Only store the address bytes for an internet address in Dart

runtime/bin/socket.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/io_buffer.h"
 #include "bin/isolate_data.h"
 #include "bin/socket.h"
 #include "bin/dartutils.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/thread.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 namespace dart {
 namespace bin {
 
 static const int kSocketIdNativeField = 0;
 
 dart::Mutex* Socket::mutex_ = new dart::Mutex();
 int Socket::service_ports_size_ = 0;
 Dart_Port* Socket::service_ports_ = NULL;
 int Socket::service_ports_index_ = 0;
 
 
-static void GetSockAddr(Dart_Handle obj, RawAddr* addr) {
-  Dart_TypedData_Type data_type;
-  uint8_t* data = NULL;
-  intptr_t len;
-  Dart_Handle result = Dart_TypedDataAcquireData(
-      obj, &data_type, reinterpret_cast<void**>(&data), &len);
-  if (Dart_IsError(result)) Dart_PropagateError(result);
-  if (data_type != Dart_TypedData_kUint8) {
-    Dart_PropagateError(Dart_NewApiError("Unexpected type for socket address"));
-  }
-  memmove(reinterpret_cast<void *>(addr), data, len);
-  Dart_TypedDataReleaseData(obj);
-}
-
-
-void FUNCTION_NAME(InternetAddress_Fixed)(Dart_NativeArguments args) {
-  int64_t id = 0;
-  bool ok = DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 0), &id);
-  ASSERT(ok);
-  USE(ok);
-  RawAddr raw;
-  memset(&raw, 0, sizeof(raw));
-  switch (id) {
-    case SocketAddress::ADDRESS_LOOPBACK_IP_V4: {
-      raw.in.sin_family = AF_INET;
-      raw.in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-      break;
-    }
-    case SocketAddress::ADDRESS_LOOPBACK_IP_V6: {
-      raw.in6.sin6_family = AF_INET6;
-      raw.in6.sin6_addr = in6addr_loopback;
-      break;
-    }
-    case SocketAddress::ADDRESS_ANY_IP_V4: {
-      raw.in.sin_family = AF_INET;
-      raw.in.sin_addr.s_addr = INADDR_ANY;
-      break;
-    }
-    case SocketAddress::ADDRESS_ANY_IP_V6: {
-      raw.in6.sin6_family = AF_INET6;
-      raw.in6.sin6_addr = in6addr_any;
-      break;
-    }
-    default:
-      Dart_Handle error = DartUtils::NewDartArgumentError("");
-      if (Dart_IsError(error)) Dart_PropagateError(error);
-      Dart_ThrowException(error);
-  }
-  Dart_SetReturnValue(args, SocketAddress::ToTypedData(&raw));
-}
-
-
 void FUNCTION_NAME(InternetAddress_Parse)(Dart_NativeArguments args) {
-  int64_t type = 0;
-  bool ok = DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 0), &type);
-  ASSERT(ok);
-  USE(ok);
   const char* address =
-      DartUtils::GetStringValue(Dart_GetNativeArgument(args, 1));
+      DartUtils::GetStringValue(Dart_GetNativeArgument(args, 0));
   ASSERT(address != NULL);
   RawAddr raw;
   memset(&raw, 0, sizeof(raw));
+  int type = strchr(address, ':') == NULL ? SocketAddress::TYPE_IPV4
+                                          : SocketAddress::TYPE_IPV6;
   if (type == SocketAddress::TYPE_IPV4) {
     raw.addr.sa_family = AF_INET;
   } else {
-    ASSERT(type == SocketAddress::TYPE_IPV6);
     raw.addr.sa_family = AF_INET6;
   }
-  ok = Socket::ParseAddress(type, address, &raw);
+  bool ok = Socket::ParseAddress(type, address, &raw);
   if (!ok) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, SocketAddress::ToTypedData(&raw));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateConnect)(Dart_NativeArguments args) {
   RawAddr addr;
-  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   intptr_t socket = Socket::CreateConnect(addr, port);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateBindDatagram)(Dart_NativeArguments args) {
   RawAddr addr;
-  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   bool reuse_addr = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 3));
   intptr_t socket = Socket::CreateBindDatagram(&addr, port, reuse_addr);
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     OSError error;
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
@@ skipping 103 matching lines @@
     addr.in.sin_port = 0;
   } else {
     ASSERT(addr.addr.sa_family == AF_INET6);
     addr.in6.sin6_port = 0;
   }
   // Format the address to a string using the numeric format.
   char numeric_address[INET6_ADDRSTRLEN];
   Socket::FormatNumericAddress(&addr, numeric_address, INET6_ADDRSTRLEN);
 
   // Create a Datagram object with the data and sender address and port.
-  const int kNumArgs = 5;
+  const int kNumArgs = 4;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = data;
-  dart_args[1] = Dart_NewBoolean(addr.addr.sa_family == AF_INET6);
-  dart_args[2] = Dart_NewStringFromCString(numeric_address);
-  if (Dart_IsError(dart_args[2])) Dart_PropagateError(dart_args[2]);
-  int len = SocketAddress::GetAddrLength(&addr);
-  dart_args[3] = Dart_NewTypedData(Dart_TypedData_kUint8, len);
+  dart_args[1] = Dart_NewStringFromCString(numeric_address);
+  if (Dart_IsError(dart_args[1])) Dart_PropagateError(dart_args[1]);
+  dart_args[2] = SocketAddress::ToTypedData(&addr);
+  dart_args[3] = Dart_NewInteger(port);
   if (Dart_IsError(dart_args[3])) Dart_PropagateError(dart_args[3]);
-  Dart_Handle err = Dart_ListSetAsBytes(
-      dart_args[3], 0, reinterpret_cast<uint8_t *>(&addr), len);
-  if (Dart_IsError(err)) Dart_PropagateError(err);
-  dart_args[4] = Dart_NewInteger(port);
-  if (Dart_IsError(dart_args[4])) Dart_PropagateError(dart_args[4]);
   // TODO(sgjesse): Cache the _makeDatagram function somewhere.
   Dart_Handle io_lib =
       Dart_LookupLibrary(DartUtils::NewString("dart:io"));
   if (Dart_IsError(io_lib)) Dart_PropagateError(io_lib);
   Dart_Handle result =
       Dart_Invoke(io_lib,
                   DartUtils::NewString("_makeDatagram"),
                   kNumArgs,
                   dart_args);
   if (Dart_IsError(result)) Dart_PropagateError(result);
@@ skipping 39 matching lines @@
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   intptr_t offset =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
   intptr_t length =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   Dart_Handle address_obj = Dart_GetNativeArgument(args, 4);
   ASSERT(Dart_IsList(address_obj));
   RawAddr addr;
-  GetSockAddr(address_obj, &addr);
+  SocketAddress::GetSockAddr(address_obj, &addr);
   int64_t port = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 5),
       0,
       65535);
   SocketAddress::SetAddrPort(&addr, port);
   Dart_TypedData_Type type;
   uint8_t* buffer = NULL;
   intptr_t len;
   Dart_Handle result = Dart_TypedDataAcquireData(
       buffer_obj, &type, reinterpret_cast<void**>(&buffer), &len);
@@ skipping 88 matching lines @@
 
 void FUNCTION_NAME(Socket_SetSocketId)(Dart_NativeArguments args) {
   intptr_t id =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), id);
 }
 
 
 void FUNCTION_NAME(ServerSocket_CreateBindListen)(Dart_NativeArguments args) {
   RawAddr addr;
-  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   int64_t port = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 2),
       0,
       65535);
   int64_t backlog = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 3),
       0,
       65535);
   bool v6_only = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 4));
   intptr_t socket = ServerSocket::CreateBindListen(
@@ skipping 48 matching lines @@
 
         CObjectInt32* type = new CObjectInt32(
             CObject::NewInt32(addr->GetType()));
         entry->SetAt(0, type);
 
         CObjectString* as_string = new CObjectString(CObject::NewString(
             addr->as_string()));
         entry->SetAt(1, as_string);
 
         RawAddr raw = addr->addr();
-        CObjectUint8Array* data = new CObjectUint8Array(CObject::NewUint8Array(
-            SocketAddress::GetAddrLength(&raw)));
-        memmove(data->Buffer(),
-                reinterpret_cast<void *>(&raw),
-                SocketAddress::GetAddrLength(&raw));
+        CObjectUint8Array* data = SocketAddress::ToCObject(&raw);
+        entry->SetAt(2, data);
 
-        entry->SetAt(2, data);
         array->SetAt(i + 1, entry);
       }
       result = array;
       delete addresses;
     } else {
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
     return result;
   }
   return CObject::IllegalArgumentError();
 }
 
 
 CObject* Socket::ReverseLookupRequest(const CObjectArray& request) {
   if (request.Length() == 1 &&
       request[0]->IsTypedData()) {
     CObjectUint8Array addr_object(request[0]);
     RawAddr addr;
-    memmove(reinterpret_cast<void *>(&addr),
-            addr_object.Buffer(),
-            addr_object.Length());
+    int len = addr_object.Length();
+    memset(reinterpret_cast<void*>(&addr), 0, sizeof(RawAddr));
+    if (len == sizeof(in_addr)) {
+      addr.in.sin_family = AF_INET;
+      memmove(reinterpret_cast<void*>(&addr.in.sin_addr),
+              addr_object.Buffer(),
+              len);
+    } else {
+      ASSERT(len == sizeof(in6_addr));
+      addr.in6.sin6_family = AF_INET6;
+      memmove(reinterpret_cast<void*>(&addr.in6.sin6_addr),
+              addr_object.Buffer(),
+              len);
+    }
+
     OSError* os_error = NULL;
     const intptr_t kMaxHostLength = 1025;
     char host[kMaxHostLength];
     if (Socket::ReverseLookup(addr, host, kMaxHostLength, &os_error)) {
       return new CObjectString(CObject::NewString(host));
     } else {
       CObject* result = CObject::NewOSError(os_error);
       delete os_error;
       return result;
     }
@@ skipping 21 matching lines @@
 
         CObjectInt32* type = new CObjectInt32(
             CObject::NewInt32(addr->GetType()));
         entry->SetAt(0, type);
 
         CObjectString* as_string = new CObjectString(CObject::NewString(
             addr->as_string()));
         entry->SetAt(1, as_string);
 
         RawAddr raw = addr->addr();
-        CObjectUint8Array* data = new CObjectUint8Array(CObject::NewUint8Array(
-            SocketAddress::GetAddrLength(&raw)));
-        memmove(data->Buffer(),
-                reinterpret_cast<void *>(&raw),
-                SocketAddress::GetAddrLength(&raw));
+        CObjectUint8Array* data = SocketAddress::ToCObject(&raw);
         entry->SetAt(2, data);
 
         CObjectString* interface_name = new CObjectString(CObject::NewString(
             interface->interface_name()));
         entry->SetAt(3, interface_name);
 
         CObjectInt64* interface_index = new CObjectInt64(CObject::NewInt64(
             interface->interface_index()));
         entry->SetAt(4, interface_index);
 
@@ skipping 110 matching lines @@
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void FUNCTION_NAME(Socket_JoinMulticast)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   RawAddr addr;
-  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   RawAddr interface;
   if (Dart_GetNativeArgument(args, 2) != Dart_Null()) {
-    GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
+    SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
   }
   int interfaceIndex =
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
   if (Socket::JoinMulticast(socket, &addr, &interface, interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void FUNCTION_NAME(Socket_LeaveMulticast)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   RawAddr addr;
-  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   RawAddr interface;
   if (Dart_GetNativeArgument(args, 2) != Dart_Null()) {
-    GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
+    SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
   }
   int interfaceIndex =
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
   if (Socket::LeaveMulticast(socket, &addr, &interface, interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void Socket::SetSocketIdNativeField(Dart_Handle socket, intptr_t id) {
   Dart_Handle err =
       Dart_SetNativeInstanceField(socket, kSocketIdNativeField, id);
   if (Dart_IsError(err)) Dart_PropagateError(err);
 }
 
 
 intptr_t Socket::GetSocketIdNativeField(Dart_Handle socket_obj) {
   intptr_t socket = 0;
   Dart_Handle err =
       Dart_GetNativeInstanceField(socket_obj, kSocketIdNativeField, &socket);
   if (Dart_IsError(err)) Dart_PropagateError(err);
   return socket;
 }
 
 }  // namespace bin
 }  // namespace dart