Reimplements net::AddressList without struct addrinfo.

net/base/net_util_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/net_util.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/file_path.h"
 #include "base/format_macros.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_string_conversions.h"
 #include "base/test/test_file_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/sys_addrinfo.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 static const size_t kNpos = string16::npos;
 
 struct FileCase {
   const wchar_t* file;
@@ skipping 365 matching lines @@
 struct UrlTestData {
   const char* description;
   const char* input;
   const char* languages;
   FormatUrlTypes format_types;
   UnescapeRule::Type escape_rules;
   const wchar_t* output;  // Use |wchar_t| to handle Unicode constants easily.
   size_t prefix_len;
 };
 
-// Returns an addrinfo for the given 32-bit address (IPv4.)
-// The result lives in static storage, so don't delete it.
+// Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
-const struct addrinfo* GetIPv4Address(const uint8* bytes, int port) {
-  static struct addrinfo static_ai;
-  static struct sockaddr_in static_addr4;
-
-  struct addrinfo* ai = &static_ai;
-  ai->ai_socktype = SOCK_STREAM;
-  memset(ai, 0, sizeof(static_ai));
-
-  ai->ai_family = AF_INET;
-  ai->ai_addrlen = sizeof(static_addr4);
-
-  struct sockaddr_in* addr4 = &static_addr4;
-  memset(addr4, 0, sizeof(static_addr4));
+void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+  memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
+  storage->addr_len = sizeof(struct sockaddr_in);
+  struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
-  addr4->sin_family = ai->ai_family;
+  addr4->sin_family = AF_INET;
   memcpy(&addr4->sin_addr, bytes, 4);
-
-  ai->ai_addr = (sockaddr*)addr4;
-  return ai;
 }
 
-// Returns a addrinfo for the given 128-bit address (IPv6.)
-// The result lives in static storage, so don't delete it.
+// Fills in sockaddr for the given 128-bit address (IPv6.)
 // |bytes| should be an array of length 16.
-const struct addrinfo* GetIPv6Address(const uint8* bytes, int port) {
-  static struct addrinfo static_ai;
-  static struct sockaddr_in6 static_addr6;
-
-  struct addrinfo* ai = &static_ai;
-  ai->ai_socktype = SOCK_STREAM;
-  memset(ai, 0, sizeof(static_ai));
-
-  ai->ai_family = AF_INET6;
-  ai->ai_addrlen = sizeof(static_addr6);
-
-  struct sockaddr_in6* addr6 = &static_addr6;
-  memset(addr6, 0, sizeof(static_addr6));
+void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+  memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
+  storage->addr_len = sizeof(struct sockaddr_in6);
+  struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
   addr6->sin6_port = base::HostToNet16(port);
-  addr6->sin6_family = ai->ai_family;
+  addr6->sin6_family = AF_INET6;
   memcpy(&addr6->sin6_addr, bytes, 16);
-
-  ai->ai_addr = (sockaddr*)addr6;
-  return ai;
 }
 
 // A helper for IDN*{Fast,Slow}.
 // Append "::<language list>" to |expected| and |actual| to make it
 // easy to tell which sub-case fails without debugging.
 void AppendLanguagesToOutputs(const char* languages,
                               string16* expected,
                               string16* actual) {
   string16 to_append = ASCIIToUTF16("::") + ASCIIToUTF16(languages);
   expected->append(to_append);
@@ skipping 1799 matching lines @@
   const struct {
     uint8 addr[4];
     const char* result;
   } tests[] = {
     {{0, 0, 0, 0}, "0.0.0.0"},
     {{127, 0, 0, 1}, "127.0.0.1"},
     {{192, 168, 0, 1}, "192.168.0.1"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    const addrinfo* ai = GetIPv4Address(tests[i].addr, 80);
-    std::string result = NetAddressToString(ai);
+    SockaddrStorage storage;
+    MakeIPv4Address(tests[i].addr, 80, &storage);
+    std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv6) {
   const struct {
     uint8 addr[16];
     const char* result;
   } tests[] = {
     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10},
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    const addrinfo* ai = GetIPv6Address(tests[i].addr, 80);
-    std::string result = NetAddressToString(ai);
+    SockaddrStorage storage;
+    MakeIPv6Address(tests[i].addr, 80, &storage);
+    std::string result = NetAddressToString(storage.addr, storage.addr_len);
     // Allow NetAddressToString() to fail, in case the system doesn't
     // support IPv6.
     if (!result.empty())
       EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
   uint8 addr[] = {127, 0, 0, 1};
-  const addrinfo* ai = GetIPv4Address(addr, 166);
-  std::string result = NetAddressToStringWithPort(ai);
+  SockaddrStorage storage;
+  MakeIPv4Address(addr, 166, &storage);
+  std::string result = NetAddressToStringWithPort(storage.addr,
+                                                  storage.addr_len);
   EXPECT_EQ("127.0.0.1:166", result);
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
   uint8 addr[] = {
       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10
   };
-  const addrinfo* ai = GetIPv6Address(addr, 361);
-  std::string result = NetAddressToStringWithPort(ai);
+  SockaddrStorage storage;
+  MakeIPv6Address(addr, 361, &storage);
+  std::string result = NetAddressToStringWithPort(storage.addr,
+                                                  storage.addr_len);
 
   // May fail on systems that don't support IPv6.
   if (!result.empty())
     EXPECT_EQ("[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:361", result);
 }
 
 TEST(NetUtilTest, GetHostName) {
   // We can't check the result of GetHostName() directly, since the result
   // will differ across machines. Our goal here is to simply exercise the
   // code path, and check that things "look about right".
@@ skipping 893 matching lines @@
       if (it->address[i] != 0) {
         all_zeroes = false;
         break;
       }
     }
     EXPECT_FALSE(all_zeroes);
   }
 }
 
 }  // namespace net