Tighten link-local IPv6 routing exclusion check

webrtc/p2p/base/port_unittest.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 520 matching lines @@
         case PROTO_UDP:           return "gturn(udp)";
         case PROTO_TCP:           return "gturn(tcp)";
         case PROTO_SSLTCP:        return "gturn(ssltcp)";
         default:                  return "gturn(?)";
       }
     }
   }
 
   void TestCrossFamilyPorts(int type);
 
+  void ExpectPortsCanConnect(bool can_connect, Port* p1, Port* p2);
+
   // This does all the work and then deletes |port1| and |port2|.
   void TestConnectivity(const char* name1, Port* port1,
                         const char* name2, Port* port2,
                         bool accept, bool same_addr1,
                         bool same_addr2, bool possible);
 
   // This connects the provided channels which have already started.  |ch1|
   // should have its Connection created (either through CreateConnection() or
   // TCP reconnecting mechanism before entering this function.
   void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) {
@@ skipping 836 matching lines @@
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyTcp) {
   TestCrossFamilyPorts(SOCK_STREAM);
 }
 
 TEST_F(PortTest, TestSkipCrossFamilyUdp) {
   TestCrossFamilyPorts(SOCK_DGRAM);
 }
 
+void PortTest::ExpectPortsCanConnect(bool can_connect, Port* p1, Port* p2) {
+  Connection* c = p1->CreateConnection(GetCandidate(p2),
+                                       Port::ORIGIN_MESSAGE);
+  if (can_connect) {
+    EXPECT_FALSE(NULL == c);
+    EXPECT_EQ(1U, p1->connections().size());
+  } else {
+    EXPECT_TRUE(NULL == c);
+    EXPECT_EQ(0U, p1->connections().size());
+  }
+}
+
+TEST_F(PortTest, TestUdpV6CrossTypePorts) {
+  FakePacketSocketFactory factory;
+  scoped_ptr<Port> ports[4];
+  SocketAddress addresses[4] = {SocketAddress("2001:db8::1", 0),
+                                SocketAddress("fe80::1", 0),
+                                SocketAddress("fe80::2", 0),
+                                SocketAddress("::1", 0)};
+  for (int i = 0; i < 4; i++) {
+    FakeAsyncPacketSocket *socket = new FakeAsyncPacketSocket();
+    factory.set_next_udp_socket(socket);
+    ports[i].reset(CreateUdpPort(addresses[i], &factory));
+    socket->set_state(AsyncPacketSocket::STATE_BINDING);
+    socket->SignalAddressReady(socket, addresses[i]);
+    ports[i]->PrepareAddress();
+  }
+
+  Port* standard = ports[0].get();
+  Port* link_local1 = ports[1].get();
+  Port* link_local2 = ports[2].get();
+  Port* localhost = ports[3].get();
+
+  ExpectPortsCanConnect(false, link_local1, standard);
+  ExpectPortsCanConnect(false, standard, link_local1);
+  ExpectPortsCanConnect(false, link_local1, localhost);
+  ExpectPortsCanConnect(false, localhost, link_local1);
+
+  ExpectPortsCanConnect(true, link_local1, link_local2);
+  ExpectPortsCanConnect(true, localhost, standard);
+  ExpectPortsCanConnect(true, standard, localhost);
+}
+
 // This test verifies DSCP value set through SetOption interface can be
 // get through DefaultDscpValue.
 TEST_F(PortTest, TestDefaultDscpValue) {
   int dscp;
   rtc::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
   EXPECT_EQ(0, udpport->SetOption(rtc::Socket::OPT_DSCP,
                                   rtc::DSCP_CS6));
   EXPECT_EQ(0, udpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
   rtc::scoped_ptr<TCPPort> tcpport(CreateTcpPort(kLocalAddr1));
   EXPECT_EQ(0, tcpport->SetOption(rtc::Socket::OPT_DSCP,
@@ skipping 1189 matching lines @@
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1, port2);
   TestChannel ch2(port2, port1);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // The controlled port should be destroyed after 10 milliseconds.
   EXPECT_TRUE_WAIT(destroyed(), kTimeout);
 }