Add constructor for creating an AddressList from a struct sockaddr. This is...

net/base/address_list.cc

 // Copyright (c) 2010 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/address_list.h"
 
 #include <stdlib.h>
 
 #include "base/logging.h"
 #include "net/base/net_util.h"
@@ skipping 130 matching lines @@
   }
 
   if (canonicalize_name) {
     std::string name = NetAddressToString(ai);
     ai->ai_canonname = do_strdup(name.c_str());
   }
   data_ = new Data(ai, false /*is_system_created*/);
   SetPort(port);
 }
 
+AddressList::AddressList(struct sockaddr* address,
+                         socklen_t address_length,
+                         int socket_type,
+                         int protocol) {
+  // Do sanity checking on socket_type and protocol.
+  DCHECK(socket_type == SOCK_DGRAM || socket_type == SOCK_STREAM);
+  DCHECK(protocol == IPPROTO_TCP || protocol == IPPROTO_UDP);
+
+  struct addrinfo* ai = new addrinfo;
+  memset(ai, 0, sizeof(addrinfo));
+  switch (address_length) {
+    case sizeof(struct sockaddr_in):
+      {
+        struct sockaddr_in* sin =
+            reinterpret_cast<struct sockaddr_in*>(address);
+        ai->ai_family = sin->sin_family;
+        DCHECK_EQ(AF_INET, ai->ai_family);
+      }
+      break;
+    case sizeof(struct sockaddr_in6):
+      {
+        struct sockaddr_in6* sin6 =
+            reinterpret_cast<struct sockaddr_in6*>(address);
+        ai->ai_family = sin6->sin6_family;
+        DCHECK_EQ(AF_INET6, ai->ai_family);
+      }
+      break;
+    default:
+      NOTREACHED() << "Bad IP address";
+      break;
+  }
+  ai->ai_socktype = socket_type;
+  ai->ai_protocol = protocol;
+  ai->ai_addrlen = address_length;
+  ai->ai_addr = reinterpret_cast<struct sockaddr*>(new char[address_length]);
+  memcpy(ai->ai_addr, address, address_length);
+  data_ = new Data(ai, false /*is_system_created*/);
+}
+
 AddressList::AddressList(const AddressList& addresslist)
     : data_(addresslist.data_) {
 }
 
 AddressList::~AddressList() {
 }
 
 AddressList& AddressList::operator=(const AddressList& addresslist) {
   data_ = addresslist.data_;
   return *this;
@@ skipping 51 matching lines @@
     return false;
   canonical_name->assign(data_->head->ai_canonname);
   return true;
 }
 
 void AddressList::Reset() {
   data_ = NULL;
 }
 
 const struct addrinfo* AddressList::head() const {
+  if (!data_)
+    return NULL;

[eroman, 2011/03/01 02:52:33]

under what circumstance is this valid?

Seems like we may just be deferring the crash to some other callsite which is
now getting a NULL.

[Mike Belshe, 2011/03/01 19:01:33]

AddressList foo;
if (foo->head())
   blah blah

This would crash.

I find it inconsistent to a) require that we not overload constructors (which
forces things like uninitialized AddressList() objects) and then b) to not
provide graceful accessors around the object (like in this case).  Now we've got
the weird state of both not being able to construct them and not being able to
tell if you've initialized yourself.

[eroman, 2011/03/01 22:11:53]

I disagree.

I think it is wrong for code to be inspecting whether the object is "valid" or
not. It seems like a logic error if consumers are being handed invalid
AddressLists. They should not have to be checking for this (hence crashing IMO
is the appropriate choice).

In fact I would rather we crash when invoking foo->head(), then to be passing
NULL deep into some system library which may not be handling that, and only
crashing later.

   return data_->head;
 }
 
 AddressList::AddressList(Data* data) : data_(data) {}
 
 AddressList::Data::Data(struct addrinfo* ai, bool is_system_created)
     : head(ai), is_system_created(is_system_created) {
   DCHECK(head);
 }
 
 AddressList::Data::~Data() {
   // Call either freeaddrinfo(head), or FreeMyAddrinfo(head), depending who
   // created the data.
   if (is_system_created)
     freeaddrinfo(head);
   else
     FreeMyAddrinfo(head);
 }
 
 }  // namespace net