Fix IPv6 support 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 273 matching lines @@
     server_address_.address.SetPort(TURN_DEFAULT_PORT);
   }
 
   if (server_address_.address.IsUnresolvedIP()) {
     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) << "IP address family does not match: "
                     << "server: " << server_address_.address.family()
-                    << "local: " << ip().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();
@@ skipping 126 matching lines @@
   } else {
     delete socket_;
   }
   socket_ = NULL;
 
   ResetNonce();
   PrepareAddress();
   ++allocate_mismatch_retries_;
 }
 
-Connection* TurnPort::CreateConnection(const Candidate& address,
+Connection* TurnPort::CreateConnection(const Candidate& remote_candidate,
                                        CandidateOrigin origin) {
   // TURN-UDP can only connect to UDP candidates.
-  if (!SupportsProtocol(address.protocol())) {
+  if (!SupportsProtocol(remote_candidate.protocol())) {
     return NULL;
   }
 
-  if (!IsCompatibleAddress(address.address())) {
-    return NULL;
-  }
-
   if (state_ == STATE_DISCONNECTED) {
     return NULL;
   }
 
   // Create an entry, if needed, so we can get our permissions set up correctly.
-  CreateOrRefreshEntry(address.address());
+  CreateOrRefreshEntry(remote_candidate.address());
 
   // A TURN port will have two candiates, STUN and TURN. STUN may not
   // present in all cases. If present stun candidate will be added first
   // and TURN candidate later.
   for (size_t index = 0; index < Candidates().size(); ++index) {
-    if (Candidates()[index].type() == RELAY_PORT_TYPE) {
-      ProxyConnection* conn = new ProxyConnection(this, index, address);
+    const Candidate& local_candidate = Candidates()[index];
+    if (local_candidate.type() == RELAY_PORT_TYPE &&
+        AddressFamilyMatch(local_candidate, remote_candidate)) {
+      ProxyConnection* conn =
+          new ProxyConnection(this, index, remote_candidate);
       AddOrReplaceConnection(conn);
       return conn;
     }
   }
   return NULL;
 }
 
 bool TurnPort::DestroyConnection(const rtc::SocketAddress& address) {
   Connection* conn = GetConnection(address);
   if (conn != nullptr) {
     conn->Destroy();
     return true;
   }
   return false;
 }
 
+bool TurnPort::AddressFamilyMatch(const Candidate& local_candidate,
+                                  const Candidate& remote_candidate) const {

[pthatcher1, 2016/06/21 05:26:54]

This can just be a static function.  It doesn't need to be a method of the
class.

And a more proper name would be "CandidateAddressesCompatible".

But you may consider just inlining it since you only call it once.

[honghaiz3, 2016/06/21 18:36:06]

Just inlined it. 

+  return local_candidate.address().family() ==
+         remote_candidate.address().family();
+}
+
 int TurnPort::SetOption(rtc::Socket::Option opt, int value) {
   if (!socket_) {
     // If socket is not created yet, these options will be applied during socket
     // creation.
     socket_options_[opt] = value;
     return 0;
   }
   return socket_->SetOption(opt, value);
 }
 
@@ skipping 1035 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->DestroyConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->DestroyConnection(ext_addr_);
 }
 }  // namespace cricket