[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 802 matching lines @@
   return -1;
 }
 
 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)

[binji, 2013/08/09 19:28:06]

no errno set if the handle cannot be acquired?

(here and the rest of the file)

[noelallen1, 2013/08/09 22:53:22]

Set by acquire socket handle.   The convention is KernelProxy functions always
return -1 + errno.

     return -1;
 
-  errno = EINVAL;
-  return -1;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());

[binji, 2013/08/09 19:28:06]

Why reinterpret_cast? If this is a downcast you can just use static_cast. Though
this is ugly enough I'd rather see it as a function on KernelHandle, i.e.

handle->socket_node()

or something.

[noelallen1, 2013/08/09 22:53:22]

Done.

+
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  Error err = sock->GetPeerName(addr, len);

[binji, 2013/08/09 19:28:06]

GetSockName?

[noelallen1, 2013/08/09 22:53:22]

Done.

+  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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  int out_len = 0;
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  int out_len = 0;
+  Error err = sock->RecvFrom(buf, len, flags, addr, addrlen, &out_len);

[binji, 2013/08/09 19:28:06]

why not make the RecvFrom out parameter ssize_t here (to avoid the ssize_t cast
below)?

[noelallen1, 2013/08/09 22:53:22]

it should match Read.  
Read(x, y, z) = Recv(x, y, z, 0) = RecvFrom(x, y, z, 0, NULL, NULL);

[binji, 2013/08/09 23:08:27]

OK

+  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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  int out_len = 0;
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  int out_len = 0;
+  Error err = sock->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;
+  MountNodeSocket* sock =
+      reinterpret_cast<MountNodeSocket*>(handle->node().get());
+
+  Error err = sock->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;
+  if (SOCK_DGRAM == type) {
+    MountNodeSocket* sock = new MountNodeUDP(socket_mount_.get());
+    ScopedMountNode node(sock);
+
+    if (sock->Init(S_IREAD | S_IWRITE) == 0) {
+      ScopedKernelHandle handle(new KernelHandle(socket_mount_, node));
+      return AllocateFD(handle);
+    }
+
+    errno = EACCES;
     return -1;
   }
 
-  errno = EACCES;
+  if (SOCK_STREAM == type) {
+    MountNodeSocket* sock = new MountNodeTCP(socket_mount_.get());
+    ScopedMountNode node(sock);
+
+    if (sock->Init(S_IREAD | S_IWRITE) == 0) {

[binji, 2013/08/09 19:28:06]

Init part here and above is identical, can you combine?

[noelallen1, 2013/08/09 22:53:22]

Done.

+      ScopedKernelHandle handle(new KernelHandle(socket_mount_, node));
+      return AllocateFD(handle);
+    }
+  }

[binji, 2013/08/09 19:28:06]

EACCES here too if sock->Init fails?

[noelallen1, 2013/08/09 22:53:22]

Done.

+
+  errno = EPROTONOSUPPORT;
   return -1;
 }
 
 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
@@ skipping 25 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io