Add NetworkAdaptor 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"
 
@@ skipping 56 matching lines @@
     case SocketAddress::ADDRESS_ANY_IP_V6: {
       raw.in6.sin6_family = AF_INET6;
       raw.in6.sin6_addr = in6addr_loopback;
       break;
     }
     default:
       Dart_Handle error = DartUtils::NewDartArgumentError("");
       if (Dart_IsError(error)) Dart_PropagateError(error);
       Dart_ThrowException(error);
   }
-  int len = SocketAddress::GetAddrLength(raw);
+  int len = SocketAddress::GetAddrLength(&raw);
   Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, len);
   if (Dart_IsError(result)) Dart_PropagateError(result);
   Dart_ListSetAsBytes(result, 0, reinterpret_cast<uint8_t *>(&raw), len);
   Dart_SetReturnValue(args, result);
   Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(Socket_CreateConnect)(Dart_NativeArguments args) {
   Dart_EnterScope();
@@ skipping 351 matching lines @@
 
 
 static CObject* LookupRequest(const CObjectArray& request) {
   if (request.Length() == 3 &&
       request[1]->IsString() &&
       request[2]->IsInt32()) {
     CObjectString host(request[1]);
     CObjectInt32 type(request[2]);
     CObject* result = NULL;
     OSError* os_error = NULL;
-    SocketAddresses* addresses =
+    AddressList<SocketAddress>* addresses =
         Socket::LookupAddress(host.CString(), type.Value(), &os_error);
     if (addresses != NULL) {
       CObjectArray* array = new CObjectArray(
           CObject::NewArray(addresses->count() + 1));
       array->SetAt(0, new CObjectInt32(CObject::NewInt32(0)));
       for (intptr_t i = 0; i < addresses->count(); i++) {
         SocketAddress* addr = addresses->GetAt(i);
         CObjectArray* entry = new CObjectArray(CObject::NewArray(3));
 
         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)));
+            SocketAddress::GetAddrLength(&raw)));
         memmove(data->Buffer(),
                 reinterpret_cast<void *>(&raw),
-                SocketAddress::GetAddrLength(raw));
+                SocketAddress::GetAddrLength(&raw));
 
         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();
 }
 
 
+static CObject* ListInterfacesRequest(const CObjectArray& request) {
+  if (request.Length() == 2 &&
+      request[1]->IsInt32()) {
+    CObjectInt32 type(request[1]);
+    CObject* result = NULL;
+    OSError* os_error = NULL;
+    AddressList<InterfaceSocketAddress>* addresses = Socket::ListInterfaces(
+        type.Value(), &os_error);
+    if (addresses != NULL) {
+      CObjectArray* array = new CObjectArray(
+          CObject::NewArray(addresses->count() + 1));
+      array->SetAt(0, new CObjectInt32(CObject::NewInt32(0)));
+      for (intptr_t i = 0; i < addresses->count(); i++) {
+        InterfaceSocketAddress* interface = addresses->GetAt(i);
+        SocketAddress* addr = interface->socket_address();
+        CObjectArray* entry = new CObjectArray(CObject::NewArray(4));
+
+        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));
+        entry->SetAt(2, data);
+
+        CObjectString* interface_name = new CObjectString(CObject::NewString(
+            interface->interface_name()));
+        entry->SetAt(3, interface_name);
+
+        array->SetAt(i + 1, entry);
+      }
+      result = array;
+      delete addresses;
+    } else {
+      result = CObject::NewOSError(os_error);
+      delete os_error;
+    }
+    return result;
+  }
+  return CObject::IllegalArgumentError();
+}
+
+
 void SocketService(Dart_Port dest_port_id,
                    Dart_Port reply_port_id,
                    Dart_CObject* message) {
   CObject* response = CObject::IllegalArgumentError();
   CObjectArray request(message);
   if (message->type == Dart_CObject_kArray) {
     if (request.Length() > 1 && request[0]->IsInt32()) {
       CObjectInt32 request_type(request[0]);
       switch (request_type.Value()) {
         case Socket::kLookupRequest:
           response = LookupRequest(request);
           break;
+        case Socket::kListInterfacesRequest:
+          response = ListInterfacesRequest(request);
+          break;
         default:
           UNREACHABLE();
       }
     }
   }
 
   Dart_PostCObject(reply_port_id, response->AsApiCObject());
 }
 
 
@@ skipping 66 matching lines @@
   return Dart_SetNativeInstanceField(socket, kSocketIdNativeField, id);
 }
 
 
 Dart_Handle Socket::GetSocketIdNativeField(Dart_Handle socket, intptr_t* id) {
   return Dart_GetNativeInstanceField(socket, kSocketIdNativeField, id);
 }
 
 }  // namespace bin
 }  // namespace dart