net/base/net_util_unittest.cc

   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/base/net_util.h"
   6
   7 #include <string.h>
   8
   9 #include <ostream>
  10
  11 #include "base/files/file_path.h"
  12 #include "base/format_macros.h"
  13 #include "base/scoped_native_library.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/sys_byteorder.h"
  19 #include "base/time/time.h"
  20 #include "net/base/ip_endpoint.h"
  21
  22 #if !defined(OS_NACL) && !defined(OS_WIN)
  23 #include <net/if.h>
  24 #include <netinet/in.h>
  25 #if defined(OS_MACOSX)
  26 #include <ifaddrs.h>
  27 #if !defined(OS_IOS)
  28 #include <netinet/in_var.h>
  29 #endif  // !OS_IOS
  30 #endif  // OS_MACOSX
  31 #endif  // !OS_NACL && !OS_WIN
  32 #include "testing/gtest/include/gtest/gtest.h"
  33 #include "url/gurl.h"
  34
  35 #if defined(OS_WIN)
  36 #include <iphlpapi.h>
  37 #include <objbase.h>
  38 #include "base/win/windows_version.h"
  39 #endif  // OS_WIN
  40
  41 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_WIN)
  42 #include "net/base/address_tracker_linux.h"
  43 #endif  // !OS_MACOSX && !OS_NACL && !OS_WIN
  44
  45 #if defined(OS_WIN)
  46 #include "net/base/net_util_win.h"
  47 #else  // OS_WIN
  48 #include "net/base/net_util_posix.h"
  49 #if defined(OS_MACOSX)
  50 #include "net/base/net_util_mac.h"
  51 #else  // OS_MACOSX
  52 #include "net/base/net_util_linux.h"
  53 #endif  // OS_MACOSX
  54 #endif  // OS_WIN
  55
  56 using base::ASCIIToUTF16;
  57 using base::WideToUTF16;
  58
  59 namespace net {
  60
  61 namespace {
  62
  63 struct HeaderCase {
  64   const char* const header_name;
  65   const char* const expected;
  66 };
  67
  68 #if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_CHROMEOS)
  69 const char kWiFiSSID[] = "TestWiFi";
  70 const char kInterfaceWithDifferentSSID[] = "wlan999";
  71
  72 std::string TestGetInterfaceSSID(const std::string& ifname) {
  73   return (ifname == kInterfaceWithDifferentSSID) ? "AnotherSSID" : kWiFiSSID;
  74 }
  75 #endif
  76
  77 // Fills in sockaddr for the given 32-bit address (IPv4.)
  78 // |bytes| should be an array of length 4.
  79 void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
  80   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
  81   storage->addr_len = sizeof(struct sockaddr_in);
  82   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
  83   addr4->sin_port = base::HostToNet16(port);
  84   addr4->sin_family = AF_INET;
  85   memcpy(&addr4->sin_addr, bytes, 4);
  86 }
  87
  88 // Fills in sockaddr for the given 128-bit address (IPv6.)
  89 // |bytes| should be an array of length 16.
  90 void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
  91   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
  92   storage->addr_len = sizeof(struct sockaddr_in6);
  93   struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
  94   addr6->sin6_port = base::HostToNet16(port);
  95   addr6->sin6_family = AF_INET6;
  96   memcpy(&addr6->sin6_addr, bytes, 16);
  97 }
  98
  99 // Helper to strignize an IP number (used to define expectations).
 100 std::string DumpIPNumber(const IPAddressNumber& v) {
 101   std::string out;
 102   for (size_t i = 0; i < v.size(); ++i) {
 103     if (i != 0)
 104       out.append(",");
 105     out.append(base::IntToString(static_cast<int>(v[i])));
 106   }
 107   return out;
 108 }
 109
 110 #if defined(OS_MACOSX)
 111 class IPAttributesGetterTest : public internal::IPAttributesGetterMac {
 112  public:
 113   IPAttributesGetterTest() : native_attributes_(0) {}
 114   bool IsInitialized() const override { return true; }
 115   bool GetIPAttributes(const char* ifname,
 116                        const sockaddr* sock_addr,
 117                        int* native_attributes) override {
 118     *native_attributes = native_attributes_;
 119     return true;
 120   }
 121   void set_native_attributes(int native_attributes) {
 122     native_attributes_ = native_attributes;
 123   }
 124
 125  private:
 126   int native_attributes_;
 127 };
 128
 129 // Helper function to create a single valid ifaddrs
 130 bool FillIfaddrs(ifaddrs* interfaces,
 131                  const char* ifname,
 132                  uint flags,
 133                  const IPAddressNumber& ip_address,
 134                  const IPAddressNumber& ip_netmask,
 135                  sockaddr_storage sock_addrs[2]) {
 136   interfaces->ifa_next = NULL;
 137   interfaces->ifa_name = const_cast<char*>(ifname);
 138   interfaces->ifa_flags = flags;
 139
 140   socklen_t sock_len = sizeof(sockaddr_storage);
 141
 142   // Convert to sockaddr for next check.
 143   if (!IPEndPoint(ip_address, 0)
 144            .ToSockAddr(reinterpret_cast<sockaddr*>(&sock_addrs[0]),
 145                        &sock_len)) {
 146     return false;
 147   }
 148   interfaces->ifa_addr = reinterpret_cast<sockaddr*>(&sock_addrs[0]);
 149
 150   sock_len = sizeof(sockaddr_storage);
 151   if (!IPEndPoint(ip_netmask, 0)
 152            .ToSockAddr(reinterpret_cast<sockaddr*>(&sock_addrs[1]),
 153                        &sock_len)) {
 154     return false;
 155   }
 156   interfaces->ifa_netmask = reinterpret_cast<sockaddr*>(&sock_addrs[1]);
 157
 158   return true;
 159 }
 160 #endif  // OS_MACOSX
 161
 162 }  // anonymous namespace
 163
 164 TEST(NetUtilTest, GetIdentityFromURL) {
 165   struct {
 166     const char* const input_url;
 167     const char* const expected_username;
 168     const char* const expected_password;
 169   } tests[] = {
 170     {
 171       "http://username:password@google.com",
 172       "username",
 173       "password",
 174     },
 175     { // Test for http://crbug.com/19200
 176       "http://username:p@ssword@google.com",
 177       "username",
 178       "p@ssword",
 179     },
 180     { // Special URL characters should be unescaped.
 181       "http://username:p%3fa%26s%2fs%23@google.com",
 182       "username",
 183       "p?a&s/s#",
 184     },
 185     { // Username contains %20.
 186       "http://use rname:password@google.com",
 187       "use rname",
 188       "password",
 189     },
 190     { // Keep %00 as is.
 191       "http://use%00rname:password@google.com",
 192       "use%00rname",
 193       "password",
 194     },
 195     { // Use a '+' in the username.
 196       "http://use+rname:password@google.com",
 197       "use+rname",
 198       "password",
 199     },
 200     { // Use a '&' in the password.
 201       "http://username:p&ssword@google.com",
 202       "username",
 203       "p&ssword",
 204     },
 205   };
 206   for (size_t i = 0; i < arraysize(tests); ++i) {
 207     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
 208                                     tests[i].input_url));
 209     GURL url(tests[i].input_url);
 210
 211     base::string16 username, password;
 212     GetIdentityFromURL(url, &username, &password);
 213
 214     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
 215     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
 216   }
 217 }
 218
 219 // Try extracting a username which was encoded with UTF8.
 220 TEST(NetUtilTest, GetIdentityFromURL_UTF8) {
 221   GURL url(WideToUTF16(L"http://foo:\x4f60\x597d@blah.com"));
 222
 223   EXPECT_EQ("foo", url.username());
 224   EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password());
 225
 226   // Extract the unescaped identity.
 227   base::string16 username, password;
 228   GetIdentityFromURL(url, &username, &password);
 229
 230   // Verify that it was decoded as UTF8.
 231   EXPECT_EQ(ASCIIToUTF16("foo"), username);
 232   EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password);
 233 }
 234
 235 // Just a bunch of fake headers.
 236 const char google_headers[] =
 237     "HTTP/1.1 200 OK\n"
 238     "Content-TYPE: text/html; charset=utf-8\n"
 239     "Content-disposition: attachment; filename=\"download.pdf\"\n"
 240     "Content-Length: 378557\n"
 241     "X-Google-Google1: 314159265\n"
 242     "X-Google-Google2: aaaa2:7783,bbb21:9441\n"
 243     "X-Google-Google4: home\n"
 244     "Transfer-Encoding: chunked\n"
 245     "Set-Cookie: HEHE_AT=6666x66beef666x6-66xx6666x66; Path=/mail\n"
 246     "Set-Cookie: HEHE_HELP=owned:0;Path=/\n"
 247     "Set-Cookie: S=gmail=Xxx-beefbeefbeef_beefb:gmail_yj=beefbeef000beefbee"
 248        "fbee:gmproxy=bee-fbeefbe; Domain=.google.com; Path=/\n"
 249     "X-Google-Google2: /one/two/three/four/five/six/seven-height/nine:9411\n"
 250     "Server: GFE/1.3\n"
 251     "Transfer-Encoding: chunked\n"
 252     "Date: Mon, 13 Nov 2006 21:38:09 GMT\n"
 253     "Expires: Tue, 14 Nov 2006 19:23:58 GMT\n"
 254     "X-Malformed: bla; arg=test\"\n"
 255     "X-Malformed2: bla; arg=\n"
 256     "X-Test: bla; arg1=val1; arg2=val2";
 257
 258 TEST(NetUtilTest, GetSpecificHeader) {
 259   const HeaderCase tests[] = {
 260     {"content-type", "text/html; charset=utf-8"},
 261     {"CONTENT-LENGTH", "378557"},
 262     {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
 263     {"Bad-Header", ""},
 264     {"", ""},
 265   };
 266
 267   // Test first with google_headers.
 268   for (size_t i = 0; i < arraysize(tests); ++i) {
 269     std::string result =
 270         GetSpecificHeader(google_headers, tests[i].header_name);
 271     EXPECT_EQ(result, tests[i].expected);
 272   }
 273
 274   // Test again with empty headers.
 275   for (size_t i = 0; i < arraysize(tests); ++i) {
 276     std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
 277     EXPECT_EQ(result, std::string());
 278   }
 279 }
 280
 281 TEST(NetUtilTest, CompliantHost) {
 282   struct CompliantHostCase {
 283     const char* const host;
 284     bool expected_output;
 285   };
 286
 287   const CompliantHostCase compliant_host_cases[] = {
 288       {"", false},
 289       {"a", true},
 290       {"-", false},
 291       {"_", false},
 292       {".", false},
 293       {"9", true},
 294       {"9a", true},
 295       {"9_", true},
 296       {"a.", true},
 297       {"a.a", true},
 298       {"9.a", true},
 299       {"a.9", true},
 300       {"_9a", false},
 301       {"-9a", false},
 302       {"a.a9", true},
 303       {"_.9a", true},
 304       {"a.-a9", false},
 305       {"a+9a", false},
 306       {"-a.a9", true},
 307       {"a_.a9", true},
 308       {"1-.a-b", true},
 309       {"1_.a-b", true},
 310       {"1-2.a_b", true},
 311       {"a.b.c.d.e", true},
 312       {"1.2.3.4.5", true},
 313       {"1.2.3.4.5.", true},
 314   };
 315
 316   for (size_t i = 0; i < arraysize(compliant_host_cases); ++i) {
 317     EXPECT_EQ(compliant_host_cases[i].expected_output,
 318               IsCanonicalizedHostCompliant(compliant_host_cases[i].host));
 319   }
 320 }
 321
 322 TEST(NetUtilTest, ParseHostAndPort) {
 323   const struct {
 324     const char* const input;
 325     bool success;
 326     const char* const expected_host;
 327     int expected_port;
 328   } tests[] = {
 329     // Valid inputs:
 330     {"foo:10", true, "foo", 10},
 331     {"foo", true, "foo", -1},
 332     {
 333       "[1080:0:0:0:8:800:200C:4171]:11",
 334       true,
 335       "1080:0:0:0:8:800:200C:4171",
 336       11
 337     },
 338     {
 339       "[1080:0:0:0:8:800:200C:4171]",
 340       true,
 341       "1080:0:0:0:8:800:200C:4171",
 342       -1
 343     },
 344
 345     // Because no validation is done on the host, the following are accepted,
 346     // even though they are invalid names.
 347     {"]", true, "]", -1},
 348     {"::1", true, ":", 1},
 349     // Invalid inputs:
 350     {"foo:bar", false, "", -1},
 351     {"foo:", false, "", -1},
 352     {":", false, "", -1},
 353     {":80", false, "", -1},
 354     {"", false, "", -1},
 355     {"porttoolong:300000", false, "", -1},
 356     {"usrname@host", false, "", -1},
 357     {"usrname:password@host", false, "", -1},
 358     {":password@host", false, "", -1},
 359     {":password@host:80", false, "", -1},
 360     {":password@host", false, "", -1},
 361     {"@host", false, "", -1},
 362     {"[", false, "", -1},
 363     {"[]", false, "", -1},
 364   };
 365
 366   for (size_t i = 0; i < arraysize(tests); ++i) {
 367     std::string host;
 368     int port;
 369     bool ok = ParseHostAndPort(tests[i].input, &host, &port);
 370
 371     EXPECT_EQ(tests[i].success, ok);
 372
 373     if (tests[i].success) {
 374       EXPECT_EQ(tests[i].expected_host, host);
 375       EXPECT_EQ(tests[i].expected_port, port);
 376     }
 377   }
 378 }
 379
 380 TEST(NetUtilTest, GetHostAndPort) {
 381   const struct {
 382     GURL url;
 383     const char* const expected_host_and_port;
 384   } tests[] = {
 385     { GURL("http://www.foo.com/x"), "www.foo.com:80"},
 386     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 387
 388     // For IPv6 literals should always include the brackets.
 389     { GURL("http://[1::2]/x"), "[1::2]:80"},
 390     { GURL("http://[::a]:33/x"), "[::a]:33"},
 391   };
 392   for (size_t i = 0; i < arraysize(tests); ++i) {
 393     std::string host_and_port = GetHostAndPort(tests[i].url);
 394     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
 395   }
 396 }
 397
 398 TEST(NetUtilTest, GetHostAndOptionalPort) {
 399   const struct {
 400     GURL url;
 401     const char* const expected_host_and_port;
 402   } tests[] = {
 403     { GURL("http://www.foo.com/x"), "www.foo.com"},
 404     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 405
 406     // For IPv6 literals should always include the brackets.
 407     { GURL("http://[1::2]/x"), "[1::2]"},
 408     { GURL("http://[::a]:33/x"), "[::a]:33"},
 409   };
 410   for (size_t i = 0; i < arraysize(tests); ++i) {
 411     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
 412     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
 413   }
 414 }
 415
 416 TEST(NetUtilTest, IPAddressToString) {
 417   uint8 addr1[4] = {0, 0, 0, 0};
 418   EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
 419
 420   uint8 addr2[4] = {192, 168, 0, 1};
 421   EXPECT_EQ("192.168.0.1", IPAddressToString(addr2, sizeof(addr2)));
 422
 423   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
 424   EXPECT_EQ("fedc:ba98::", IPAddressToString(addr3, sizeof(addr3)));
 425 }
 426
 427 TEST(NetUtilTest, IPAddressToStringWithPort) {
 428   uint8 addr1[4] = {0, 0, 0, 0};
 429   EXPECT_EQ("0.0.0.0:3", IPAddressToStringWithPort(addr1, sizeof(addr1), 3));
 430
 431   uint8 addr2[4] = {192, 168, 0, 1};
 432   EXPECT_EQ("192.168.0.1:99",
 433             IPAddressToStringWithPort(addr2, sizeof(addr2), 99));
 434
 435   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
 436   EXPECT_EQ("[fedc:ba98::]:8080",
 437             IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
 438 }
 439
 440 TEST(NetUtilTest, NetAddressToString_IPv4) {
 441   const struct {
 442     uint8 addr[4];
 443     const char* const result;
 444   } tests[] = {
 445     {{0, 0, 0, 0}, "0.0.0.0"},
 446     {{127, 0, 0, 1}, "127.0.0.1"},
 447     {{192, 168, 0, 1}, "192.168.0.1"},
 448   };
 449
 450   for (size_t i = 0; i < arraysize(tests); ++i) {
 451     SockaddrStorage storage;
 452     MakeIPv4Address(tests[i].addr, 80, &storage);
 453     std::string result = NetAddressToString(storage.addr, storage.addr_len);
 454     EXPECT_EQ(std::string(tests[i].result), result);
 455   }
 456 }
 457
 458 TEST(NetUtilTest, NetAddressToString_IPv6) {
 459   const struct {
 460     uint8 addr[16];
 461     const char* const result;
 462   } tests[] = {
 463     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
 464       0x98, 0x76, 0x54, 0x32, 0x10},
 465      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
 466   };
 467
 468   for (size_t i = 0; i < arraysize(tests); ++i) {
 469     SockaddrStorage storage;
 470     MakeIPv6Address(tests[i].addr, 80, &storage);
 471     EXPECT_EQ(std::string(tests[i].result),
 472         NetAddressToString(storage.addr, storage.addr_len));
 473   }
 474 }
 475
 476 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
 477   uint8 addr[] = {127, 0, 0, 1};
 478   SockaddrStorage storage;
 479   MakeIPv4Address(addr, 166, &storage);
 480   std::string result = NetAddressToStringWithPort(storage.addr,
 481                                                   storage.addr_len);
 482   EXPECT_EQ("127.0.0.1:166", result);
 483 }
 484
 485 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
 486   uint8 addr[] = {
 487       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
 488       0x98, 0x76, 0x54, 0x32, 0x10
 489   };
 490   SockaddrStorage storage;
 491   MakeIPv6Address(addr, 361, &storage);
 492   std::string result = NetAddressToStringWithPort(storage.addr,
 493                                                   storage.addr_len);
 494
 495   // May fail on systems that don't support IPv6.
 496   if (!result.empty())
 497     EXPECT_EQ("[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:361", result);
 498 }
 499
 500 TEST(NetUtilTest, GetHostName) {
 501   // We can't check the result of GetHostName() directly, since the result
 502   // will differ across machines. Our goal here is to simply exercise the
 503   // code path, and check that things "look about right".
 504   std::string hostname = GetHostName();
 505   EXPECT_FALSE(hostname.empty());
 506 }
 507
 508 TEST(NetUtilTest, SimplifyUrlForRequest) {
 509   struct {
 510     const char* const input_url;
 511     const char* const expected_simplified_url;
 512   } tests[] = {
 513     {
 514       // Reference section should be stripped.
 515       "http://www.google.com:78/foobar?query=1#hash",
 516       "http://www.google.com:78/foobar?query=1",
 517     },
 518     {
 519       // Reference section can itself contain #.
 520       "http://192.168.0.1?query=1#hash#10#11#13#14",
 521       "http://192.168.0.1?query=1",
 522     },
 523     { // Strip username/password.
 524       "http://user:pass@google.com",
 525       "http://google.com/",
 526     },
 527     { // Strip both the reference and the username/password.
 528       "http://user:pass@google.com:80/sup?yo#X#X",
 529       "http://google.com/sup?yo",
 530     },
 531     { // Try an HTTPS URL -- strip both the reference and the username/password.
 532       "https://user:pass@google.com:80/sup?yo#X#X",
 533       "https://google.com:80/sup?yo",
 534     },
 535     { // Try an FTP URL -- strip both the reference and the username/password.
 536       "ftp://user:pass@google.com:80/sup?yo#X#X",
 537       "ftp://google.com:80/sup?yo",
 538     },
 539     { // Try a nonstandard URL
 540       "foobar://user:pass@google.com:80/sup?yo#X#X",
 541       "foobar://user:pass@google.com:80/sup?yo",
 542     },
 543   };
 544   for (size_t i = 0; i < arraysize(tests); ++i) {
 545     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
 546                                     tests[i].input_url));
 547     GURL input_url(GURL(tests[i].input_url));
 548     GURL expected_url(GURL(tests[i].expected_simplified_url));
 549     EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
 550   }
 551 }
 552
 553 TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
 554   std::string invalid[] = { "1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12" };
 555   std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
 556
 557   for (size_t i = 0; i < arraysize(invalid); ++i) {
 558     SetExplicitlyAllowedPorts(invalid[i]);
 559     EXPECT_EQ(0, static_cast<int>(GetCountOfExplicitlyAllowedPorts()));
 560   }
 561
 562   for (size_t i = 0; i < arraysize(valid); ++i) {
 563     SetExplicitlyAllowedPorts(valid[i]);
 564     EXPECT_EQ(i, GetCountOfExplicitlyAllowedPorts());
 565   }
 566 }
 567
 568 TEST(NetUtilTest, GetHostOrSpecFromURL) {
 569   EXPECT_EQ("example.com",
 570             GetHostOrSpecFromURL(GURL("http://example.com/test")));
 571   EXPECT_EQ("example.com",
 572             GetHostOrSpecFromURL(GURL("http://example.com./test")));
 573   EXPECT_EQ("file:///tmp/test.html",
 574             GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
 575 }
 576
 577 TEST(NetUtilTest, GetAddressFamily) {
 578   IPAddressNumber number;
 579   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
 580   EXPECT_EQ(ADDRESS_FAMILY_IPV4, GetAddressFamily(number));
 581   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
 582   EXPECT_EQ(ADDRESS_FAMILY_IPV6, GetAddressFamily(number));
 583 }
 584
 585 // Test that invalid IP literals fail to parse.
 586 TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) {
 587   IPAddressNumber number;
 588
 589   EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number));
 590   EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number));
 591   EXPECT_FALSE(ParseIPLiteralToNumber(std::string(), &number));
 592   EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number));
 593   EXPECT_FALSE(ParseIPLiteralToNumber("  192.168.0.1  ", &number));
 594   EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number));
 595 }
 596
 597 // Test parsing an IPv4 literal.
 598 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv4) {
 599   IPAddressNumber number;
 600   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
 601   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
 602   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
 603 }
 604
 605 // Test parsing an IPv6 literal.
 606 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv6) {
 607   IPAddressNumber number;
 608   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
 609   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
 610   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 611 }
 612
 613 // Test mapping an IPv4 address to an IPv6 address.
 614 TEST(NetUtilTest, ConvertIPv4NumberToIPv6Number) {
 615   IPAddressNumber ipv4_number;
 616   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 617
 618   IPAddressNumber ipv6_number =
 619       ConvertIPv4NumberToIPv6Number(ipv4_number);
 620
 621   // ::ffff:192.168.0.1
 622   EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
 623             DumpIPNumber(ipv6_number));
 624   EXPECT_EQ("::ffff:c0a8:1", IPAddressToString(ipv6_number));
 625 }
 626
 627 TEST(NetUtilTest, ParseURLHostnameToNumber_FailParse) {
 628   IPAddressNumber number;
 629
 630   EXPECT_FALSE(ParseURLHostnameToNumber("bad value", &number));
 631   EXPECT_FALSE(ParseURLHostnameToNumber("bad:value", &number));
 632   EXPECT_FALSE(ParseURLHostnameToNumber(std::string(), &number));
 633   EXPECT_FALSE(ParseURLHostnameToNumber("192.168.0.1:30", &number));
 634   EXPECT_FALSE(ParseURLHostnameToNumber("  192.168.0.1  ", &number));
 635   EXPECT_FALSE(ParseURLHostnameToNumber("::1", &number));
 636 }
 637
 638 TEST(NetUtilTest, ParseURLHostnameToNumber_IPv4) {
 639   IPAddressNumber number;
 640   EXPECT_TRUE(ParseURLHostnameToNumber("192.168.0.1", &number));
 641   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
 642   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
 643 }
 644
 645 TEST(NetUtilTest, ParseURLHostnameToNumber_IPv6) {
 646   IPAddressNumber number;
 647   EXPECT_TRUE(ParseURLHostnameToNumber("[1:abcd::3:4:ff]", &number));
 648   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
 649   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 650 }
 651
 652 TEST(NetUtilTest, IsIPv4Mapped) {
 653   IPAddressNumber ipv4_number;
 654   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 655   EXPECT_FALSE(IsIPv4Mapped(ipv4_number));
 656
 657   IPAddressNumber ipv6_number;
 658   EXPECT_TRUE(ParseIPLiteralToNumber("::1", &ipv4_number));
 659   EXPECT_FALSE(IsIPv4Mapped(ipv6_number));
 660
 661   IPAddressNumber ipv4mapped_number;
 662   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 663   EXPECT_TRUE(IsIPv4Mapped(ipv4mapped_number));
 664 }
 665
 666 TEST(NetUtilTest, ConvertIPv4MappedToIPv4) {
 667   IPAddressNumber ipv4mapped_number;
 668   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 669   IPAddressNumber expected;
 670   EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
 671   IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
 672   EXPECT_EQ(expected, result);
 673 }
 674
 675 // Test parsing invalid CIDR notation literals.
 676 TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
 677   const char* const bad_literals[] = {
 678       "foobar",
 679       "",
 680       "192.168.0.1",
 681       "::1",
 682       "/",
 683       "/1",
 684       "1",
 685       "192.168.1.1/-1",
 686       "192.168.1.1/33",
 687       "::1/-3",
 688       "a::3/129",
 689       "::1/x",
 690       "192.168.0.1//11"
 691   };
 692
 693   for (size_t i = 0; i < arraysize(bad_literals); ++i) {
 694     IPAddressNumber ip_number;
 695     size_t prefix_length_in_bits;
 696
 697     EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
 698                                      &ip_number,
 699                                      &prefix_length_in_bits));
 700   }
 701 }
 702
 703 // Test parsing a valid CIDR notation literal.
 704 TEST(NetUtilTest, ParseCIDRBlock_Valid) {
 705   IPAddressNumber ip_number;
 706   size_t prefix_length_in_bits;
 707
 708   EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
 709                                   &ip_number,
 710                                   &prefix_length_in_bits));
 711
 712   EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
 713   EXPECT_EQ(11u, prefix_length_in_bits);
 714 }
 715
 716 TEST(NetUtilTest, IPNumberMatchesPrefix) {
 717   struct {
 718     const char* const cidr_literal;
 719     const char* const ip_literal;
 720     bool expected_to_match;
 721   } tests[] = {
 722     // IPv4 prefix with IPv4 inputs.
 723     {
 724       "10.10.1.32/27",
 725       "10.10.1.44",
 726       true
 727     },
 728     {
 729       "10.10.1.32/27",
 730       "10.10.1.90",
 731       false
 732     },
 733     {
 734       "10.10.1.32/27",
 735       "10.10.1.90",
 736       false
 737     },
 738
 739     // IPv6 prefix with IPv6 inputs.
 740     {
 741       "2001:db8::/32",
 742       "2001:DB8:3:4::5",
 743       true
 744     },
 745     {
 746       "2001:db8::/32",
 747       "2001:c8::",
 748       false
 749     },
 750
 751     // IPv6 prefix with IPv4 inputs.
 752     {
 753       "2001:db8::/33",
 754       "192.168.0.1",
 755       false
 756     },
 757     {
 758       "::ffff:192.168.0.1/112",
 759       "192.168.33.77",
 760       true
 761     },
 762
 763     // IPv4 prefix with IPv6 inputs.
 764     {
 765       "10.11.33.44/16",
 766       "::ffff:0a0b:89",
 767       true
 768     },
 769     {
 770       "10.11.33.44/16",
 771       "::ffff:10.12.33.44",
 772       false
 773     },
 774   };
 775   for (size_t i = 0; i < arraysize(tests); ++i) {
 776     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
 777                                     tests[i].cidr_literal,
 778                                     tests[i].ip_literal));
 779
 780     IPAddressNumber ip_number;
 781     EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
 782
 783     IPAddressNumber ip_prefix;
 784     size_t prefix_length_in_bits;
 785
 786     EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
 787                                &ip_prefix,
 788                                &prefix_length_in_bits));
 789
 790     EXPECT_EQ(tests[i].expected_to_match,
 791               IPNumberMatchesPrefix(ip_number,
 792                                     ip_prefix,
 793                                     prefix_length_in_bits));
 794   }
 795 }
 796
 797 TEST(NetUtilTest, IsLocalhost) {
 798   EXPECT_TRUE(IsLocalhost("localhost"));
 799   EXPECT_TRUE(IsLocalhost("localhost.localdomain"));
 800   EXPECT_TRUE(IsLocalhost("localhost6"));
 801   EXPECT_TRUE(IsLocalhost("localhost6.localdomain6"));
 802   EXPECT_TRUE(IsLocalhost("127.0.0.1"));
 803   EXPECT_TRUE(IsLocalhost("127.0.1.0"));
 804   EXPECT_TRUE(IsLocalhost("127.1.0.0"));
 805   EXPECT_TRUE(IsLocalhost("127.0.0.255"));
 806   EXPECT_TRUE(IsLocalhost("127.0.255.0"));
 807   EXPECT_TRUE(IsLocalhost("127.255.0.0"));
 808   EXPECT_TRUE(IsLocalhost("::1"));
 809   EXPECT_TRUE(IsLocalhost("0:0:0:0:0:0:0:1"));
 810   EXPECT_TRUE(IsLocalhost("foo.localhost"));
 811
 812   EXPECT_FALSE(IsLocalhost("localhostx"));
 813   EXPECT_FALSE(IsLocalhost("foo.localdomain"));
 814   EXPECT_FALSE(IsLocalhost("localhost6x"));
 815   EXPECT_FALSE(IsLocalhost("localhost.localdomain6"));
 816   EXPECT_FALSE(IsLocalhost("localhost6.localdomain"));
 817   EXPECT_FALSE(IsLocalhost("127.0.0.1.1"));
 818   EXPECT_FALSE(IsLocalhost(".127.0.0.255"));
 819   EXPECT_FALSE(IsLocalhost("::2"));
 820   EXPECT_FALSE(IsLocalhost("::1:1"));
 821   EXPECT_FALSE(IsLocalhost("0:0:0:0:1:0:0:1"));
 822   EXPECT_FALSE(IsLocalhost("::1:1"));
 823   EXPECT_FALSE(IsLocalhost("0:0:0:0:0:0:0:0:1"));
 824   EXPECT_FALSE(IsLocalhost("foo.localhost.com"));
 825   EXPECT_FALSE(IsLocalhost("foo.localhoste"));
 826 }
 827
 828 TEST(NetUtilTest, IsLocalhostTLD) {
 829   EXPECT_TRUE(IsLocalhostTLD("foo.localhost"));
 830   EXPECT_TRUE(IsLocalhostTLD("foo.localhost."));
 831   EXPECT_FALSE(IsLocalhostTLD("foo.localhos"));
 832   EXPECT_FALSE(IsLocalhostTLD("foo.localhost.com"));
 833   EXPECT_FALSE(IsLocalhost("foo.localhoste"));
 834 }
 835
 836 TEST(NetUtilTest, GoogleHost) {
 837   struct GoogleHostCase {
 838     GURL url;
 839     bool expected_output;
 840   };
 841
 842   const GoogleHostCase google_host_cases[] = {
 843       {GURL("http://.google.com"), true},
 844       {GURL("http://.youtube.com"), true},
 845       {GURL("http://.gmail.com"), true},
 846       {GURL("http://.doubleclick.net"), true},
 847       {GURL("http://.gstatic.com"), true},
 848       {GURL("http://.googlevideo.com"), true},
 849       {GURL("http://.googleusercontent.com"), true},
 850       {GURL("http://.googlesyndication.com"), true},
 851       {GURL("http://.google-analytics.com"), true},
 852       {GURL("http://.googleadservices.com"), true},
 853       {GURL("http://.googleapis.com"), true},
 854       {GURL("http://a.google.com"), true},
 855       {GURL("http://b.youtube.com"), true},
 856       {GURL("http://c.gmail.com"), true},
 857       {GURL("http://google.com"), false},
 858       {GURL("http://youtube.com"), false},
 859       {GURL("http://gmail.com"), false},
 860       {GURL("http://google.coma"), false},
 861       {GURL("http://agoogle.com"), false},
 862       {GURL("http://oogle.com"), false},
 863       {GURL("http://google.co"), false},
 864       {GURL("http://oggole.com"), false},
 865   };
 866
 867   for (size_t i = 0; i < arraysize(google_host_cases); ++i) {
 868     EXPECT_EQ(google_host_cases[i].expected_output,
 869               HasGoogleHost(google_host_cases[i].url));
 870   }
 871 }
 872
 873 // Verify GetNetworkList().
 874 TEST(NetUtilTest, GetNetworkList) {
 875   NetworkInterfaceList list;
 876   ASSERT_TRUE(GetNetworkList(&list, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES));
 877   for (NetworkInterfaceList::iterator it = list.begin();
 878        it != list.end(); ++it) {
 879     // Verify that the names are not empty.
 880     EXPECT_FALSE(it->name.empty());
 881     EXPECT_FALSE(it->friendly_name.empty());
 882
 883     // Verify that the address is correct.
 884     EXPECT_TRUE(it->address.size() == kIPv4AddressSize ||
 885                 it->address.size() == kIPv6AddressSize)
 886         << "Invalid address of size " << it->address.size();
 887     bool all_zeroes = true;
 888     for (size_t i = 0; i < it->address.size(); ++i) {
 889       if (it->address[i] != 0) {
 890         all_zeroes = false;
 891         break;
 892       }
 893     }
 894     EXPECT_FALSE(all_zeroes);
 895     EXPECT_GT(it->prefix_length, 1u);
 896     EXPECT_LE(it->prefix_length, it->address.size() * 8);
 897
 898 #if defined(OS_WIN)
 899     // On Windows |name| is NET_LUID.
 900     base::ScopedNativeLibrary phlpapi_lib(
 901         base::FilePath(FILE_PATH_LITERAL("iphlpapi.dll")));
 902     ASSERT_TRUE(phlpapi_lib.is_valid());
 903     typedef NETIO_STATUS (WINAPI* ConvertInterfaceIndexToLuid)(NET_IFINDEX,
 904                                                                PNET_LUID);
 905     ConvertInterfaceIndexToLuid interface_to_luid =
 906         reinterpret_cast<ConvertInterfaceIndexToLuid>(
 907             phlpapi_lib.GetFunctionPointer("ConvertInterfaceIndexToLuid"));
 908
 909     typedef NETIO_STATUS (WINAPI* ConvertInterfaceLuidToGuid)(NET_LUID*,
 910                                                               GUID*);
 911     ConvertInterfaceLuidToGuid luid_to_guid =
 912         reinterpret_cast<ConvertInterfaceLuidToGuid>(
 913             phlpapi_lib.GetFunctionPointer("ConvertInterfaceLuidToGuid"));
 914
 915     if (interface_to_luid && luid_to_guid) {
 916       NET_LUID luid;
 917       EXPECT_EQ(interface_to_luid(it->interface_index, &luid), NO_ERROR);
 918       GUID guid;
 919       EXPECT_EQ(luid_to_guid(&luid, &guid), NO_ERROR);
 920       LPOLESTR name;
 921       StringFromCLSID(guid, &name);
 922       EXPECT_STREQ(base::UTF8ToWide(it->name).c_str(), name);
 923       CoTaskMemFree(name);
 924       continue;
 925     } else {
 926       EXPECT_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
 927       EXPECT_LT(it->interface_index, 1u << 24u);  // Must fit 0.x.x.x.
 928       EXPECT_NE(it->interface_index, 0u);  // 0 means to use default.
 929     }
 930     if (it->type == NetworkChangeNotifier::CONNECTION_WIFI) {
 931       EXPECT_NE(WIFI_PHY_LAYER_PROTOCOL_NONE, GetWifiPHYLayerProtocol());
 932     }
 933 #elif !defined(OS_ANDROID)
 934     char name[IF_NAMESIZE];
 935     EXPECT_TRUE(if_indextoname(it->interface_index, name));
 936     EXPECT_STREQ(it->name.c_str(), name);
 937 #endif
 938   }
 939 }
 940
 941 static const char ifname_em1[] = "em1";
 942 #if defined(OS_WIN)
 943 static const char ifname_vm[] = "VMnet";
 944 #else
 945 static const char ifname_vm[] = "vmnet";
 946 #endif  // OS_WIN
 947
 948 static const unsigned char kIPv6LocalAddr[] = {
 949   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 950
 951 // The following 3 addresses need to be changed together. IPv6Addr is the IPv6
 952 // address. IPv6Netmask is the mask address with as many leading bits set to 1
 953 // as the prefix length. IPv6AddrPrefix needs to match IPv6Addr with the same
 954 // number of bits as the prefix length.
 955 static const unsigned char kIPv6Addr[] =
 956   {0x24, 0x01, 0xfa, 0x00, 0x00, 0x04, 0x10, 0x00, 0xbe, 0x30, 0x5b, 0xff,
 957    0xfe, 0xe5, 0x00, 0xc3};
 958 #if defined(OS_WIN)
 959 static const unsigned char kIPv6AddrPrefix[] =
 960   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 961    0x00, 0x00, 0x00, 0x00};
 962 #endif  // OS_WIN
 963 #if defined(OS_MACOSX)
 964 static const unsigned char kIPv6Netmask[] =
 965   {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 966    0x00, 0x00, 0x00, 0x00};
 967 #endif  // OS_MACOSX
 968
 969 #if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_NACL)
 970
 971 char* CopyInterfaceName(const char* ifname, int ifname_size, char* output) {
 972   EXPECT_LT(ifname_size, IF_NAMESIZE);
 973   memcpy(output, ifname, ifname_size);
 974   return output;
 975 }
 976
 977 char* GetInterfaceName(int interface_index, char* ifname) {
 978   return CopyInterfaceName(ifname_em1, arraysize(ifname_em1), ifname);
 979 }
 980
 981 char* GetInterfaceNameVM(int interface_index, char* ifname) {
 982   return CopyInterfaceName(ifname_vm, arraysize(ifname_vm), ifname);
 983 }
 984
 985 TEST(NetUtilTest, GetNetworkListTrimming) {
 986   IPAddressNumber ipv6_local_address(
 987       kIPv6LocalAddr, kIPv6LocalAddr + arraysize(kIPv6LocalAddr));
 988   IPAddressNumber ipv6_address(kIPv6Addr, kIPv6Addr + arraysize(kIPv6Addr));
 989
 990   NetworkInterfaceList results;
 991   ::base::hash_set<int> online_links;
 992   internal::AddressTrackerLinux::AddressMap address_map;
 993
 994   // Interface 1 is offline.
 995   struct ifaddrmsg msg = {
 996       AF_INET6,
 997       1,               /* prefix length */
 998       IFA_F_TEMPORARY, /* address flags */
 999       0,               /* link scope */
1000       1                /* link index */
1001   };
1002
1003   // Address of offline links should be ignored.
1004   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1005   EXPECT_TRUE(internal::GetNetworkListImpl(
1006       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1007       address_map, GetInterfaceName));
1008   EXPECT_EQ(results.size(), 0ul);
1009
1010   // Mark interface 1 online.
1011   online_links.insert(1);
1012
1013   // Local address should be trimmed out.
1014   address_map.clear();
1015   ASSERT_TRUE(
1016       address_map.insert(std::make_pair(ipv6_local_address, msg)).second);
1017   EXPECT_TRUE(internal::GetNetworkListImpl(
1018       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1019       address_map, GetInterfaceName));
1020   EXPECT_EQ(results.size(), 0ul);
1021
1022   // vmware address should return by default.
1023   address_map.clear();
1024   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1025   EXPECT_TRUE(internal::GetNetworkListImpl(
1026       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1027       address_map, GetInterfaceNameVM));
1028   EXPECT_EQ(results.size(), 1ul);
1029   EXPECT_EQ(results[0].name, ifname_vm);
1030   EXPECT_EQ(results[0].prefix_length, 1ul);
1031   EXPECT_EQ(results[0].address, ipv6_address);
1032   results.clear();
1033
1034   // vmware address should be trimmed out if policy specified so.
1035   address_map.clear();
1036   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1037   EXPECT_TRUE(internal::GetNetworkListImpl(
1038       &results, EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1039       address_map, GetInterfaceNameVM));
1040   EXPECT_EQ(results.size(), 0ul);
1041   results.clear();
1042
1043   // Addresses with banned attributes should be ignored.
1044   address_map.clear();
1045   msg.ifa_flags = IFA_F_TENTATIVE;
1046   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1047   EXPECT_TRUE(internal::GetNetworkListImpl(
1048       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1049       address_map, GetInterfaceName));
1050   EXPECT_EQ(results.size(), 0ul);
1051   results.clear();
1052
1053   // Addresses with allowed attribute IFA_F_TEMPORARY should be returned and
1054   // attributes should be translated correctly.
1055   address_map.clear();
1056   msg.ifa_flags = IFA_F_TEMPORARY;
1057   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1058   EXPECT_TRUE(internal::GetNetworkListImpl(
1059       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1060       address_map, GetInterfaceName));
1061   EXPECT_EQ(results.size(), 1ul);
1062   EXPECT_EQ(results[0].name, ifname_em1);
1063   EXPECT_EQ(results[0].prefix_length, 1ul);
1064   EXPECT_EQ(results[0].address, ipv6_address);
1065   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_TEMPORARY);
1066   results.clear();
1067
1068   // Addresses with allowed attribute IFA_F_DEPRECATED should be returned and
1069   // attributes should be translated correctly.
1070   address_map.clear();
1071   msg.ifa_flags = IFA_F_DEPRECATED;
1072   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
1073   EXPECT_TRUE(internal::GetNetworkListImpl(
1074       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, online_links,
1075       address_map, GetInterfaceName));
1076   EXPECT_EQ(results.size(), 1ul);
1077   EXPECT_EQ(results[0].name, ifname_em1);
1078   EXPECT_EQ(results[0].prefix_length, 1ul);
1079   EXPECT_EQ(results[0].address, ipv6_address);
1080   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_DEPRECATED);
1081   results.clear();
1082 }
1083
1084 #elif defined(OS_MACOSX)
1085
1086 TEST(NetUtilTest, GetNetworkListTrimming) {
1087   IPAddressNumber ipv6_local_address(
1088       kIPv6LocalAddr, kIPv6LocalAddr + arraysize(kIPv6LocalAddr));
1089   IPAddressNumber ipv6_address(kIPv6Addr, kIPv6Addr + arraysize(kIPv6Addr));
1090   IPAddressNumber ipv6_netmask(kIPv6Netmask,
1091                                kIPv6Netmask + arraysize(kIPv6Netmask));
1092
1093   NetworkInterfaceList results;
1094   IPAttributesGetterTest ip_attributes_getter;
1095   sockaddr_storage addresses[2];
1096   ifaddrs interface;
1097
1098   // Address of offline links should be ignored.
1099   ASSERT_TRUE(FillIfaddrs(&interface, ifname_em1, IFF_UP, ipv6_address,
1100                           ipv6_netmask, addresses));
1101   EXPECT_TRUE(internal::GetNetworkListImpl(
1102       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1103       &ip_attributes_getter));
1104   EXPECT_EQ(results.size(), 0ul);
1105
1106   // Local address should be trimmed out.
1107   ASSERT_TRUE(FillIfaddrs(&interface, ifname_em1, IFF_RUNNING,
1108                           ipv6_local_address, ipv6_netmask, addresses));
1109   EXPECT_TRUE(internal::GetNetworkListImpl(
1110       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1111       &ip_attributes_getter));
1112   EXPECT_EQ(results.size(), 0ul);
1113
1114   // vmware address should return by default.
1115   ASSERT_TRUE(FillIfaddrs(&interface, ifname_vm, IFF_RUNNING, ipv6_address,
1116                           ipv6_netmask, addresses));
1117   EXPECT_TRUE(internal::GetNetworkListImpl(
1118       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1119       &ip_attributes_getter));
1120   EXPECT_EQ(results.size(), 1ul);
1121   EXPECT_EQ(results[0].name, ifname_vm);
1122   EXPECT_EQ(results[0].prefix_length, 1ul);
1123   EXPECT_EQ(results[0].address, ipv6_address);
1124   results.clear();
1125
1126   // vmware address should be trimmed out if policy specified so.
1127   ASSERT_TRUE(FillIfaddrs(&interface, ifname_vm, IFF_RUNNING, ipv6_address,
1128                           ipv6_netmask, addresses));
1129   EXPECT_TRUE(internal::GetNetworkListImpl(
1130       &results, EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1131       &ip_attributes_getter));
1132   EXPECT_EQ(results.size(), 0ul);
1133   results.clear();
1134
1135 #if !defined(OS_IOS)
1136   // Addresses with banned attributes should be ignored.
1137   ip_attributes_getter.set_native_attributes(IN6_IFF_ANYCAST);
1138   ASSERT_TRUE(FillIfaddrs(&interface, ifname_em1, IFF_RUNNING, ipv6_address,
1139                           ipv6_netmask, addresses));
1140   EXPECT_TRUE(internal::GetNetworkListImpl(
1141       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1142       &ip_attributes_getter));
1143   EXPECT_EQ(results.size(), 0ul);
1144   results.clear();
1145
1146   // Addresses with allowed attribute IFA_F_TEMPORARY should be returned and
1147   // attributes should be translated correctly.
1148   ip_attributes_getter.set_native_attributes(IN6_IFF_TEMPORARY);
1149   ASSERT_TRUE(FillIfaddrs(&interface, ifname_em1, IFF_RUNNING, ipv6_address,
1150                           ipv6_netmask, addresses));
1151   EXPECT_TRUE(internal::GetNetworkListImpl(
1152       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1153       &ip_attributes_getter));
1154   EXPECT_EQ(results.size(), 1ul);
1155   EXPECT_EQ(results[0].name, ifname_em1);
1156   EXPECT_EQ(results[0].prefix_length, 1ul);
1157   EXPECT_EQ(results[0].address, ipv6_address);
1158   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_TEMPORARY);
1159   results.clear();
1160
1161   // Addresses with allowed attribute IFA_F_DEPRECATED should be returned and
1162   // attributes should be translated correctly.
1163   ip_attributes_getter.set_native_attributes(IN6_IFF_DEPRECATED);
1164   ASSERT_TRUE(FillIfaddrs(&interface, ifname_em1, IFF_RUNNING, ipv6_address,
1165                           ipv6_netmask, addresses));
1166   EXPECT_TRUE(internal::GetNetworkListImpl(
1167       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, &interface,
1168       &ip_attributes_getter));
1169   EXPECT_EQ(results.size(), 1ul);
1170   EXPECT_EQ(results[0].name, ifname_em1);
1171   EXPECT_EQ(results[0].prefix_length, 1ul);
1172   EXPECT_EQ(results[0].address, ipv6_address);
1173   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_DEPRECATED);
1174   results.clear();
1175 #endif  // !OS_IOS
1176 }
1177 #elif defined(OS_WIN)  // !OS_MACOSX && !OS_WIN && !OS_NACL
1178
1179 // Helper function to create a valid IP_ADAPTER_ADDRESSES with reasonable
1180 // default value. The output is the |adapter_address|. All the rests are input
1181 // to fill the |adapter_address|. |sock_addrs| are temporary storage used by
1182 // |adapter_address| once the function is returned.
1183 bool FillAdapterAddress(IP_ADAPTER_ADDRESSES* adapter_address,
1184                         const char* ifname,
1185                         const IPAddressNumber& ip_address,
1186                         const IPAddressNumber& ip_netmask,
1187                         sockaddr_storage sock_addrs[2]) {
1188   adapter_address->AdapterName = const_cast<char*>(ifname);
1189   adapter_address->FriendlyName = const_cast<PWCHAR>(L"interface");
1190   adapter_address->IfType = IF_TYPE_ETHERNET_CSMACD;
1191   adapter_address->OperStatus = IfOperStatusUp;
1192   adapter_address->FirstUnicastAddress->DadState = IpDadStatePreferred;
1193   adapter_address->FirstUnicastAddress->PrefixOrigin = IpPrefixOriginOther;
1194   adapter_address->FirstUnicastAddress->SuffixOrigin = IpSuffixOriginOther;
1195   adapter_address->FirstUnicastAddress->PreferredLifetime = 100;
1196   adapter_address->FirstUnicastAddress->ValidLifetime = 1000;
1197
1198   socklen_t sock_len = sizeof(sockaddr_storage);
1199
1200   // Convert to sockaddr for next check.
1201   if (!IPEndPoint(ip_address, 0)
1202            .ToSockAddr(reinterpret_cast<sockaddr*>(&sock_addrs[0]),
1203                        &sock_len)) {
1204     return false;
1205   }
1206   adapter_address->FirstUnicastAddress->Address.lpSockaddr =
1207       reinterpret_cast<sockaddr*>(&sock_addrs[0]);
1208   adapter_address->FirstUnicastAddress->Address.iSockaddrLength = sock_len;
1209   adapter_address->FirstUnicastAddress->OnLinkPrefixLength = 1;
1210
1211   sock_len = sizeof(sockaddr_storage);
1212   if (!IPEndPoint(ip_netmask, 0)
1213            .ToSockAddr(reinterpret_cast<sockaddr*>(&sock_addrs[1]),
1214                        &sock_len)) {
1215     return false;
1216   }
1217   adapter_address->FirstPrefix->Address.lpSockaddr =
1218       reinterpret_cast<sockaddr*>(&sock_addrs[1]);
1219   adapter_address->FirstPrefix->Address.iSockaddrLength = sock_len;
1220   adapter_address->FirstPrefix->PrefixLength = 1;
1221
1222   DCHECK_EQ(sock_addrs[0].ss_family, sock_addrs[1].ss_family);
1223   if (sock_addrs[0].ss_family == AF_INET6) {
1224     adapter_address->Ipv6IfIndex = 0;
1225   } else {
1226     DCHECK_EQ(sock_addrs[0].ss_family, AF_INET);
1227     adapter_address->IfIndex = 0;
1228   }
1229
1230   return true;
1231 }
1232
1233 TEST(NetUtilTest, GetNetworkListTrimming) {
1234   IPAddressNumber ipv6_local_address(
1235       kIPv6LocalAddr, kIPv6LocalAddr + arraysize(kIPv6LocalAddr));
1236   IPAddressNumber ipv6_address(kIPv6Addr, kIPv6Addr + arraysize(kIPv6Addr));
1237   IPAddressNumber ipv6_prefix(kIPv6AddrPrefix,
1238                               kIPv6AddrPrefix + arraysize(kIPv6AddrPrefix));
1239
1240   NetworkInterfaceList results;
1241   sockaddr_storage addresses[2];
1242   IP_ADAPTER_ADDRESSES adapter_address = {0};
1243   IP_ADAPTER_UNICAST_ADDRESS address = {0};
1244   IP_ADAPTER_PREFIX adapter_prefix = {0};
1245   adapter_address.FirstUnicastAddress = &address;
1246   adapter_address.FirstPrefix = &adapter_prefix;
1247
1248   // Address of offline links should be ignored.
1249   ASSERT_TRUE(FillAdapterAddress(
1250       &adapter_address /* adapter_address */, ifname_em1 /* ifname */,
1251       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1252       addresses /* sock_addrs */));
1253   adapter_address.OperStatus = IfOperStatusDown;
1254
1255   EXPECT_TRUE(internal::GetNetworkListImpl(
1256       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1257
1258   EXPECT_EQ(results.size(), 0ul);
1259
1260   // Address on loopback interface should be trimmed out.
1261   ASSERT_TRUE(FillAdapterAddress(
1262       &adapter_address /* adapter_address */, ifname_em1 /* ifname */,
1263       ipv6_local_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1264       addresses /* sock_addrs */));
1265   adapter_address.IfType = IF_TYPE_SOFTWARE_LOOPBACK;
1266
1267   EXPECT_TRUE(internal::GetNetworkListImpl(
1268       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1269   EXPECT_EQ(results.size(), 0ul);
1270
1271   // vmware address should return by default.
1272   ASSERT_TRUE(FillAdapterAddress(
1273       &adapter_address /* adapter_address */, ifname_vm /* ifname */,
1274       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1275       addresses /* sock_addrs */));
1276   EXPECT_TRUE(internal::GetNetworkListImpl(
1277       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1278   EXPECT_EQ(results.size(), 1ul);
1279   EXPECT_EQ(results[0].name, ifname_vm);
1280   EXPECT_EQ(results[0].prefix_length, 1ul);
1281   EXPECT_EQ(results[0].address, ipv6_address);
1282   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_NONE);
1283   results.clear();
1284
1285   // vmware address should be trimmed out if policy specified so.
1286   ASSERT_TRUE(FillAdapterAddress(
1287       &adapter_address /* adapter_address */, ifname_vm /* ifname */,
1288       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1289       addresses /* sock_addrs */));
1290   EXPECT_TRUE(internal::GetNetworkListImpl(
1291       &results, EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1292   EXPECT_EQ(results.size(), 0ul);
1293   results.clear();
1294
1295   // Addresses with incompleted DAD should be ignored.
1296   ASSERT_TRUE(FillAdapterAddress(
1297       &adapter_address /* adapter_address */, ifname_em1 /* ifname */,
1298       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1299       addresses /* sock_addrs */));
1300   adapter_address.FirstUnicastAddress->DadState = IpDadStateTentative;
1301
1302   EXPECT_TRUE(internal::GetNetworkListImpl(
1303       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1304   EXPECT_EQ(results.size(), 0ul);
1305   results.clear();
1306
1307   // Addresses with allowed attribute IpSuffixOriginRandom should be returned
1308   // and attributes should be translated correctly to
1309   // IP_ADDRESS_ATTRIBUTE_TEMPORARY.
1310   ASSERT_TRUE(FillAdapterAddress(
1311       &adapter_address /* adapter_address */, ifname_em1 /* ifname */,
1312       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1313       addresses /* sock_addrs */));
1314   adapter_address.FirstUnicastAddress->PrefixOrigin =
1315       IpPrefixOriginRouterAdvertisement;
1316   adapter_address.FirstUnicastAddress->SuffixOrigin = IpSuffixOriginRandom;
1317
1318   EXPECT_TRUE(internal::GetNetworkListImpl(
1319       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1320   EXPECT_EQ(results.size(), 1ul);
1321   EXPECT_EQ(results[0].name, ifname_em1);
1322   EXPECT_EQ(results[0].prefix_length, 1ul);
1323   EXPECT_EQ(results[0].address, ipv6_address);
1324   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_TEMPORARY);
1325   results.clear();
1326
1327   // Addresses with preferred lifetime 0 should be returned and
1328   // attributes should be translated correctly to
1329   // IP_ADDRESS_ATTRIBUTE_DEPRECATED.
1330   ASSERT_TRUE(FillAdapterAddress(
1331       &adapter_address /* adapter_address */, ifname_em1 /* ifname */,
1332       ipv6_address /* ip_address */, ipv6_prefix /* ip_netmask */,
1333       addresses /* sock_addrs */));
1334   adapter_address.FirstUnicastAddress->PreferredLifetime = 0;
1335   adapter_address.FriendlyName = const_cast<PWCHAR>(L"FriendlyInterfaceName");
1336   EXPECT_TRUE(internal::GetNetworkListImpl(
1337       &results, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES, true, &adapter_address));
1338   EXPECT_EQ(results.size(), 1ul);
1339   EXPECT_EQ(results[0].friendly_name, "FriendlyInterfaceName");
1340   EXPECT_EQ(results[0].name, ifname_em1);
1341   EXPECT_EQ(results[0].prefix_length, 1ul);
1342   EXPECT_EQ(results[0].address, ipv6_address);
1343   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_DEPRECATED);
1344   results.clear();
1345 }
1346
1347 #endif  // !OS_MACOSX && !OS_WIN && !OS_NACL
1348
1349 TEST(NetUtilTest, GetWifiSSID) {
1350   // We can't check the result of GetWifiSSID() directly, since the result
1351   // will differ across machines. Simply exercise the code path and hope that it
1352   // doesn't crash.
1353   EXPECT_NE((const char*)NULL, GetWifiSSID().c_str());
1354 }
1355
1356 #if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_CHROMEOS)
1357 TEST(NetUtilTest, GetWifiSSIDFromInterfaceList) {
1358   NetworkInterfaceList list;
1359   EXPECT_EQ(std::string(), internal::GetWifiSSIDFromInterfaceListInternal(
1360                                list, TestGetInterfaceSSID));
1361
1362   NetworkInterface interface1;
1363   interface1.name = "wlan0";
1364   interface1.type = NetworkChangeNotifier::CONNECTION_WIFI;
1365   list.push_back(interface1);
1366   ASSERT_EQ(1u, list.size());
1367   EXPECT_EQ(std::string(kWiFiSSID),
1368             internal::GetWifiSSIDFromInterfaceListInternal(
1369                 list, TestGetInterfaceSSID));
1370
1371   NetworkInterface interface2;
1372   interface2.name = "wlan1";
1373   interface2.type = NetworkChangeNotifier::CONNECTION_WIFI;
1374   list.push_back(interface2);
1375   ASSERT_EQ(2u, list.size());
1376   EXPECT_EQ(std::string(kWiFiSSID),
1377             internal::GetWifiSSIDFromInterfaceListInternal(
1378                 list, TestGetInterfaceSSID));
1379
1380   NetworkInterface interface3;
1381   interface3.name = kInterfaceWithDifferentSSID;
1382   interface3.type = NetworkChangeNotifier::CONNECTION_WIFI;
1383   list.push_back(interface3);
1384   ASSERT_EQ(3u, list.size());
1385   EXPECT_EQ(std::string(), internal::GetWifiSSIDFromInterfaceListInternal(
1386                                list, TestGetInterfaceSSID));
1387
1388   list.pop_back();
1389   NetworkInterface interface4;
1390   interface4.name = "eth0";
1391   interface4.type = NetworkChangeNotifier::CONNECTION_ETHERNET;
1392   list.push_back(interface4);
1393   ASSERT_EQ(3u, list.size());
1394   EXPECT_EQ(std::string(), internal::GetWifiSSIDFromInterfaceListInternal(
1395                                list, TestGetInterfaceSSID));
1396 }
1397 #endif  // OS_LINUX
1398
1399 namespace {
1400
1401 #if defined(OS_WIN)
1402 bool read_int_or_bool(DWORD data_size,
1403                       PVOID data) {
1404   switch (data_size) {
1405     case 1:
1406       return !!*reinterpret_cast<uint8*>(data);
1407     case 4:
1408       return !!*reinterpret_cast<uint32*>(data);
1409     default:
1410       LOG(FATAL) << "That is not a type I know!";
1411       return false;
1412   }
1413 }
1414
1415 int GetWifiOptions() {
1416   const internal::WlanApi& wlanapi = internal::WlanApi::GetInstance();
1417   if (!wlanapi.initialized)
1418     return -1;
1419
1420   internal::WlanHandle client;
1421   DWORD cur_version = 0;
1422   const DWORD kMaxClientVersion = 2;
1423   DWORD result = wlanapi.OpenHandle(
1424       kMaxClientVersion, &cur_version, &client);
1425   if (result != ERROR_SUCCESS)
1426     return -1;
1427
1428   WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
1429   result = wlanapi.enum_interfaces_func(client.Get(), NULL,
1430                                         &interface_list_ptr);
1431   if (result != ERROR_SUCCESS)
1432     return -1;
1433   scoped_ptr<WLAN_INTERFACE_INFO_LIST, internal::WlanApiDeleter> interface_list(
1434       interface_list_ptr);
1435
1436   for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
1437     WLAN_INTERFACE_INFO* info = &interface_list->InterfaceInfo[i];
1438     DWORD data_size;
1439     PVOID data;
1440     int options = 0;
1441     result = wlanapi.query_interface_func(
1442         client.Get(),
1443         &info->InterfaceGuid,
1444         wlan_intf_opcode_background_scan_enabled,
1445         NULL,
1446         &data_size,
1447         &data,
1448         NULL);
1449     if (result != ERROR_SUCCESS)
1450       continue;
1451     if (!read_int_or_bool(data_size, data)) {
1452       options |= WIFI_OPTIONS_DISABLE_SCAN;
1453     }
1454     internal::WlanApi::GetInstance().free_memory_func(data);
1455
1456     result = wlanapi.query_interface_func(
1457         client.Get(),
1458         &info->InterfaceGuid,
1459         wlan_intf_opcode_media_streaming_mode,
1460         NULL,
1461         &data_size,
1462         &data,
1463         NULL);
1464     if (result != ERROR_SUCCESS)
1465       continue;
1466     if (read_int_or_bool(data_size, data)) {
1467       options |= WIFI_OPTIONS_MEDIA_STREAMING_MODE;
1468     }
1469     internal::WlanApi::GetInstance().free_memory_func(data);
1470
1471     // Just the the options from the first succesful
1472     // interface.
1473     return options;
1474   }
1475
1476   // No wifi interface found.
1477   return -1;
1478 }
1479
1480 #else  // OS_WIN
1481
1482 int GetWifiOptions() {
1483   // Not supported.
1484   return -1;
1485 }
1486
1487 #endif  // OS_WIN
1488
1489 void TryChangeWifiOptions(int options) {
1490   int previous_options = GetWifiOptions();
1491   scoped_ptr<ScopedWifiOptions> scoped_options = SetWifiOptions(options);
1492   EXPECT_EQ(previous_options | options, GetWifiOptions());
1493   scoped_options.reset();
1494   EXPECT_EQ(previous_options, GetWifiOptions());
1495 }
1496
1497 };  // namespace
1498
1499 // Test SetWifiOptions().
1500 TEST(NetUtilTest, SetWifiOptionsTest) {
1501   TryChangeWifiOptions(0);
1502   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN);
1503   TryChangeWifiOptions(WIFI_OPTIONS_MEDIA_STREAMING_MODE);
1504   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN |
1505                        WIFI_OPTIONS_MEDIA_STREAMING_MODE);
1506 }
1507
1508 struct NonUniqueNameTestData {
1509   bool is_unique;
1510   const char* const hostname;
1511 };
1512
1513 // Google Test pretty-printer.
1514 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
1515   ASSERT_TRUE(data.hostname);
1516   *os << " hostname: " << testing::PrintToString(data.hostname)
1517       << "; is_unique: " << testing::PrintToString(data.is_unique);
1518 }
1519
1520 const NonUniqueNameTestData kNonUniqueNameTestData[] = {
1521     // Domains under ICANN-assigned domains.
1522     { true, "google.com" },
1523     { true, "google.co.uk" },
1524     // Domains under private registries.
1525     { true, "appspot.com" },
1526     { true, "test.appspot.com" },
1527     // Unreserved IPv4 addresses (in various forms).
1528     { true, "8.8.8.8" },
1529     { true, "99.64.0.0" },
1530     { true, "212.15.0.0" },
1531     { true, "212.15" },
1532     { true, "212.15.0" },
1533     { true, "3557752832" },
1534     // Reserved IPv4 addresses (in various forms).
1535     { false, "192.168.0.0" },
1536     { false, "192.168.0.6" },
1537     { false, "10.0.0.5" },
1538     { false, "10.0" },
1539     { false, "10.0.0" },
1540     { false, "3232235526" },
1541     // Unreserved IPv6 addresses.
1542     { true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1543     { true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210" },
1544     // Reserved IPv6 addresses.
1545     { false, "::192.9.5.5" },
1546     { false, "FEED::BEEF" },
1547     { false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1548     // 'internal'/non-IANA assigned domains.
1549     { false, "intranet" },
1550     { false, "intranet." },
1551     { false, "intranet.example" },
1552     { false, "host.intranet.example" },
1553     // gTLDs under discussion, but not yet assigned.
1554     { false, "intranet.corp" },
1555     { false, "intranet.internal" },
1556     // Invalid host names are treated as unique - but expected to be
1557     // filtered out before then.
1558     { true, "junk)(£)$*!@~#" },
1559     { true, "w$w.example.com" },
1560     { true, "nocolonsallowed:example" },
1561     { true, "[::4.5.6.9]" },
1562 };
1563
1564 class NetUtilNonUniqueNameTest
1565     : public testing::TestWithParam<NonUniqueNameTestData> {
1566  public:
1567   virtual ~NetUtilNonUniqueNameTest() {}
1568
1569  protected:
1570   bool IsUnique(const std::string& hostname) {
1571     return !IsHostnameNonUnique(hostname);
1572   }
1573 };
1574
1575 // Test that internal/non-unique names are properly identified as such, but
1576 // that IP addresses and hosts beneath registry-controlled domains are flagged
1577 // as unique names.
1578 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
1579   const NonUniqueNameTestData& test_data = GetParam();
1580
1581   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
1582 }
1583
1584 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
1585                         testing::ValuesIn(kNonUniqueNameTestData));
1586
1587 }  // namespace net