[NaCl SDK] Add UDP and TCP Sockets

native_client_sdk/src/libraries/nacl_io/kernel_proxy.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "nacl_io/kernel_proxy.h"
 
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
 
 #include <iterator>
 #include <string>
 
 #include "nacl_io/host_resolver.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/mount.h"
 #include "nacl_io/mount_dev.h"
 #include "nacl_io/mount_html5fs.h"
 #include "nacl_io/mount_http.h"
 #include "nacl_io/mount_mem.h"
 #include "nacl_io/mount_node.h"
+#include "nacl_io/mount_node_tcp.h"
+#include "nacl_io/mount_node_udp.h"
 #include "nacl_io/mount_passthrough.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/typed_mount_factory.h"
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 
@@ skipping 35 matching lines @@
   assert(result == 0);
 
   // Open the first three in order to get STDIN, STDOUT, STDERR
   open("/dev/stdin", O_RDONLY);
   open("/dev/stdout", O_WRONLY);
   open("/dev/stderr", O_WRONLY);
 
 #ifdef PROVIDES_SOCKET_API
   host_resolver_.Init(ppapi_);
 #endif
+
+  StringMap_t args;
+  socket_mount_.reset(new MountSocket());
+  socket_mount_->Init(0, args, ppapi);
 }
 
 int KernelProxy::open_resource(const char* path) {
   ScopedMount mnt;
   Path rel;
 
   Error error = AcquireMountAndRelPath(path, &mnt, &rel);
   if (error) {
     errno = error;
     return -1;
@@ skipping 805 matching lines @@
 int KernelProxy::bind(int fd, const struct sockaddr* addr, socklen_t len) {
   if (NULL == addr) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  Error err = handle->socket_node()->Bind(addr, len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return 0;
 }
 
 int KernelProxy::connect(int fd, const struct sockaddr* addr, socklen_t len) {
   if (NULL == addr) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EACCES;
-  return -1;
+  Error err = handle->socket_node()->Connect(addr, len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return 0;
 }
 
 struct hostent* KernelProxy::gethostbyname(const char* name) {
   return host_resolver_.gethostbyname(name);
 }
 
 int KernelProxy::getpeername(int fd, struct sockaddr* addr, socklen_t* len) {
   if (NULL == addr || NULL == len) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  Error err = handle->socket_node()->GetPeerName(addr, len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return 0;
 }
 
 int KernelProxy::getsockname(int fd, struct sockaddr* addr, socklen_t* len) {
   if (NULL == addr || NULL == len) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  Error err = handle->socket_node()->GetSockName(addr, len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return 0;
 }
 
 int KernelProxy::getsockopt(int fd,
                          int lvl,
                          int optname,
                          void* optval,
                          socklen_t* len) {
   if (NULL == optval || NULL == len) {
     errno = EFAULT;
     return -1;
@@ skipping 30 matching lines @@
                           int flags) {
   if (NULL == buf) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  int out_len = 0;
+  Error err = handle->socket_node()->Recv(buf, len, flags, &out_len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return static_cast<ssize_t>(out_len);
 }
 
 ssize_t KernelProxy::recvfrom(int fd,
                               void* buf,
                               size_t len,
                               int flags,
                               struct sockaddr* addr,
                               socklen_t* addrlen) {
   // According to the manpage, recvfrom with a null addr is identical to recv.
   if (NULL == addr) {
     return recv(fd, buf, len, flags);
   }
 
   if (NULL == buf || NULL == addrlen) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  int out_len = 0;
+  Error err = handle->socket_node()->RecvFrom(buf,
+                                              len,
+                                              flags,
+                                              addr,
+                                              addrlen,
+                                              &out_len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return static_cast<ssize_t>(out_len);
 }
 
 ssize_t KernelProxy::recvmsg(int fd, struct msghdr* msg, int flags) {
   if (NULL == msg ) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
   errno = EOPNOTSUPP;
   return -1;
 }
 
 ssize_t KernelProxy::send(int fd, const void* buf, size_t len, int flags) {
   if (NULL == buf) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  int out_len = 0;
+  Error err = handle->socket_node()->Send(buf, len, flags, &out_len);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return static_cast<ssize_t>(out_len);
 }
 
 ssize_t KernelProxy::sendto(int fd,
                             const void* buf,
                             size_t len,
                             int flags,
                             const struct sockaddr* addr,
                             socklen_t addrlen) {
   // According to the manpage, sendto with a null addr is identical to send.
   if (NULL == addr) {
     return send(fd, buf, len, flags);
   }
 
   if (NULL == buf) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  int out_len = 0;
+  Error err =
+      handle->socket_node()->SendTo(buf, len, flags, addr, addrlen, &out_len);
+
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return static_cast<ssize_t>(out_len);
 }
 
 ssize_t KernelProxy::sendmsg(int fd, const struct msghdr* msg, int flags) {
   if (NULL == msg) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
@@ skipping 19 matching lines @@
 
   errno = EINVAL;
   return -1;
 }
 
 int KernelProxy::shutdown(int fd, int how) {
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
-  errno = EINVAL;
-  return -1;
+  Error err = handle->socket_node()->Shutdown(how);
+  if (err != 0) {
+    errno = err;
+    return -1;
+  }
+
+  return 0;
 }
 
 int KernelProxy::socket(int domain, int type, int protocol) {
   if (AF_INET != domain && AF_INET6 != domain) {
     errno = EAFNOSUPPORT;
     return -1;
   }
 
-  if (SOCK_STREAM != type && SOCK_DGRAM != type) {
-    errno = EPROTONOSUPPORT;
-    return -1;
+  MountNodeSocket* sock = NULL;
+  switch (type) {
+    case SOCK_DGRAM:
+      sock = new MountNodeUDP(socket_mount_.get());
+      break;
+
+    case SOCK_STREAM:
+      sock = new MountNodeTCP(socket_mount_.get());
+      break;
+
+    default:
+      errno = EPROTONOSUPPORT;
+      return -1;
   }
 
-  errno = EACCES;
-  return -1;
+  ScopedMountNode node(sock);
+  if (sock->Init(S_IREAD | S_IWRITE) == 0) {
+    ScopedKernelHandle handle(new KernelHandle(socket_mount_, node));
+    return AllocateFD(handle);
+  }
+
+  // If we failed to init, assume we don't have access.
+  return EACCES;
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int* sv) {
   if (NULL == sv) {
     errno = EFAULT;
     return -1;
   }
 
   // Catch-22: We don't support AF_UNIX, but any other AF doesn't support
   // socket pairs. Thus, this function always fails.
@@ skipping 24 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io