[NaCl SDK] nacl_io: Add support for non-blocking connect/accept

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>
@@ skipping 1009 matching lines @@
 
 
 // Socket Functions
 int KernelProxy::accept(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;
-
-  PP_Resource new_sock = 0;
-  Error err = handle->socket_node()->Accept(&new_sock, addr, len);
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  PP_Resource new_sock = 0;
+  error = handle->Accept(&new_sock, addr, len);
+  if (error != 0) {
+    errno = error;
+    return -1;
+  }
+
   MountNodeSocket* sock = new MountNodeTCP(stream_mount_.get(), new_sock);
 
   // The MountNodeSocket now holds a reference to the new socket
   // so we release ours.
   ppapi_->ReleaseResource(new_sock);
-  err = sock->Init(S_IREAD | S_IWRITE);
-  if (err != 0) {
-    errno = err;
+  error = sock->Init(S_IREAD | S_IWRITE);
+  if (error != 0) {
+    errno = error;
     return -1;
   }
 
   ScopedMountNode node(sock);
   ScopedKernelHandle new_handle(new KernelHandle(stream_mount_, node));
   return AllocateFD(new_handle);
 }
 
 int KernelProxy::bind(int fd, const struct sockaddr* addr, socklen_t len) {
   if (NULL == addr) {
@@ skipping 14 matching lines @@
   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;
-
-  Error err = handle->socket_node()->Connect(addr, len);
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  error = handle->Connect(addr, len);
+  if (error != 0) {
+    errno = error;
+    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;
@@ skipping 72 matching lines @@
 ssize_t KernelProxy::recv(int fd,
                           void* buf,
                           size_t len,
                           int flags) {
   if (NULL == buf) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
-  if (AcquireSocketHandle(fd, &handle) == -1)
-    return -1;
-
-  int out_len = 0;
-  Error err = handle->socket_node()->Recv(handle->Data(), buf, len, flags,
-                                          &out_len);
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  int out_len = 0;
+  error = handle->Recv(buf, len, flags, &out_len);
+  if (error != 0) {
+    errno = error;
+    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;
-
-  int out_len = 0;
-  Error err = handle->socket_node()->RecvFrom(handle->Data(),
-                                              buf,
-                                              len,
-                                              flags,
-                                              addr,
-                                              addrlen,
-                                              &out_len);
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  int out_len = 0;
+  error = handle->RecvFrom(buf, len, flags, addr, addrlen, &out_len);
+  if (error != 0) {
+    errno = error;
+    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;
-
-  int out_len = 0;
-  Error err = handle->socket_node()->Send(handle->Data(), buf, len, flags,
-                                          &out_len);
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  int out_len = 0;
+  error = handle->Send(buf, len, flags, &out_len);
+  if (error != 0) {
+    errno = error;
+    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;
-
-  int out_len = 0;
-  Error err = handle->socket_node()->SendTo(handle->Data(), buf, len, flags,
-                                            addr, addrlen, &out_len);
-
-  if (err != 0) {
-    errno = err;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
     return -1;
   }
 
+  int out_len = 0;
+  error = handle->SendTo(buf, len, flags, addr, addrlen, &out_len);
+  if (error != 0) {
+    errno = error;
+    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;
@@ skipping 108 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io