Add UDP support to dart:io

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/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;
 
+// TODO(sgjesse): Make this thread local.
+unsigned int rand_r_state = 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);
@@ skipping 68 matching lines @@
       Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_Handle err = DartUtils::NewDartOSError(&os_error);
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
 }
 
+void FUNCTION_NAME(Socket_CreateBindDatagram)(Dart_NativeArguments args) {
+  RawAddr addr;
+  GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
+  int64_t port = 0;
+  DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 2), &port);
+  intptr_t socket = Socket::CreateBindDatagram(&addr, port);
+  OSError error;
+  if (socket >= 0) {
+    Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
+    Dart_SetReturnValue(args, Dart_True());
+  } else {
+    OSError error;
+    Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
+  }
+}
+
 
 void FUNCTION_NAME(Socket_Available)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t available = Socket::Available(socket);
   if (available >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(available));
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
@@ skipping 45 matching lines @@
       Dart_SetReturnValue(args, err);
     }
   } else if (available == 0) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
+void FUNCTION_NAME(Socket_RecvFrom)(Dart_NativeArguments args) {
+  static bool drop_datagrams = Dart_IsVMFlagSet("drop_datagrams");
+  intptr_t socket =
+      Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
+
+  // TODO(sgjesse): This needs to be 64k as that is the max UDP packet size.
+  uint8_t buffer[4096];
+  RawAddr addr;
+  intptr_t bytes_read = Socket::RecvFrom(socket, buffer, 4096, &addr);
+  Dart_Handle err;
+  if (bytes_read > 0) {
+    uint8_t* data_buffer = NULL;
+    Dart_Handle data = IOBuffer::Allocate(bytes_read, &data_buffer);
+    if (Dart_IsError(data)) Dart_PropagateError(data);
+    ASSERT(data_buffer != NULL);
+    memmove(data_buffer, buffer, bytes_read);
+
+    // Get the port and clear it in the sockaddr structure.
+    int port = SocketAddress::GetAddrPort(&addr);
+    if (addr.addr.sa_family == AF_INET) {
+      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;
+    Dart_Handle dart_args[kNumArgs];
+    dart_args[0] = data;
+    dart_args[1] = Dart_NewInteger(addr.addr.sa_family == AF_INET
+                                   ? SocketAddress::TYPE_IPV4
+                                   : SocketAddress::TYPE_IPV6);
+    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);
+    if (Dart_IsError(dart_args[3])) Dart_PropagateError(dart_args[3]);
+    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);
+    if (drop_datagrams) {
+      int random = rand_r(&rand_r_state);
+      if (random > (RAND_MAX / 2)) {
+        Dart_SetReturnValue(args, result);
+      } else {
+        Dart_SetReturnValue(args, Dart_Null());
+      }
+    } else {
+      Dart_SetReturnValue(args, result);
+    }
+  } else if (bytes_read == 0) {
+    Dart_SetReturnValue(args, Dart_Null());
+  } else {
+    ASSERT(bytes_read == -1);
+    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
+  }
+}
+
+
 void FUNCTION_NAME(Socket_WriteList)(Dart_NativeArguments args) {
   static bool short_socket_writes = Dart_IsVMFlagSet("short_socket_write");
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   ASSERT(Dart_IsList(buffer_obj));
   intptr_t offset =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
   intptr_t length =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
@@ skipping 14 matching lines @@
     Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
   } else {
     // Extract OSError before we release data, as it may override the error.
     OSError os_error;
     Dart_TypedDataReleaseData(buffer_obj);
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
   }
 }
 
 
+void FUNCTION_NAME(Socket_SendTo)(Dart_NativeArguments args) {
+  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);
+  intptr_t port =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 5));
+  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);
+  if (Dart_IsError(result)) Dart_PropagateError(result);
+  ASSERT((offset + length) <= len);
+  buffer += offset;
+  intptr_t bytes_written = Socket::SendTo(socket, buffer, length, addr);
+  if (bytes_written >= 0) {
+    Dart_TypedDataReleaseData(buffer_obj);
+    Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
+  } else {
+    // Extract OSError before we release data, as it may override the error.
+    OSError os_error;
+    Dart_TypedDataReleaseData(buffer_obj);
+    Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
+  }
+}
+
+
 void FUNCTION_NAME(Socket_GetPort)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   OSError os_error;
   intptr_t port = Socket::GetPort(socket);
   if (port > 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(port));
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
@@ skipping 230 matching lines @@
     } else {
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
     return result;
   }
   return CObject::IllegalArgumentError();
 }
 
 
+void FUNCTION_NAME(Socket_GetOption)(Dart_NativeArguments args) {
+  intptr_t socket =
+      Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
+  int64_t option;
+  Dart_Handle err =
+      Dart_IntegerToInt64(Dart_GetNativeArgument(args, 1), &option);
+  if (Dart_IsError(err)) Dart_PropagateError(err);
+  bool ok;
+  switch (option) {
+    case 0: {  // TCP_NODELAY.
+      bool enabled;
+      ok = Socket::GetNoDelay(socket, &enabled);
+      if (ok) {
+        Dart_SetReturnValue(args, enabled ? Dart_True() : Dart_False());
+      }
+      break;
+    }
+    case 1: {  // IP_MULTICAST_LOOP.
+      bool enabled;
+      ok = Socket::GetMulticastLoop(socket, &enabled);
+      if (ok) {
+        Dart_SetReturnValue(args, enabled ? Dart_True() : Dart_False());
+      }
+      break;
+    }
+    case 2: {  // IP_MULTICAST_TTL.
+      int value;
+      ok = Socket::GetMulticastTTL(socket, &value);
+      if (ok) {
+        Dart_SetReturnValue(args, Dart_NewInteger(value));
+      }
+      break;
+    }
+    case 3: {  // IP_BROADCAST.
+      bool enabled;
+      ok = Socket::GetBroadcast(socket, &enabled);
+      if (ok) {
+        Dart_SetReturnValue(args, enabled ? Dart_True() : Dart_False());
+      }
+      break;
+    }
+    default:
+      UNREACHABLE();
+      break;
+  }
+  // In case of failure the return value is not set above.
+  if (!ok) {
+    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
+  }
+}
+
+
 void FUNCTION_NAME(Socket_SetOption)(Dart_NativeArguments args) {
   bool result = false;
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
-  Dart_Handle option_obj = Dart_GetNativeArgument(args, 1);
   int64_t option;
-  Dart_Handle err = Dart_IntegerToInt64(option_obj, &option);
-  if (Dart_IsError(err)) Dart_PropagateError(err);
-  Dart_Handle enabled_obj = Dart_GetNativeArgument(args, 2);
-  bool enabled;
-  err = Dart_BooleanValue(enabled_obj, &enabled);
+  Dart_Handle err =
+      Dart_IntegerToInt64(Dart_GetNativeArgument(args, 1), &option);
   if (Dart_IsError(err)) Dart_PropagateError(err);
   switch (option) {
     case 0:  // TCP_NODELAY.
-      result = Socket::SetNoDelay(socket, enabled);
+      result = Socket::SetNoDelay(
+          socket, DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 2)));
+      break;
+    case 1:  // IP_MULTICAST_LOOP.
+      result = Socket::SetMulticastLoop(
+          socket, DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 2)));
+      break;
+    case 2:  // IP_MULTICAST_TTL.
+      result = Socket::SetMulticastTTL(
+          socket, DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 2)));
+      break;
+    case 3:  // IP_BROADCAST.
+      result = Socket::SetBroadcast(
+          socket, DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 2)));
       break;
     default:
+      UNREACHABLE();
       break;
   }
-  Dart_SetReturnValue(args, Dart_NewBoolean(result));
+  if (result) {
+    Dart_SetReturnValue(args, Dart_Null());
+  } 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);
+  if (Socket::JoinMulticast(socket, &addr, 0)) {
+    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);
+  if (Socket::LeaveMulticast(socket, &addr, 0)) {
+    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