Ensuring that UDP TURN servers are always used as STUN servers.

webrtc/base/natsocketfactory.cc

 /*
  *  Copyright 2004 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 161 matching lines @@
     if (result >= 0) {
       ASSERT(remote_addr == server_addr_);
 
       // TODO: we need better framing so we know how many bytes we can
       // return before we need to read the next address. For UDP, this will be
       // fine as long as the reader always reads everything in the packet.
       ASSERT((size_t)result < size_);
 
       // Decode the wire packet into the actual results.
       SocketAddress real_remote_addr;
-      size_t addrlength =
-          UnpackAddressFromNAT(buf_, result, &real_remote_addr);
+      size_t addrlength = UnpackAddressFromNAT(buf_, result, &real_remote_addr);
       memcpy(data, buf_ + addrlength, result - addrlength);
 
       // Make sure this packet should be delivered before returning it.
       if (!connected_ || (real_remote_addr == remote_addr_)) {
         if (out_addr)
           *out_addr = real_remote_addr;
         result = result - static_cast<int>(addrlength);
       } else {
         LOG(LS_ERROR) << "Dropping packet from unknown remote address: "
                       << real_remote_addr.ToString();
@@ skipping 29 matching lines @@
   }
   int EstimateMTU(uint16* mtu) override { return socket_->EstimateMTU(mtu); }
   int GetOption(Option opt, int* value) override {
     return socket_->GetOption(opt, value);
   }
   int SetOption(Option opt, int value) override {
     return socket_->SetOption(opt, value);
   }
 
   void OnConnectEvent(AsyncSocket* socket) {
-    // If we're NATed, we need to send a request with the real addr to use.
+    // If we're NATed, we need to send a message with the real addr to use.
     ASSERT(socket == socket_);
     if (server_addr_.IsNil()) {
       connected_ = true;
       SignalConnectEvent(this);
     } else {
       SendConnectRequest();
     }
   }
   void OnReadEvent(AsyncSocket* socket) {
     // If we're NATed, we need to process the connect reply.
@@ skipping 18 matching lines @@
   void Grow(size_t new_size) {
     if (size_ < new_size) {
       delete[] buf_;
       size_ = new_size;
       buf_ = new char[size_];
     }
   }
 
   // Sends the destination address to the server to tell it to connect.
   void SendConnectRequest() {
-    char buf[256];
+    char buf[kNATEncodedIPv6AddressSize];
     size_t length = PackAddressForNAT(buf, ARRAY_SIZE(buf), remote_addr_);
     socket_->Send(buf, length);
   }
 
   // Handles the byte sent back from the server and fires the appropriate event.
   void HandleConnectReply() {
     char code;
     socket_->Recv(&code, sizeof(code));
     if (code == 0) {
+      connected_ = true;
       SignalConnectEvent(this);
     } else {
       Close();
       SignalCloseEvent(this, code);
     }
   }
 
   NATInternalSocketFactory* sf_;
   int family_;
   int type_;
   bool connected_;
   SocketAddress remote_addr_;
   SocketAddress server_addr_;  // address of the NAT server
   AsyncSocket* socket_;
   char* buf_;
   size_t size_;
 };
 
 // NATSocketFactory
 NATSocketFactory::NATSocketFactory(SocketFactory* factory,
-                                   const SocketAddress& nat_addr)
-    : factory_(factory), nat_addr_(nat_addr) {
+                                   const SocketAddress& nat_udp_addr,
+                                   const SocketAddress& nat_tcp_addr)
+    : factory_(factory), nat_udp_addr_(nat_udp_addr),
+      nat_tcp_addr_(nat_tcp_addr) {
 }
 
 Socket* NATSocketFactory::CreateSocket(int type) {
   return CreateSocket(AF_INET, type);
 }
 
 Socket* NATSocketFactory::CreateSocket(int family, int type) {
   return new NATSocket(this, family, type);
 }
 
 AsyncSocket* NATSocketFactory::CreateAsyncSocket(int type) {
   return CreateAsyncSocket(AF_INET, type);
 }
 
 AsyncSocket* NATSocketFactory::CreateAsyncSocket(int family, int type) {
   return new NATSocket(this, family, type);
 }
 
 AsyncSocket* NATSocketFactory::CreateInternalSocket(int family, int type,
     const SocketAddress& local_addr, SocketAddress* nat_addr) {
-  *nat_addr = nat_addr_;
+  if (type == SOCK_STREAM) {
+    *nat_addr = nat_tcp_addr_;
+  } else {
+    *nat_addr = nat_udp_addr_;
+  }
   return factory_->CreateAsyncSocket(family, type);
 }
 
 // NATSocketServer
 NATSocketServer::NATSocketServer(SocketServer* server)
     : server_(server), msg_queue_(NULL) {
 }
 
 NATSocketServer::Translator* NATSocketServer::GetTranslator(
     const SocketAddress& ext_ip) {
@@ skipping 43 matching lines @@
   server_->WakeUp();
 }
 
 AsyncSocket* NATSocketServer::CreateInternalSocket(int family, int type,
     const SocketAddress& local_addr, SocketAddress* nat_addr) {
   AsyncSocket* socket = NULL;
   Translator* nat = nats_.FindClient(local_addr);
   if (nat) {
     socket = nat->internal_factory()->CreateAsyncSocket(family, type);
     *nat_addr = (type == SOCK_STREAM) ?
-        nat->internal_tcp_address() : nat->internal_address();
+        nat->internal_tcp_address() : nat->internal_udp_address();
   } else {
     socket = server_->CreateAsyncSocket(family, type);
   }
   return socket;
 }
 
 // NATSocketServer::Translator
 NATSocketServer::Translator::Translator(
     NATSocketServer* server, NATType type, const SocketAddress& int_ip,
     SocketFactory* ext_factory, const SocketAddress& ext_ip)
     : server_(server) {
   // Create a new private network, and a NATServer running on the private
   // network that bridges to the external network. Also tell the private
   // network to use the same message queue as us.
   VirtualSocketServer* internal_server = new VirtualSocketServer(server_);
   internal_server->SetMessageQueue(server_->queue());
   internal_factory_.reset(internal_server);
-  nat_server_.reset(new NATServer(type, internal_server, int_ip,
+  nat_server_.reset(new NATServer(type, internal_server, int_ip, int_ip,
                                   ext_factory, ext_ip));
 }
 
 NATSocketServer::Translator::~Translator() = default;
 
 NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
     const SocketAddress& ext_ip) {
   return nats_.Get(ext_ip);
 }
 
@@ skipping 69 matching lines @@
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
   Translator* nat = NULL;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
   return nat;
 }
 
 }  // namespace rtc