Bug 4865: Enable connectivity when the remote peer is on public internet.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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 131 matching lines @@
       EXPECT_EQ(post_ipv4.s_addr, pre_ipv4.s_addr);
     } else if (post_ip.family() == AF_INET6) {
       in6_addr post_ip6 = post_ip.ipv6_address();
       in6_addr pre_ip6 = pre_ip.ipv6_address();
       uint32* post_as_ints = reinterpret_cast<uint32*>(&post_ip6.s6_addr);
       uint32* pre_as_ints = reinterpret_cast<uint32*>(&pre_ip6.s6_addr);
       EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
     }
   }
 
+  // Test a client can bind to the any address, and all sent packets will have
+  // the default route as the source address. Also, it can receive packets sent
+  // to the default route.
+  void TestDefaultRoute(const IPAddress& default_route) {
+    ss_->SetDefaultRoute(default_route);
+
+    // Create client1 bound to the any address.
+    AsyncSocket* socket =
+        ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+    socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
+    SocketAddress client1_any_addr = socket->GetLocalAddress();
+    EXPECT_TRUE(client1_any_addr.IsAnyIP());
+    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+
+    // Create client2 bound to the default route.
+    AsyncSocket* socket2 =
+        ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+    socket2->Bind(SocketAddress(default_route, 0));
+    SocketAddress client2_addr = socket2->GetLocalAddress();
+    EXPECT_FALSE(client2_addr.IsAnyIP());
+    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+
+    // Client1 sends to client2, client2 should see the default route as
+    // client1's address.
+    SocketAddress client1_addr;
+    EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
+    EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+    EXPECT_EQ(client1_addr,
+              SocketAddress(default_route, client1_any_addr.port()));
+
+    // Client2 can send back to client1's default route address.
+    EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
+    EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+
+    // Client2 also can send to client1's any address. This is to document the
+    // current behavior. In reality, this should fail as the any address
+    // shouldn't be the destination.

[pthatcher1, 2015/08/07 21:28:19]

Can we just remove the current behavior, or do we rely on it?  If we rely on it,
please put a comment why.  If not, please put a TODO for removing it (or just
remove it).

[guoweis_webrtc, 2015/08/13 14:17:28]

Done.

+    SocketAddress client2_addr_new;
+    EXPECT_EQ(3, client2->SendTo("foo", 3, client1_any_addr));
+    EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr_new));
+    EXPECT_EQ(client2_addr_new, client2_addr);
+  }
+
   void BasicTest(const SocketAddress& initial_addr) {
     AsyncSocket* socket = ss_->CreateAsyncSocket(initial_addr.family(),
                                                  SOCK_DGRAM);
     socket->Bind(initial_addr);
     SocketAddress server_addr = socket->GetLocalAddress();
     // Make sure VSS didn't switch families on us.
     EXPECT_EQ(server_addr.family(), initial_addr.family());
 
     TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
     AsyncSocket* socket2 =
@@ skipping 622 matching lines @@
 TEST_F(VirtualSocketServerTest, basic_v4) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
 
 TEST_F(VirtualSocketServerTest, basic_v6) {
   SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
   BasicTest(ipv6_test_addr);
 }
 
+TEST_F(VirtualSocketServerTest, TestDefaultRoute_v4) {
+  IPAddress ipv4_default_addr(0x01020304);
+  TestDefaultRoute(ipv4_default_addr);
+}
+
+TEST_F(VirtualSocketServerTest, TestDefaultRoute_v6) {
+  IPAddress ipv6_default_addr;
+  EXPECT_TRUE(
+      IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ipv6_default_addr));
+  TestDefaultRoute(ipv6_default_addr);
+}
+
 TEST_F(VirtualSocketServerTest, connect_v4) {
   ConnectTest(kIPv4AnyAddress);
 }
 
 TEST_F(VirtualSocketServerTest, connect_v6) {
   ConnectTest(kIPv6AnyAddress);
 }
 
 TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
   ConnectToNonListenerTest(kIPv4AnyAddress);
@@ skipping 190 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }