Add new InternetAddress class with a static lookup function (including IPv6 results).

runtime/bin/socket_linux.cc

Index: runtime/bin/socket_linux.cc
diff --git a/runtime/bin/socket_linux.cc b/runtime/bin/socket_linux.cc
index 23e492c930f58bb6446b0fb26c896678816d27ad..4d2ab56f50808ecf2cdd18e3c9203c7e233f8255 100644
--- a/runtime/bin/socket_linux.cc
+++ b/runtime/bin/socket_linux.cc
@@ -25,12 +25,14 @@ bool Socket::Initialize() {
 }
 
 
-intptr_t Socket::CreateConnect(const char* host, const intptr_t port) {
+intptr_t Socket::CreateConnect(SocketAddress::Type type,

[Søren Gjesse, 2013/04/18 09:07:40]

I don't think we need the type. sockaddr_in has a family member first.

[Anders Johnsen, 2013/04/18 12:09:45]

Done.

+                               uint8_t* host_data,

[Søren Gjesse, 2013/04/18 09:07:40]

sockaddr_storage* address or sockaddr_in* address

[Anders Johnsen, 2013/04/18 12:09:45]

Done.

+                               intptr_t host_length,
+                               const intptr_t port) {
   intptr_t fd;
-  struct hostent server;
-  struct sockaddr_in server_address;
 
-  fd = TEMP_FAILURE_RETRY(socket(AF_INET, SOCK_STREAM, 0));
+  fd = TEMP_FAILURE_RETRY(
+      socket(type == SocketAddress::IPv6 ? AF_INET6 : AF_INET, SOCK_STREAM, 0));
   if (fd < 0) {
     Log::PrintErr("Error CreateConnect: %s\n", strerror(errno));
     return -1;
@@ -39,28 +41,16 @@ intptr_t Socket::CreateConnect(const char* host, const intptr_t port) {
   FDUtils::SetCloseOnExec(fd);
   Socket::SetNonBlocking(fd);
 
-  static const size_t kTempBufSize = 1024;
-  char temp_buf[kTempBufSize];
-  struct hostent *unused;
-  int err;
-  if (gethostbyname_r(
-          host, &server, temp_buf, kTempBufSize, &unused, &err) != 0) {
-    TEMP_FAILURE_RETRY(close(fd));
-    Log::PrintErr("Error CreateConnect: %s\n", strerror(errno));
-    return -1;
-  }
-
-  server_address.sin_family = AF_INET;
-  server_address.sin_port = htons(port);
-  bcopy(server.h_addr, &server_address.sin_addr.s_addr, server.h_length);
-  memset(&server_address.sin_zero, 0, sizeof(server_address.sin_zero));
+  struct sockaddr_in* in = reinterpret_cast<struct sockaddr_in*>(host_data);
+  in->sin_port = htons(port);
   intptr_t result = TEMP_FAILURE_RETRY(
       connect(fd,
-              reinterpret_cast<struct sockaddr *>(&server_address),
-              sizeof(server_address)));
+              reinterpret_cast<struct sockaddr*>(host_data),
+              host_length));
   if (result == 0 || errno == EINPROGRESS) {
     return fd;
   }
+  TEMP_FAILURE_RETRY(close(fd));
   return -1;
 }
 
@@ -161,13 +151,14 @@ intptr_t Socket::GetStdioHandle(int num) {
 }
 
 
-const char* Socket::LookupIPv4Address(char* host, OSError** os_error) {
+SocketAddresses* Socket::LookupAddress(char* host, OSError** os_error) {
   // Perform a name lookup for an IPv4 address.
   struct addrinfo hints;
   memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_INET;
+  hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = IPPROTO_TCP;
+  hints.ai_flags = 0;
+  hints.ai_protocol = 0;
   struct addrinfo* info = NULL;
   int status = getaddrinfo(host, 0, &hints, &info);
   if (status != 0) {
@@ -177,34 +168,45 @@ const char* Socket::LookupIPv4Address(char* host, OSError** os_error) {
                             OSError::kGetAddressInfo);
     return NULL;
   }
-  // Convert the address into IPv4 dotted decimal notation.
-  char* buffer = reinterpret_cast<char*>(malloc(INET_ADDRSTRLEN));
-  sockaddr_in *sockaddr = reinterpret_cast<sockaddr_in *>(info->ai_addr);
-  const char* result = inet_ntop(AF_INET,
-                                 reinterpret_cast<void *>(&sockaddr->sin_addr),
-                                 buffer,
-                                 INET_ADDRSTRLEN);
-  if (result == NULL) {
-    free(buffer);
-    return NULL;
+  intptr_t count = 0;
+  for (struct addrinfo* c = info; c != NULL; c = c->ai_next) {
+    if (c->ai_family == AF_INET || c->ai_family == AF_INET6) count++;
   }
-  ASSERT(result == buffer);
-  return buffer;
+  SocketAddresses* addresses = new SocketAddresses(count);
+  intptr_t i = 0;
+  for (struct addrinfo* c = info; c != NULL; c = c->ai_next) {
+    if (c->ai_family == AF_INET || c->ai_family == AF_INET6) {

[Søren Gjesse, 2013/04/18 09:07:40]

How about moving all this into the SocketAddress constructor?

SocketAddress(struct addrinfo* addrinfo) {
  ...
}

[Anders Johnsen, 2013/04/18 12:09:45]

Done.

+      char* buffer = new char[INET6_ADDRSTRLEN];
+      sockaddr_in *sockaddr = reinterpret_cast<sockaddr_in *>(c->ai_addr);
+      const char* as_string = inet_ntop(c->ai_family,
+                                        &sockaddr->sin_addr,
+                                        buffer,
+                                        INET6_ADDRSTRLEN);
+      if (as_string == NULL) delete[] buffer;
+      uint8_t* data = new uint8_t[c->ai_addrlen];
+      memmove(data, reinterpret_cast<void *>(c->ai_addr), c->ai_addrlen);
+      SocketAddress::Type type = c->ai_family == AF_INET ?
+          SocketAddress::IPv4 :
+          SocketAddress::IPv6;
+      addresses->addresses[i] =
+          new SocketAddress(type, as_string, data, c->ai_addrlen);
+      i++;
+    }
+  }
+  freeaddrinfo(info);
+  return addresses;
 }
 
 
-intptr_t ServerSocket::CreateBindListen(const char* host,
+intptr_t ServerSocket::CreateBindListen(SocketAddress::Type type,
+                                        uint8_t* host_data,
+                                        intptr_t host_len,
                                         intptr_t port,
                                         intptr_t backlog) {
   intptr_t fd;
-  struct sockaddr_in server_address;
 
-  in_addr_t s_addr = inet_addr(host);
-  if (s_addr == INADDR_NONE) {
-    return -5;
-  }
-
-  fd = TEMP_FAILURE_RETRY(socket(AF_INET, SOCK_STREAM, 0));
+  fd = TEMP_FAILURE_RETRY(
+      socket(type == SocketAddress::IPv6 ? AF_INET6 : AF_INET, SOCK_STREAM, 0));
   if (fd < 0) return -1;
 
   FDUtils::SetCloseOnExec(fd);
@@ -213,15 +215,18 @@ intptr_t ServerSocket::CreateBindListen(const char* host,
   TEMP_FAILURE_RETRY(
       setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)));
 
-  server_address.sin_family = AF_INET;
-  server_address.sin_port = htons(port);
-  server_address.sin_addr.s_addr = s_addr;
-  memset(&server_address.sin_zero, 0, sizeof(server_address.sin_zero));
+  if (type == SocketAddress::IPv6) {
+    optval = 0;
+    TEMP_FAILURE_RETRY(
+        setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof(optval)));
+  }
 
+  struct sockaddr_in* in = reinterpret_cast<struct sockaddr_in*>(host_data);
+  in->sin_port = htons(port);
   if (TEMP_FAILURE_RETRY(
           bind(fd,
-               reinterpret_cast<struct sockaddr *>(&server_address),
-               sizeof(server_address))) < 0) {
+               reinterpret_cast<struct sockaddr*>(host_data),
+               host_len)) < 0) {
     TEMP_FAILURE_RETRY(close(fd));
     return -1;
   }