1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/dns/address_sorter_posix.h" 6 7 #include "base/bind.h" 8 #include "base/logging.h" 9 #include "net/base/net_errors.h" 10 #include "net/base/net_util.h" 11 #include "net/base/test_completion_callback.h" 12 #include "net/socket/client_socket_factory.h" 13 #include "net/socket/ssl_client_socket.h" 14 #include "net/socket/stream_socket.h" 15 #include "net/udp/datagram_client_socket.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 namespace net { 19 namespace { 20 21 // Used to map destination address to source address. 22 typedef std::map<IPAddressNumber, IPAddressNumber> AddressMapping; 23 24 IPAddressNumber ParseIP(const std::string& str) { 25 IPAddressNumber addr; 26 CHECK(ParseIPLiteralToNumber(str, &addr)); 27 return addr; 28 } 29 30 // A mock socket which binds to source address according to AddressMapping. 31 class TestUDPClientSocket : public DatagramClientSocket { 32 public: 33 explicit TestUDPClientSocket(const AddressMapping* mapping) 34 : mapping_(mapping), connected_(false) {} 35 36 virtual ~TestUDPClientSocket() {} 37 38 virtual int Read(IOBuffer*, int, const CompletionCallback&) OVERRIDE { 39 NOTIMPLEMENTED(); 40 return OK; 41 } 42 virtual int Write(IOBuffer*, int, const CompletionCallback&) OVERRIDE { 43 NOTIMPLEMENTED(); 44 return OK; 45 } 46 virtual int SetReceiveBufferSize(int32) OVERRIDE { 47 return OK; 48 } 49 virtual int SetSendBufferSize(int32) OVERRIDE { 50 return OK; 51 } 52 53 virtual void Close() OVERRIDE {} 54 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { 55 NOTIMPLEMENTED(); 56 return OK; 57 } 58 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { 59 if (!connected_) 60 return ERR_UNEXPECTED; 61 *address = local_endpoint_; 62 return OK; 63 } 64 65 virtual int Connect(const IPEndPoint& remote) OVERRIDE { 66 if (connected_) 67 return ERR_UNEXPECTED; 68 AddressMapping::const_iterator it = mapping_->find(remote.address()); 69 if (it == mapping_->end()) 70 return ERR_FAILED; 71 connected_ = true; 72 local_endpoint_ = IPEndPoint(it->second, 39874 /* arbitrary port */); 73 return OK; 74 } 75 76 virtual const BoundNetLog& NetLog() const OVERRIDE { 77 return net_log_; 78 } 79 80 private: 81 BoundNetLog net_log_; 82 const AddressMapping* mapping_; 83 bool connected_; 84 IPEndPoint local_endpoint_; 85 86 DISALLOW_COPY_AND_ASSIGN(TestUDPClientSocket); 87 }; 88 89 // Creates TestUDPClientSockets and maintains an AddressMapping. 90 class TestSocketFactory : public ClientSocketFactory { 91 public: 92 TestSocketFactory() {} 93 virtual ~TestSocketFactory() {} 94 95 virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket( 96 DatagramSocket::BindType, 97 const RandIntCallback&, 98 NetLog*, 99 const NetLog::Source&) OVERRIDE { 100 return scoped_ptr<DatagramClientSocket>(new TestUDPClientSocket(&mapping_)); 101 } 102 virtual scoped_ptr<StreamSocket> CreateTransportClientSocket( 103 const AddressList&, 104 NetLog*, 105 const NetLog::Source&) OVERRIDE { 106 NOTIMPLEMENTED(); 107 return scoped_ptr<StreamSocket>(); 108 } 109 virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket( 110 scoped_ptr<ClientSocketHandle>, 111 const HostPortPair&, 112 const SSLConfig&, 113 const SSLClientSocketContext&) OVERRIDE { 114 NOTIMPLEMENTED(); 115 return scoped_ptr<SSLClientSocket>(); 116 } 117 virtual void ClearSSLSessionCache() OVERRIDE { 118 NOTIMPLEMENTED(); 119 } 120 121 void AddMapping(const IPAddressNumber& dst, const IPAddressNumber& src) { 122 mapping_[dst] = src; 123 } 124 125 private: 126 AddressMapping mapping_; 127 128 DISALLOW_COPY_AND_ASSIGN(TestSocketFactory); 129 }; 130 131 void OnSortComplete(AddressList* result_buf, 132 const CompletionCallback& callback, 133 bool success, 134 const AddressList& result) { 135 EXPECT_TRUE(success); 136 if (success) 137 *result_buf = result; 138 callback.Run(OK); 139 } 140 141 } // namespace 142 143 class AddressSorterPosixTest : public testing::Test { 144 protected: 145 AddressSorterPosixTest() : sorter_(&socket_factory_) {} 146 147 void AddMapping(const std::string& dst, const std::string& src) { 148 socket_factory_.AddMapping(ParseIP(dst), ParseIP(src)); 149 } 150 151 AddressSorterPosix::SourceAddressInfo* GetSourceInfo( 152 const std::string& addr) { 153 IPAddressNumber address = ParseIP(addr); 154 AddressSorterPosix::SourceAddressInfo* info = &sorter_.source_map_[address]; 155 if (info->scope == AddressSorterPosix::SCOPE_UNDEFINED) 156 sorter_.FillPolicy(address, info); 157 return info; 158 } 159 160 // Verify that NULL-terminated |addresses| matches (-1)-terminated |order| 161 // after sorting. 162 void Verify(const char* addresses[], const int order[]) { 163 AddressList list; 164 for (const char** addr = addresses; *addr != NULL; ++addr) 165 list.push_back(IPEndPoint(ParseIP(*addr), 80)); 166 for (size_t i = 0; order[i] >= 0; ++i) 167 CHECK_LT(order[i], static_cast<int>(list.size())); 168 169 AddressList result; 170 TestCompletionCallback callback; 171 sorter_.Sort(list, base::Bind(&OnSortComplete, &result, 172 callback.callback())); 173 callback.WaitForResult(); 174 175 for (size_t i = 0; (i < result.size()) || (order[i] >= 0); ++i) { 176 IPEndPoint expected = order[i] >= 0 ? list[order[i]] : IPEndPoint(); 177 IPEndPoint actual = i < result.size() ? result[i] : IPEndPoint(); 178 EXPECT_TRUE(expected.address() == actual.address()) << 179 "Address out of order at position " << i << "\n" << 180 " Actual: " << actual.ToStringWithoutPort() << "\n" << 181 "Expected: " << expected.ToStringWithoutPort(); 182 } 183 } 184 185 TestSocketFactory socket_factory_; 186 AddressSorterPosix sorter_; 187 }; 188 189 // Rule 1: Avoid unusable destinations. 190 TEST_F(AddressSorterPosixTest, Rule1) { 191 AddMapping("10.0.0.231", "10.0.0.1"); 192 const char* addresses[] = { "::1", "10.0.0.231", "127.0.0.1", NULL }; 193 const int order[] = { 1, -1 }; 194 Verify(addresses, order); 195 } 196 197 // Rule 2: Prefer matching scope. 198 TEST_F(AddressSorterPosixTest, Rule2) { 199 AddMapping("3002::1", "4000::10"); // matching global 200 AddMapping("ff32::1", "fe81::10"); // matching link-local 201 AddMapping("fec1::1", "fec1::10"); // matching node-local 202 AddMapping("3002::2", "::1"); // global vs. link-local 203 AddMapping("fec1::2", "fe81::10"); // site-local vs. link-local 204 AddMapping("8.0.0.1", "169.254.0.10"); // global vs. link-local 205 // In all three cases, matching scope is preferred. 206 const int order[] = { 1, 0, -1 }; 207 const char* addresses1[] = { "3002::2", "3002::1", NULL }; 208 Verify(addresses1, order); 209 const char* addresses2[] = { "fec1::2", "ff32::1", NULL }; 210 Verify(addresses2, order); 211 const char* addresses3[] = { "8.0.0.1", "fec1::1", NULL }; 212 Verify(addresses3, order); 213 } 214 215 // Rule 3: Avoid deprecated addresses. 216 TEST_F(AddressSorterPosixTest, Rule3) { 217 // Matching scope. 218 AddMapping("3002::1", "4000::10"); 219 GetSourceInfo("4000::10")->deprecated = true; 220 AddMapping("3002::2", "4000::20"); 221 const char* addresses[] = { "3002::1", "3002::2", NULL }; 222 const int order[] = { 1, 0, -1 }; 223 Verify(addresses, order); 224 } 225 226 // Rule 4: Prefer home addresses. 227 TEST_F(AddressSorterPosixTest, Rule4) { 228 AddMapping("3002::1", "4000::10"); 229 AddMapping("3002::2", "4000::20"); 230 GetSourceInfo("4000::20")->home = true; 231 const char* addresses[] = { "3002::1", "3002::2", NULL }; 232 const int order[] = { 1, 0, -1 }; 233 Verify(addresses, order); 234 } 235 236 // Rule 5: Prefer matching label. 237 TEST_F(AddressSorterPosixTest, Rule5) { 238 AddMapping("::1", "::1"); // matching loopback 239 AddMapping("::ffff:1234:1", "::ffff:1234:10"); // matching IPv4-mapped 240 AddMapping("2001::1", "::ffff:1234:10"); // Teredo vs. IPv4-mapped 241 AddMapping("2002::1", "2001::10"); // 6to4 vs. Teredo 242 const int order[] = { 1, 0, -1 }; 243 { 244 const char* addresses[] = { "2001::1", "::1", NULL }; 245 Verify(addresses, order); 246 } 247 { 248 const char* addresses[] = { "2002::1", "::ffff:1234:1", NULL }; 249 Verify(addresses, order); 250 } 251 } 252 253 // Rule 6: Prefer higher precedence. 254 TEST_F(AddressSorterPosixTest, Rule6) { 255 AddMapping("::1", "::1"); // loopback 256 AddMapping("ff32::1", "fe81::10"); // multicast 257 AddMapping("::ffff:1234:1", "::ffff:1234:10"); // IPv4-mapped 258 AddMapping("2001::1", "2001::10"); // Teredo 259 const char* addresses[] = { "2001::1", "::ffff:1234:1", "ff32::1", "::1", 260 NULL }; 261 const int order[] = { 3, 2, 1, 0, -1 }; 262 Verify(addresses, order); 263 } 264 265 // Rule 7: Prefer native transport. 266 TEST_F(AddressSorterPosixTest, Rule7) { 267 AddMapping("3002::1", "4000::10"); 268 AddMapping("3002::2", "4000::20"); 269 GetSourceInfo("4000::20")->native = true; 270 const char* addresses[] = { "3002::1", "3002::2", NULL }; 271 const int order[] = { 1, 0, -1 }; 272 Verify(addresses, order); 273 } 274 275 // Rule 8: Prefer smaller scope. 276 TEST_F(AddressSorterPosixTest, Rule8) { 277 // Matching scope. Should precede the others by Rule 2. 278 AddMapping("fe81::1", "fe81::10"); // link-local 279 AddMapping("3000::1", "4000::10"); // global 280 // Mismatched scope. 281 AddMapping("ff32::1", "4000::10"); // link-local 282 AddMapping("ff35::1", "4000::10"); // site-local 283 AddMapping("ff38::1", "4000::10"); // org-local 284 const char* addresses[] = { "ff38::1", "3000::1", "ff35::1", "ff32::1", 285 "fe81::1", NULL }; 286 const int order[] = { 4, 1, 3, 2, 0, -1 }; 287 Verify(addresses, order); 288 } 289 290 // Rule 9: Use longest matching prefix. 291 TEST_F(AddressSorterPosixTest, Rule9) { 292 AddMapping("3000::1", "3000:ffff::10"); // 16 bit match 293 GetSourceInfo("3000:ffff::10")->prefix_length = 16; 294 AddMapping("4000::1", "4000::10"); // 123 bit match, limited to 15 295 GetSourceInfo("4000::10")->prefix_length = 15; 296 AddMapping("4002::1", "4000::10"); // 14 bit match 297 AddMapping("4080::1", "4000::10"); // 8 bit match 298 const char* addresses[] = { "4080::1", "4002::1", "4000::1", "3000::1", 299 NULL }; 300 const int order[] = { 3, 2, 1, 0, -1 }; 301 Verify(addresses, order); 302 } 303 304 // Rule 10: Leave the order unchanged. 305 TEST_F(AddressSorterPosixTest, Rule10) { 306 AddMapping("4000::1", "4000::10"); 307 AddMapping("4000::2", "4000::10"); 308 AddMapping("4000::3", "4000::10"); 309 const char* addresses[] = { "4000::1", "4000::2", "4000::3", NULL }; 310 const int order[] = { 0, 1, 2, -1 }; 311 Verify(addresses, order); 312 } 313 314 TEST_F(AddressSorterPosixTest, MultipleRules) { 315 AddMapping("::1", "::1"); // loopback 316 AddMapping("ff32::1", "fe81::10"); // link-local multicast 317 AddMapping("ff3e::1", "4000::10"); // global multicast 318 AddMapping("4000::1", "4000::10"); // global unicast 319 AddMapping("ff32::2", "fe81::20"); // deprecated link-local multicast 320 GetSourceInfo("fe81::20")->deprecated = true; 321 const char* addresses[] = { "ff3e::1", "ff32::2", "4000::1", "ff32::1", "::1", 322 "8.0.0.1", NULL }; 323 const int order[] = { 4, 3, 0, 2, 1, -1 }; 324 Verify(addresses, order); 325 } 326 327 } // namespace net 328