Fix IPv6 support issue.

webrtc/p2p/base/turnport.h

 /*
  *  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 14 matching lines @@
 class AsyncResolver;
 class SignalThread;
 }
 
 namespace cricket {
 
 extern const char TURN_PORT_TYPE[];
 class TurnAllocateRequest;
 class TurnEntry;
 
 class TurnPort : public Port {

[andresp, 2016/06/21 11:36:10]

I noticed every caller of Port::IsCompatibleAddress comes from a place where the
port type (udp/tcp/turnport) is known. As so I don't think Port should declare
it at all.

And if port wants to keep it declared, then turnport should implement it
properly.

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

I think IsCompatibleAddress is useful in matching the local port IP address
family vs the family type of the internal address (basically the known public
address used by a client to send TURN allocate request) of the turn server. It
is also useful when creating a connection with a remote client for non-TURN
port. It is a single implementation used by different type of Port. The only
exception is that when creating connections in TurnPort, we should not use it.
We should check local candidate family vs the remote candidate family. 
So it makes sense to me to keep its implementation at Port and use it in
subclasses of Port. 

[pthatcher1, 2016/06/21 18:50:18]

We'd have to duplicate the following logic between tcpport.cc and stunport.cc,
but maybe that's OK.

  if (family == AF_INET6 &&
      (IPIsLinkLocal(ip()) != IPIsLinkLocal(addr.ipaddr()))) {
    return false;
  }

[honghaiz3, 2016/06/21 20:06:49]

For turn port, the generated candidate family is always AF_INET now. So I think
it is not necessary to add that check (Even in the future the generated
candidate family may be ipv6, it should still be fine not having this check. 

You mentioned stunport.cc. Do we need to do anything special about stunport
here?

[pthatcher1, 2016/06/21 20:55:08]

StunPort and TcpPort both use IsCompatibleAddress and use that logic, so if we
remove IsCompatiableAddress (as Andre suggested), we'd need to duplicate that
logic in both of those places.

In other words, I'm not sure it's worth it to remove IsCompatibleAddress.

  public:
   enum PortState {
     STATE_CONNECTING,    // Initial state, cannot send any packets.
     STATE_CONNECTED,     // Socket connected, ready to send stun requests.
     STATE_READY,         // Received allocate success, can send any packets.
     STATE_DISCONNECTED,  // TCP connection died, cannot send any packets.
   };
   static TurnPort* Create(rtc::Thread* thread,
                           rtc::PacketSocketFactory* factory,
                           rtc::Network* network,
@@ skipping 33 matching lines @@
 
   bool ready() const { return state_ == STATE_READY; }
   bool connected() const {
     return state_ == STATE_READY || state_ == STATE_CONNECTED;
   }
   const RelayCredentials& credentials() const { return credentials_; }
 
   virtual void PrepareAddress();
   virtual Connection* CreateConnection(
       const Candidate& c, PortInterface::CandidateOrigin origin);
+
   virtual int SendTo(const void* data, size_t size,
                      const rtc::SocketAddress& addr,
                      const rtc::PacketOptions& options,
                      bool payload);
   virtual int SetOption(rtc::Socket::Option opt, int value);
   virtual int GetOption(rtc::Socket::Option opt, int* value);
   virtual int GetError();
 
   virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
                                     const char* data, size_t size,
@@ skipping 95 matching lines @@
 
   bool CreateTurnClientSocket();
 
   void set_nonce(const std::string& nonce) { nonce_ = nonce; }
   void set_realm(const std::string& realm) {
     if (realm != realm_) {
       realm_ = realm;
       UpdateHash();
     }
   }
+  bool AddressFamilyMatch(const Candidate& local_candidate,
+                          const Candidate& remote_candidate) const;
 
   void OnTurnRefreshError();
   bool SetAlternateServer(const rtc::SocketAddress& address);
   void ResolveTurnAddress(const rtc::SocketAddress& address);
   void OnResolveResult(rtc::AsyncResolverInterface* resolver);
 
   void AddRequestAuthInfo(StunMessage* msg);
   void OnSendStunPacket(const void* data, size_t size, StunRequest* request);
   // Stun address from allocate success response.
   // Currently used only for testing.
@@ skipping 65 matching lines @@
   friend class TurnEntry;
   friend class TurnAllocateRequest;
   friend class TurnRefreshRequest;
   friend class TurnCreatePermissionRequest;
   friend class TurnChannelBindRequest;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TURNPORT_H_