Fix a Turn TCP port issue.

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 154 matching lines @@
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    rtc::AsyncPacketSocket* socket,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
                    const std::string& origin)
-    : Port(thread, factory, network, socket->GetLocalAddress().ipaddr(),
-           username, password),
+    : Port(thread,
+           factory,
+           network,
+           socket->GetLocalAddress().ipaddr(),
+           username,
+           password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(socket),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
-      connected_(false),
+      state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    const rtc::IPAddress& ip,
                    uint16 min_port,
                    uint16 max_port,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
                    const std::string& origin)
-    : Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port,
-           username, password),
+    : Port(thread,
+           RELAY_PORT_TYPE,
+           factory,
+           network,
+           ip,
+           min_port,
+           max_port,
+           username,
+           password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(NULL),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
-      connected_(false),
+      state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
 TurnPort::~TurnPort() {
   // TODO(juberti): Should this even be necessary?
 
   // release the allocation by sending a refresh with
   // lifetime 0.
-  if (connected_) {
+  if (ready()) {
     TurnRefreshRequest bye(this);
     bye.set_lifetime(0);
     SendRequest(&bye, 0);
   }
 
   while (!entries_.empty()) {
     DestroyEntry(entries_.front()->address());
   }
   if (resolver_) {
     resolver_->Destroy(false);
@@ skipping 19 matching lines @@
   if (!server_address_.address.port()) {
     // We will set default TURN port, if no port is set in the address.
     server_address_.address.SetPort(TURN_DEFAULT_PORT);
   }
 
   if (server_address_.address.IsUnresolved()) {
     ResolveTurnAddress(server_address_.address);
   } else {
     // If protocol family of server address doesn't match with local, return.
     if (!IsCompatibleAddress(server_address_.address)) {
-      LOG(LS_ERROR) << "Server IP address family does not match with "
-                    << "local host address family type";
+      LOG(LS_ERROR) << "IP address family does not match: "
+                    << "server: " << server_address_.address.family()
+                    << "local: " << ip().family();
       OnAllocateError();
       return;
     }
 
     // Insert the current address to prevent redirection pingpong.
     attempted_server_addresses_.insert(server_address_.address);
 
     LOG_J(LS_INFO, this) << "Trying to connect to TURN server via "
                          << ProtoToString(server_address_.proto) << " @ "
                          << server_address_.address.ToSensitiveString();
     if (!CreateTurnClientSocket()) {
+      LOG(LS_ERROR) << "Failed to create TURN client socket";
       OnAllocateError();
-    } else if (server_address_.proto == PROTO_UDP) {
+      return;
+    }
+    if (server_address_.proto == PROTO_UDP) {
       // If its UDP, send AllocateRequest now.
       // For TCP and TLS AllcateRequest will be sent by OnSocketConnect.
       SendRequest(new TurnAllocateRequest(this), 0);
     }
   }
 }
 
 bool TurnPort::CreateTurnClientSocket() {
   ASSERT(!socket_ || SharedSocket());
 
@@ skipping 23 matching lines @@
     socket_->SetOption(iter->first, iter->second);
   }
 
   if (!SharedSocket()) {
     // If socket is shared, AllocationSequence will receive the packet.
     socket_->SignalReadPacket.connect(this, &TurnPort::OnReadPacket);
   }
 
   socket_->SignalReadyToSend.connect(this, &TurnPort::OnReadyToSend);
 
+  // TCP port is ready to send stun requests after the socket is connected,
+  // while UDP port is ready to do so once the socket is created.
   if (server_address_.proto == PROTO_TCP) {
     socket_->SignalConnect.connect(this, &TurnPort::OnSocketConnect);
     socket_->SignalClose.connect(this, &TurnPort::OnSocketClose);
+  } else {
+    state_ = STATE_CONNECTED;
   }
   return true;
 }
 
 void TurnPort::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
   ASSERT(server_address_.proto == PROTO_TCP);
   // Do not use this port if the socket bound to a different address than
   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
   // given a binding address, and the platform is expected to pick the
   // correct local address.
@@ skipping 18 matching lines @@
     } else {
       LOG(LS_WARNING) << "Socket is bound to a different address:"
                       << socket->GetLocalAddress().ipaddr().ToString()
                       << ", rather then the local port:" << ip().ToString()
                       << ". Discarding TURN port.";
       OnAllocateError();
       return;
     }
   }
 
+  state_ = STATE_CONNECTED;  // It is ready to send stun requests.
   if (server_address_.address.IsUnresolved()) {
     server_address_.address = socket_->GetRemoteAddress();
   }
 
   LOG(LS_INFO) << "TurnPort connected to " << socket->GetRemoteAddress()
                << " using tcp.";
   SendRequest(new TurnAllocateRequest(this), 0);
 }
 
 void TurnPort::OnSocketClose(rtc::AsyncPacketSocket* socket, int error) {
   LOG_J(LS_WARNING, this) << "Connection with server failed, error=" << error;
   ASSERT(socket == socket_);
-  if (!connected_) {
+  if (!ready()) {
     OnAllocateError();
   }
-  connected_ = false;
+  request_manager_.Clear();
+  state_ = STATE_DISCONNECTED;
 }
 
 void TurnPort::OnAllocateMismatch() {
   if (allocate_mismatch_retries_ >= MAX_ALLOCATE_MISMATCH_RETRIES) {
     LOG_J(LS_WARNING, this) << "Giving up on the port after "
                             << allocate_mismatch_retries_
                             << " retries for STUN_ERROR_ALLOCATION_MISMATCH";
     OnAllocateError();
     return;
   }
@@ skipping 66 matching lines @@
 int TurnPort::GetError() {
   return error_;
 }
 
 int TurnPort::SendTo(const void* data, size_t size,
                      const rtc::SocketAddress& addr,
                      const rtc::PacketOptions& options,
                      bool payload) {
   // Try to find an entry for this specific address; we should have one.
   TurnEntry* entry = FindEntry(addr);
-  ASSERT(entry != NULL);
   if (!entry) {
+    LOG(LS_ERROR) << "Did not find the TurnEntry for address " << addr;
     return 0;
   }
 
-  if (!connected()) {
+  if (!ready()) {
     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
 
   // Send the actual contents to the server using the usual mechanism.
   int sent = entry->Send(data, size, payload, options);
   if (sent <= 0) {
     return SOCKET_ERROR;
   }
 
@@ skipping 48 matching lines @@
         !StunMessage::ValidateMessageIntegrity(data, size, hash())) {
       LOG_J(LS_WARNING, this) << "Received TURN message with invalid "
                               << "message integrity, msg_type=" << msg_type;
       return;
     }
     request_manager_.CheckResponse(data, size);
   }
 }
 
 void TurnPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
-  if (connected_) {
+  if (ready()) {
     Port::OnReadyToSend();
   }
 }
 
 
 // Update current server address port with the alternate server address port.
 bool TurnPort::SetAlternateServer(const rtc::SocketAddress& address) {
   // Check if we have seen this address before and reject if we did.
   AttemptedServerSet::iterator iter = attempted_server_addresses_.find(address);
   if (iter != attempted_server_addresses_.end()) {
@@ skipping 59 matching lines @@
   // Signal needs both resolved and unresolved address. After signal is sent
   // we can copy resolved address back into |server_address_|.
   SignalResolvedServerAddress(this, server_address_.address,
                               resolved_address);
   server_address_.address = resolved_address;
   PrepareAddress();
 }
 
 void TurnPort::OnSendStunPacket(const void* data, size_t size,
                                 StunRequest* request) {
+  ASSERT(connected());
   rtc::PacketOptions options(DefaultDscpValue());
   if (Send(data, size, options) < 0) {
     LOG_J(LS_ERROR, this) << "Failed to send TURN message, err="
                           << socket_->GetError();
   }
 }
 
 void TurnPort::OnStunAddress(const rtc::SocketAddress& address) {
   // STUN Port will discover STUN candidate, as it's supplied with first TURN
   // server address.
   // Why not using this address? - P2PTransportChannel will start creating
   // connections after first candidate, which means it could start creating the
   // connections before TURN candidate added. For that to handle, we need to
   // supply STUN candidate from this port to UDPPort, and TurnPort should have
   // handle to UDPPort to pass back the address.
 }
 
 void TurnPort::OnAllocateSuccess(const rtc::SocketAddress& address,
                                  const rtc::SocketAddress& stun_address) {
-  connected_ = true;
+  state_ = STATE_READY;
 
   rtc::SocketAddress related_address = stun_address;
     if (!(candidate_filter() & CF_REFLEXIVE)) {
     // If candidate filter only allows relay type of address, empty raddr to
     // avoid local address leakage.
     related_address = rtc::EmptySocketAddressWithFamily(stun_address.family());
   }
 
   // For relayed candidate, Base is the candidate itself.
   AddAddress(address,          // Candidate address.
@@ skipping 611 matching lines @@
                      const rtc::SocketAddress& ext_addr)
     : port_(port),
       channel_id_(channel_id),
       ext_addr_(ext_addr),
       state_(STATE_UNBOUND) {
   // Creating permission for |ext_addr_|.
   SendCreatePermissionRequest();
 }
 
 void TurnEntry::SendCreatePermissionRequest() {
-  port_->SendRequest(new TurnCreatePermissionRequest(
-      port_, this, ext_addr_), 0);
+  if (port_->connected()) {

[juberti1, 2015/07/31 06:04:42]

Might be better to return NULL from CreateConnection, so that we don't silently
eat permission requests.

[honghaiz3, 2015/07/31 15:39:36]

Done. This is a different version I prepared yesterday (did not send out).

+    port_->SendRequest(new TurnCreatePermissionRequest(port_, this, ext_addr_),
+                       0);
+  }
 }
 
 void TurnEntry::SendChannelBindRequest(int delay) {
   port_->SendRequest(new TurnChannelBindRequest(
       port_, this, channel_id_, ext_addr_), delay);
 }
 
 int TurnEntry::Send(const void* data, size_t size, bool payload,
                     const rtc::PacketOptions& options) {
   rtc::ByteBuffer buf;
@@ skipping 54 matching lines @@
   // bind request as per http://tools.ietf.org/html/rfc5766#section-11.3
   if (code == STUN_ERROR_STALE_NONCE) {
     if (port_->UpdateNonce(response)) {
       // Send channel bind request with fresh nonce.
       SendChannelBindRequest(0);
     }
   }
 }
 
 }  // namespace cricket