Add support for building the Dart VM for Android OS.

runtime/bin/socket_android.cc

 // Copyright (c) 2012, 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 <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "bin/fdutils.h"
 #include "bin/socket.h"
 
 
 bool Socket::Initialize() {
-  // Nothing to do on Linux.
+  // Nothing to do on Android.
   return true;
 }
 
 
 intptr_t Socket::CreateConnect(const char* host, 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));
@@ skipping 88 matching lines @@
                 host,
                 INET_ADDRSTRLEN) == NULL) {
     fprintf(stderr, "Error inet_ntop: %s\n", strerror(errno));
     return false;
   }
   *port = ntohs(socket_address.sin_port);
   return true;
 }
 
 
 void Socket::GetError(intptr_t fd, OSError* os_error) {

[cshapiro, 2012/08/07 22:39:40]

I am wondering how this should behave if there is a permissions error.  For
example, the client binary might not be able to make an outgoing connection. 
Maybe the error code is conflated with another expected error and this is a
non-issue.

[jackpal, 2012/08/08 00:26:19]

In my experience Android apps without the android.permission.INTERNET permission
return an EACESS error.

I think that's good enough.

-  int len = sizeof(errno);
+  int errorNumber;
+  int len = sizeof(errorNumber);
   getsockopt(fd,
              SOL_SOCKET,
              SO_ERROR,
-             &errno,
+             reinterpret_cast<void*>(&errorNumber),
              reinterpret_cast<socklen_t*>(&len));
-  os_error->SetCodeAndMessage(OSError::kSystem, errno);
+  os_error->SetCodeAndMessage(OSError::kSystem, errorNumber);
 }
 
 
 intptr_t Socket::GetStdioHandle(int num) {
   return static_cast<intptr_t>(num);
 }
 
 
 const char* Socket::LookupIPv4Address(char* host, OSError** os_error) {
   // Perform a name lookup for an IPv4 address.
@@ skipping 61 matching lines @@
     fprintf(stderr, "Error Listen: %s\n", strerror(errno));
     return -1;
   }
 
   FDUtils::SetNonBlocking(fd);
   return fd;
 }
 
 
 static bool IsTemporaryAcceptError(int error) {
-  // On Linux a number of protocol errors should be treated as EAGAIN.
+  // On Android a number of protocol errors should be treated as EAGAIN.
   // These are the ones for TCP/IP.
   return (error == EAGAIN) || (error == ENETDOWN) || (error == EPROTO) ||
       (error == ENOPROTOOPT) || (error == EHOSTDOWN) || (error == ENONET) ||
       (error == EHOSTUNREACH) || (error == EOPNOTSUPP) ||
       (error == ENETUNREACH);
 }
 
 
 intptr_t ServerSocket::Accept(intptr_t fd) {
   intptr_t socket;
   struct sockaddr clientaddr;
   socklen_t addrlen = sizeof(clientaddr);
   socket = TEMP_FAILURE_RETRY(accept(fd, &clientaddr, &addrlen));
   if (socket == -1) {
     if (IsTemporaryAcceptError(errno)) {
       // We need to signal to the caller that this is actually not an
       // error. We got woken up from the poll on the listening socket,
       // but there is no connection ready to be accepted.
       ASSERT(kTemporaryFailure != -1);
       socket = kTemporaryFailure;
     }
   } else {
     FDUtils::SetNonBlocking(socket);
   }
   return socket;
 }