1/* 2 * libjingle 3 * Copyright 2004--2005, Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28#include "talk/p2p/base/relayport.h" 29#include "webrtc/base/asyncpacketsocket.h" 30#include "webrtc/base/helpers.h" 31#include "webrtc/base/logging.h" 32 33namespace cricket { 34 35static const uint32 kMessageConnectTimeout = 1; 36static const int kKeepAliveDelay = 10 * 60 * 1000; 37static const int kRetryTimeout = 50 * 1000; // ICE says 50 secs 38// How long to wait for a socket to connect to remote host in milliseconds 39// before trying another connection. 40static const int kSoftConnectTimeoutMs = 3 * 1000; 41 42// Handles a connection to one address/port/protocol combination for a 43// particular RelayEntry. 44class RelayConnection : public sigslot::has_slots<> { 45 public: 46 RelayConnection(const ProtocolAddress* protocol_address, 47 rtc::AsyncPacketSocket* socket, 48 rtc::Thread* thread); 49 ~RelayConnection(); 50 rtc::AsyncPacketSocket* socket() const { return socket_; } 51 52 const ProtocolAddress* protocol_address() { 53 return protocol_address_; 54 } 55 56 rtc::SocketAddress GetAddress() const { 57 return protocol_address_->address; 58 } 59 60 ProtocolType GetProtocol() const { 61 return protocol_address_->proto; 62 } 63 64 int SetSocketOption(rtc::Socket::Option opt, int value); 65 66 // Validates a response to a STUN allocate request. 67 bool CheckResponse(StunMessage* msg); 68 69 // Sends data to the relay server. 70 int Send(const void* pv, size_t cb, const rtc::PacketOptions& options); 71 72 // Sends a STUN allocate request message to the relay server. 73 void SendAllocateRequest(RelayEntry* entry, int delay); 74 75 // Return the latest error generated by the socket. 76 int GetError() { return socket_->GetError(); } 77 78 // Called on behalf of a StunRequest to write data to the socket. This is 79 // already STUN intended for the server, so no wrapping is necessary. 80 void OnSendPacket(const void* data, size_t size, StunRequest* req); 81 82 private: 83 rtc::AsyncPacketSocket* socket_; 84 const ProtocolAddress* protocol_address_; 85 StunRequestManager *request_manager_; 86}; 87 88// Manages a number of connections to the relayserver, one for each 89// available protocol. We aim to use each connection for only a 90// specific destination address so that we can avoid wrapping every 91// packet in a STUN send / data indication. 92class RelayEntry : public rtc::MessageHandler, 93 public sigslot::has_slots<> { 94 public: 95 RelayEntry(RelayPort* port, const rtc::SocketAddress& ext_addr); 96 ~RelayEntry(); 97 98 RelayPort* port() { return port_; } 99 100 const rtc::SocketAddress& address() const { return ext_addr_; } 101 void set_address(const rtc::SocketAddress& addr) { ext_addr_ = addr; } 102 103 bool connected() const { return connected_; } 104 bool locked() const { return locked_; } 105 106 // Returns the last error on the socket of this entry. 107 int GetError(); 108 109 // Returns the most preferred connection of the given 110 // ones. Connections are rated based on protocol in the order of: 111 // UDP, TCP and SSLTCP, where UDP is the most preferred protocol 112 static RelayConnection* GetBestConnection(RelayConnection* conn1, 113 RelayConnection* conn2); 114 115 // Sends the STUN requests to the server to initiate this connection. 116 void Connect(); 117 118 // Called when this entry becomes connected. The address given is the one 119 // exposed to the outside world on the relay server. 120 void OnConnect(const rtc::SocketAddress& mapped_addr, 121 RelayConnection* socket); 122 123 // Sends a packet to the given destination address using the socket of this 124 // entry. This will wrap the packet in STUN if necessary. 125 int SendTo(const void* data, size_t size, 126 const rtc::SocketAddress& addr, 127 const rtc::PacketOptions& options); 128 129 // Schedules a keep-alive allocate request. 130 void ScheduleKeepAlive(); 131 132 void SetServerIndex(size_t sindex) { server_index_ = sindex; } 133 134 // Sets this option on the socket of each connection. 135 int SetSocketOption(rtc::Socket::Option opt, int value); 136 137 size_t ServerIndex() const { return server_index_; } 138 139 // Try a different server address 140 void HandleConnectFailure(rtc::AsyncPacketSocket* socket); 141 142 // Implementation of the MessageHandler Interface. 143 virtual void OnMessage(rtc::Message *pmsg); 144 145 private: 146 RelayPort* port_; 147 rtc::SocketAddress ext_addr_; 148 size_t server_index_; 149 bool connected_; 150 bool locked_; 151 RelayConnection* current_connection_; 152 153 // Called when a TCP connection is established or fails 154 void OnSocketConnect(rtc::AsyncPacketSocket* socket); 155 void OnSocketClose(rtc::AsyncPacketSocket* socket, int error); 156 157 // Called when a packet is received on this socket. 158 void OnReadPacket( 159 rtc::AsyncPacketSocket* socket, 160 const char* data, size_t size, 161 const rtc::SocketAddress& remote_addr, 162 const rtc::PacketTime& packet_time); 163 // Called when the socket is currently able to send. 164 void OnReadyToSend(rtc::AsyncPacketSocket* socket); 165 166 // Sends the given data on the socket to the server with no wrapping. This 167 // returns the number of bytes written or -1 if an error occurred. 168 int SendPacket(const void* data, size_t size, 169 const rtc::PacketOptions& options); 170}; 171 172// Handles an allocate request for a particular RelayEntry. 173class AllocateRequest : public StunRequest { 174 public: 175 AllocateRequest(RelayEntry* entry, RelayConnection* connection); 176 virtual ~AllocateRequest() {} 177 178 virtual void Prepare(StunMessage* request); 179 180 virtual int GetNextDelay(); 181 182 virtual void OnResponse(StunMessage* response); 183 virtual void OnErrorResponse(StunMessage* response); 184 virtual void OnTimeout(); 185 186 private: 187 RelayEntry* entry_; 188 RelayConnection* connection_; 189 uint32 start_time_; 190}; 191 192RelayPort::RelayPort( 193 rtc::Thread* thread, rtc::PacketSocketFactory* factory, 194 rtc::Network* network, const rtc::IPAddress& ip, 195 int min_port, int max_port, const std::string& username, 196 const std::string& password) 197 : Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port, 198 username, password), 199 ready_(false), 200 error_(0) { 201 entries_.push_back( 202 new RelayEntry(this, rtc::SocketAddress())); 203 // TODO: set local preference value for TCP based candidates. 204} 205 206RelayPort::~RelayPort() { 207 for (size_t i = 0; i < entries_.size(); ++i) 208 delete entries_[i]; 209 thread()->Clear(this); 210} 211 212void RelayPort::AddServerAddress(const ProtocolAddress& addr) { 213 // Since HTTP proxies usually only allow 443, 214 // let's up the priority on PROTO_SSLTCP 215 if (addr.proto == PROTO_SSLTCP && 216 (proxy().type == rtc::PROXY_HTTPS || 217 proxy().type == rtc::PROXY_UNKNOWN)) { 218 server_addr_.push_front(addr); 219 } else { 220 server_addr_.push_back(addr); 221 } 222} 223 224void RelayPort::AddExternalAddress(const ProtocolAddress& addr) { 225 std::string proto_name = ProtoToString(addr.proto); 226 for (std::vector<ProtocolAddress>::iterator it = external_addr_.begin(); 227 it != external_addr_.end(); ++it) { 228 if ((it->address == addr.address) && (it->proto == addr.proto)) { 229 LOG(INFO) << "Redundant relay address: " << proto_name 230 << " @ " << addr.address.ToSensitiveString(); 231 return; 232 } 233 } 234 external_addr_.push_back(addr); 235} 236 237void RelayPort::SetReady() { 238 if (!ready_) { 239 std::vector<ProtocolAddress>::iterator iter; 240 for (iter = external_addr_.begin(); 241 iter != external_addr_.end(); ++iter) { 242 std::string proto_name = ProtoToString(iter->proto); 243 // In case of Gturn, related address is set to null socket address. 244 // This is due to as mapped address stun attribute is used for allocated 245 // address. 246 AddAddress(iter->address, iter->address, rtc::SocketAddress(), 247 proto_name, "", RELAY_PORT_TYPE, 248 ICE_TYPE_PREFERENCE_RELAY, 0, false); 249 } 250 ready_ = true; 251 SignalPortComplete(this); 252 } 253} 254 255const ProtocolAddress * RelayPort::ServerAddress(size_t index) const { 256 if (index < server_addr_.size()) 257 return &server_addr_[index]; 258 return NULL; 259} 260 261bool RelayPort::HasMagicCookie(const char* data, size_t size) { 262 if (size < 24 + sizeof(TURN_MAGIC_COOKIE_VALUE)) { 263 return false; 264 } else { 265 return memcmp(data + 24, 266 TURN_MAGIC_COOKIE_VALUE, 267 sizeof(TURN_MAGIC_COOKIE_VALUE)) == 0; 268 } 269} 270 271void RelayPort::PrepareAddress() { 272 // We initiate a connect on the first entry. If this completes, it will fill 273 // in the server address as the address of this port. 274 ASSERT(entries_.size() == 1); 275 entries_[0]->Connect(); 276 ready_ = false; 277} 278 279Connection* RelayPort::CreateConnection(const Candidate& address, 280 CandidateOrigin origin) { 281 // We only create conns to non-udp sockets if they are incoming on this port 282 if ((address.protocol() != UDP_PROTOCOL_NAME) && 283 (origin != ORIGIN_THIS_PORT)) { 284 return 0; 285 } 286 287 // We don't support loopback on relays 288 if (address.type() == Type()) { 289 return 0; 290 } 291 292 if (!IsCompatibleAddress(address.address())) { 293 return 0; 294 } 295 296 size_t index = 0; 297 for (size_t i = 0; i < Candidates().size(); ++i) { 298 const Candidate& local = Candidates()[i]; 299 if (local.protocol() == address.protocol()) { 300 index = i; 301 break; 302 } 303 } 304 305 Connection * conn = new ProxyConnection(this, index, address); 306 AddConnection(conn); 307 return conn; 308} 309 310int RelayPort::SendTo(const void* data, size_t size, 311 const rtc::SocketAddress& addr, 312 const rtc::PacketOptions& options, 313 bool payload) { 314 // Try to find an entry for this specific address. Note that the first entry 315 // created was not given an address initially, so it can be set to the first 316 // address that comes along. 317 RelayEntry* entry = 0; 318 319 for (size_t i = 0; i < entries_.size(); ++i) { 320 if (entries_[i]->address().IsNil() && payload) { 321 entry = entries_[i]; 322 entry->set_address(addr); 323 break; 324 } else if (entries_[i]->address() == addr) { 325 entry = entries_[i]; 326 break; 327 } 328 } 329 330 // If we did not find one, then we make a new one. This will not be useable 331 // until it becomes connected, however. 332 if (!entry && payload) { 333 entry = new RelayEntry(this, addr); 334 if (!entries_.empty()) { 335 entry->SetServerIndex(entries_[0]->ServerIndex()); 336 } 337 entry->Connect(); 338 entries_.push_back(entry); 339 } 340 341 // If the entry is connected, then we can send on it (though wrapping may 342 // still be necessary). Otherwise, we can't yet use this connection, so we 343 // default to the first one. 344 if (!entry || !entry->connected()) { 345 ASSERT(!entries_.empty()); 346 entry = entries_[0]; 347 if (!entry->connected()) { 348 error_ = EWOULDBLOCK; 349 return SOCKET_ERROR; 350 } 351 } 352 353 // Send the actual contents to the server using the usual mechanism. 354 int sent = entry->SendTo(data, size, addr, options); 355 if (sent <= 0) { 356 ASSERT(sent < 0); 357 error_ = entry->GetError(); 358 return SOCKET_ERROR; 359 } 360 // The caller of the function is expecting the number of user data bytes, 361 // rather than the size of the packet. 362 return static_cast<int>(size); 363} 364 365int RelayPort::SetOption(rtc::Socket::Option opt, int value) { 366 int result = 0; 367 for (size_t i = 0; i < entries_.size(); ++i) { 368 if (entries_[i]->SetSocketOption(opt, value) < 0) { 369 result = -1; 370 error_ = entries_[i]->GetError(); 371 } 372 } 373 options_.push_back(OptionValue(opt, value)); 374 return result; 375} 376 377int RelayPort::GetOption(rtc::Socket::Option opt, int* value) { 378 std::vector<OptionValue>::iterator it; 379 for (it = options_.begin(); it < options_.end(); ++it) { 380 if (it->first == opt) { 381 *value = it->second; 382 return 0; 383 } 384 } 385 return SOCKET_ERROR; 386} 387 388int RelayPort::GetError() { 389 return error_; 390} 391 392void RelayPort::OnReadPacket( 393 const char* data, size_t size, 394 const rtc::SocketAddress& remote_addr, 395 ProtocolType proto, 396 const rtc::PacketTime& packet_time) { 397 if (Connection* conn = GetConnection(remote_addr)) { 398 conn->OnReadPacket(data, size, packet_time); 399 } else { 400 Port::OnReadPacket(data, size, remote_addr, proto); 401 } 402} 403 404RelayConnection::RelayConnection(const ProtocolAddress* protocol_address, 405 rtc::AsyncPacketSocket* socket, 406 rtc::Thread* thread) 407 : socket_(socket), 408 protocol_address_(protocol_address) { 409 request_manager_ = new StunRequestManager(thread); 410 request_manager_->SignalSendPacket.connect(this, 411 &RelayConnection::OnSendPacket); 412} 413 414RelayConnection::~RelayConnection() { 415 delete request_manager_; 416 delete socket_; 417} 418 419int RelayConnection::SetSocketOption(rtc::Socket::Option opt, 420 int value) { 421 if (socket_) { 422 return socket_->SetOption(opt, value); 423 } 424 return 0; 425} 426 427bool RelayConnection::CheckResponse(StunMessage* msg) { 428 return request_manager_->CheckResponse(msg); 429} 430 431void RelayConnection::OnSendPacket(const void* data, size_t size, 432 StunRequest* req) { 433 // TODO(mallinath) Find a way to get DSCP value from Port. 434 rtc::PacketOptions options; // Default dscp set to NO_CHANGE. 435 int sent = socket_->SendTo(data, size, GetAddress(), options); 436 if (sent <= 0) { 437 LOG(LS_VERBOSE) << "OnSendPacket: failed sending to " << GetAddress() << 438 strerror(socket_->GetError()); 439 ASSERT(sent < 0); 440 } 441} 442 443int RelayConnection::Send(const void* pv, size_t cb, 444 const rtc::PacketOptions& options) { 445 return socket_->SendTo(pv, cb, GetAddress(), options); 446} 447 448void RelayConnection::SendAllocateRequest(RelayEntry* entry, int delay) { 449 request_manager_->SendDelayed(new AllocateRequest(entry, this), delay); 450} 451 452RelayEntry::RelayEntry(RelayPort* port, 453 const rtc::SocketAddress& ext_addr) 454 : port_(port), ext_addr_(ext_addr), 455 server_index_(0), connected_(false), locked_(false), 456 current_connection_(NULL) { 457} 458 459RelayEntry::~RelayEntry() { 460 // Remove all RelayConnections and dispose sockets. 461 delete current_connection_; 462 current_connection_ = NULL; 463} 464 465void RelayEntry::Connect() { 466 // If we're already connected, return. 467 if (connected_) 468 return; 469 470 // If we've exhausted all options, bail out. 471 const ProtocolAddress* ra = port()->ServerAddress(server_index_); 472 if (!ra) { 473 LOG(LS_WARNING) << "No more relay addresses left to try"; 474 return; 475 } 476 477 // Remove any previous connection. 478 if (current_connection_) { 479 port()->thread()->Dispose(current_connection_); 480 current_connection_ = NULL; 481 } 482 483 // Try to set up our new socket. 484 LOG(LS_INFO) << "Connecting to relay via " << ProtoToString(ra->proto) << 485 " @ " << ra->address.ToSensitiveString(); 486 487 rtc::AsyncPacketSocket* socket = NULL; 488 489 if (ra->proto == PROTO_UDP) { 490 // UDP sockets are simple. 491 socket = port_->socket_factory()->CreateUdpSocket( 492 rtc::SocketAddress(port_->ip(), 0), 493 port_->min_port(), port_->max_port()); 494 } else if (ra->proto == PROTO_TCP || ra->proto == PROTO_SSLTCP) { 495 int opts = (ra->proto == PROTO_SSLTCP) ? 496 rtc::PacketSocketFactory::OPT_SSLTCP : 0; 497 socket = port_->socket_factory()->CreateClientTcpSocket( 498 rtc::SocketAddress(port_->ip(), 0), ra->address, 499 port_->proxy(), port_->user_agent(), opts); 500 } else { 501 LOG(LS_WARNING) << "Unknown protocol (" << ra->proto << ")"; 502 } 503 504 if (!socket) { 505 LOG(LS_WARNING) << "Socket creation failed"; 506 } 507 508 // If we failed to get a socket, move on to the next protocol. 509 if (!socket) { 510 port()->thread()->Post(this, kMessageConnectTimeout); 511 return; 512 } 513 514 // Otherwise, create the new connection and configure any socket options. 515 socket->SignalReadPacket.connect(this, &RelayEntry::OnReadPacket); 516 socket->SignalReadyToSend.connect(this, &RelayEntry::OnReadyToSend); 517 current_connection_ = new RelayConnection(ra, socket, port()->thread()); 518 for (size_t i = 0; i < port_->options().size(); ++i) { 519 current_connection_->SetSocketOption(port_->options()[i].first, 520 port_->options()[i].second); 521 } 522 523 // If we're trying UDP, start binding requests. 524 // If we're trying TCP, wait for connection with a fixed timeout. 525 if ((ra->proto == PROTO_TCP) || (ra->proto == PROTO_SSLTCP)) { 526 socket->SignalClose.connect(this, &RelayEntry::OnSocketClose); 527 socket->SignalConnect.connect(this, &RelayEntry::OnSocketConnect); 528 port()->thread()->PostDelayed(kSoftConnectTimeoutMs, this, 529 kMessageConnectTimeout); 530 } else { 531 current_connection_->SendAllocateRequest(this, 0); 532 } 533} 534 535int RelayEntry::GetError() { 536 if (current_connection_ != NULL) { 537 return current_connection_->GetError(); 538 } 539 return 0; 540} 541 542RelayConnection* RelayEntry::GetBestConnection(RelayConnection* conn1, 543 RelayConnection* conn2) { 544 return conn1->GetProtocol() <= conn2->GetProtocol() ? conn1 : conn2; 545} 546 547void RelayEntry::OnConnect(const rtc::SocketAddress& mapped_addr, 548 RelayConnection* connection) { 549 // We are connected, notify our parent. 550 ProtocolType proto = PROTO_UDP; 551 LOG(INFO) << "Relay allocate succeeded: " << ProtoToString(proto) 552 << " @ " << mapped_addr.ToSensitiveString(); 553 connected_ = true; 554 555 port_->AddExternalAddress(ProtocolAddress(mapped_addr, proto)); 556 port_->SetReady(); 557} 558 559int RelayEntry::SendTo(const void* data, size_t size, 560 const rtc::SocketAddress& addr, 561 const rtc::PacketOptions& options) { 562 // If this connection is locked to the address given, then we can send the 563 // packet with no wrapper. 564 if (locked_ && (ext_addr_ == addr)) 565 return SendPacket(data, size, options); 566 567 // Otherwise, we must wrap the given data in a STUN SEND request so that we 568 // can communicate the destination address to the server. 569 // 570 // Note that we do not use a StunRequest here. This is because there is 571 // likely no reason to resend this packet. If it is late, we just drop it. 572 // The next send to this address will try again. 573 574 RelayMessage request; 575 request.SetType(STUN_SEND_REQUEST); 576 577 StunByteStringAttribute* magic_cookie_attr = 578 StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE); 579 magic_cookie_attr->CopyBytes(TURN_MAGIC_COOKIE_VALUE, 580 sizeof(TURN_MAGIC_COOKIE_VALUE)); 581 VERIFY(request.AddAttribute(magic_cookie_attr)); 582 583 StunByteStringAttribute* username_attr = 584 StunAttribute::CreateByteString(STUN_ATTR_USERNAME); 585 username_attr->CopyBytes(port_->username_fragment().c_str(), 586 port_->username_fragment().size()); 587 VERIFY(request.AddAttribute(username_attr)); 588 589 StunAddressAttribute* addr_attr = 590 StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS); 591 addr_attr->SetIP(addr.ipaddr()); 592 addr_attr->SetPort(addr.port()); 593 VERIFY(request.AddAttribute(addr_attr)); 594 595 // Attempt to lock 596 if (ext_addr_ == addr) { 597 StunUInt32Attribute* options_attr = 598 StunAttribute::CreateUInt32(STUN_ATTR_OPTIONS); 599 options_attr->SetValue(0x1); 600 VERIFY(request.AddAttribute(options_attr)); 601 } 602 603 StunByteStringAttribute* data_attr = 604 StunAttribute::CreateByteString(STUN_ATTR_DATA); 605 data_attr->CopyBytes(data, size); 606 VERIFY(request.AddAttribute(data_attr)); 607 608 // TODO: compute the HMAC. 609 610 rtc::ByteBuffer buf; 611 request.Write(&buf); 612 613 return SendPacket(buf.Data(), buf.Length(), options); 614} 615 616void RelayEntry::ScheduleKeepAlive() { 617 if (current_connection_) { 618 current_connection_->SendAllocateRequest(this, kKeepAliveDelay); 619 } 620} 621 622int RelayEntry::SetSocketOption(rtc::Socket::Option opt, int value) { 623 // Set the option on all available sockets. 624 int socket_error = 0; 625 if (current_connection_) { 626 socket_error = current_connection_->SetSocketOption(opt, value); 627 } 628 return socket_error; 629} 630 631void RelayEntry::HandleConnectFailure( 632 rtc::AsyncPacketSocket* socket) { 633 // Make sure it's the current connection that has failed, it might 634 // be an old socked that has not yet been disposed. 635 if (!socket || 636 (current_connection_ && socket == current_connection_->socket())) { 637 if (current_connection_) 638 port()->SignalConnectFailure(current_connection_->protocol_address()); 639 640 // Try to connect to the next server address. 641 server_index_ += 1; 642 Connect(); 643 } 644} 645 646void RelayEntry::OnMessage(rtc::Message *pmsg) { 647 ASSERT(pmsg->message_id == kMessageConnectTimeout); 648 if (current_connection_) { 649 const ProtocolAddress* ra = current_connection_->protocol_address(); 650 LOG(LS_WARNING) << "Relay " << ra->proto << " connection to " << 651 ra->address << " timed out"; 652 653 // Currently we connect to each server address in sequence. If we 654 // have more addresses to try, treat this is an error and move on to 655 // the next address, otherwise give this connection more time and 656 // await the real timeout. 657 // 658 // TODO: Connect to servers in parallel to speed up connect time 659 // and to avoid giving up too early. 660 port_->SignalSoftTimeout(ra); 661 HandleConnectFailure(current_connection_->socket()); 662 } else { 663 HandleConnectFailure(NULL); 664 } 665} 666 667void RelayEntry::OnSocketConnect(rtc::AsyncPacketSocket* socket) { 668 LOG(INFO) << "relay tcp connected to " << 669 socket->GetRemoteAddress().ToSensitiveString(); 670 if (current_connection_ != NULL) { 671 current_connection_->SendAllocateRequest(this, 0); 672 } 673} 674 675void RelayEntry::OnSocketClose(rtc::AsyncPacketSocket* socket, 676 int error) { 677 PLOG(LERROR, error) << "Relay connection failed: socket closed"; 678 HandleConnectFailure(socket); 679} 680 681void RelayEntry::OnReadPacket( 682 rtc::AsyncPacketSocket* socket, 683 const char* data, size_t size, 684 const rtc::SocketAddress& remote_addr, 685 const rtc::PacketTime& packet_time) { 686 // ASSERT(remote_addr == port_->server_addr()); 687 // TODO: are we worried about this? 688 689 if (current_connection_ == NULL || socket != current_connection_->socket()) { 690 // This packet comes from an unknown address. 691 LOG(WARNING) << "Dropping packet: unknown address"; 692 return; 693 } 694 695 // If the magic cookie is not present, then this is an unwrapped packet sent 696 // by the server, The actual remote address is the one we recorded. 697 if (!port_->HasMagicCookie(data, size)) { 698 if (locked_) { 699 port_->OnReadPacket(data, size, ext_addr_, PROTO_UDP, packet_time); 700 } else { 701 LOG(WARNING) << "Dropping packet: entry not locked"; 702 } 703 return; 704 } 705 706 rtc::ByteBuffer buf(data, size); 707 RelayMessage msg; 708 if (!msg.Read(&buf)) { 709 LOG(INFO) << "Incoming packet was not STUN"; 710 return; 711 } 712 713 // The incoming packet should be a STUN ALLOCATE response, SEND response, or 714 // DATA indication. 715 if (current_connection_->CheckResponse(&msg)) { 716 return; 717 } else if (msg.type() == STUN_SEND_RESPONSE) { 718 if (const StunUInt32Attribute* options_attr = 719 msg.GetUInt32(STUN_ATTR_OPTIONS)) { 720 if (options_attr->value() & 0x1) { 721 locked_ = true; 722 } 723 } 724 return; 725 } else if (msg.type() != STUN_DATA_INDICATION) { 726 LOG(INFO) << "Received BAD stun type from server: " << msg.type(); 727 return; 728 } 729 730 // This must be a data indication. 731 732 const StunAddressAttribute* addr_attr = 733 msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2); 734 if (!addr_attr) { 735 LOG(INFO) << "Data indication has no source address"; 736 return; 737 } else if (addr_attr->family() != 1) { 738 LOG(INFO) << "Source address has bad family"; 739 return; 740 } 741 742 rtc::SocketAddress remote_addr2(addr_attr->ipaddr(), addr_attr->port()); 743 744 const StunByteStringAttribute* data_attr = msg.GetByteString(STUN_ATTR_DATA); 745 if (!data_attr) { 746 LOG(INFO) << "Data indication has no data"; 747 return; 748 } 749 750 // Process the actual data and remote address in the normal manner. 751 port_->OnReadPacket(data_attr->bytes(), data_attr->length(), remote_addr2, 752 PROTO_UDP, packet_time); 753} 754 755void RelayEntry::OnReadyToSend(rtc::AsyncPacketSocket* socket) { 756 if (connected()) { 757 port_->OnReadyToSend(); 758 } 759} 760 761int RelayEntry::SendPacket(const void* data, size_t size, 762 const rtc::PacketOptions& options) { 763 int sent = 0; 764 if (current_connection_) { 765 // We are connected, no need to send packets anywere else than to 766 // the current connection. 767 sent = current_connection_->Send(data, size, options); 768 } 769 return sent; 770} 771 772AllocateRequest::AllocateRequest(RelayEntry* entry, 773 RelayConnection* connection) 774 : StunRequest(new RelayMessage()), 775 entry_(entry), 776 connection_(connection) { 777 start_time_ = rtc::Time(); 778} 779 780void AllocateRequest::Prepare(StunMessage* request) { 781 request->SetType(STUN_ALLOCATE_REQUEST); 782 783 StunByteStringAttribute* username_attr = 784 StunAttribute::CreateByteString(STUN_ATTR_USERNAME); 785 username_attr->CopyBytes( 786 entry_->port()->username_fragment().c_str(), 787 entry_->port()->username_fragment().size()); 788 VERIFY(request->AddAttribute(username_attr)); 789} 790 791int AllocateRequest::GetNextDelay() { 792 int delay = 100 * rtc::_max(1 << count_, 2); 793 count_ += 1; 794 if (count_ == 5) 795 timeout_ = true; 796 return delay; 797} 798 799void AllocateRequest::OnResponse(StunMessage* response) { 800 const StunAddressAttribute* addr_attr = 801 response->GetAddress(STUN_ATTR_MAPPED_ADDRESS); 802 if (!addr_attr) { 803 LOG(INFO) << "Allocate response missing mapped address."; 804 } else if (addr_attr->family() != 1) { 805 LOG(INFO) << "Mapped address has bad family"; 806 } else { 807 rtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port()); 808 entry_->OnConnect(addr, connection_); 809 } 810 811 // We will do a keep-alive regardless of whether this request suceeds. 812 // This should have almost no impact on network usage. 813 entry_->ScheduleKeepAlive(); 814} 815 816void AllocateRequest::OnErrorResponse(StunMessage* response) { 817 const StunErrorCodeAttribute* attr = response->GetErrorCode(); 818 if (!attr) { 819 LOG(INFO) << "Bad allocate response error code"; 820 } else { 821 LOG(INFO) << "Allocate error response:" 822 << " code=" << attr->code() 823 << " reason='" << attr->reason() << "'"; 824 } 825 826 if (rtc::TimeSince(start_time_) <= kRetryTimeout) 827 entry_->ScheduleKeepAlive(); 828} 829 830void AllocateRequest::OnTimeout() { 831 LOG(INFO) << "Allocate request timed out"; 832 entry_->HandleConnectFailure(connection_->socket()); 833} 834 835} // namespace cricket 836