Socket subsystem implementation

libraries/nacl-mounts/base/KernelProxy.cc

 /*
  * Copyright (c) 2012 The Native Client 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 <assert.h>
+#include <sys/time.h>
 #include <list>
 #include <utility>
-#include "../console/ConsoleMount.h"
+#include "console/ConsoleMount.h"

[Evgeniy Stepanov, 2012/05/23 15:35:13]

Why this one without ../, and the two below it with ../ ?

[vissi, 2012/05/25 11:08:50]

Now without ..

 #include "../dev/DevMount.h"
+#include "../net/SocketSubSystem.h"
 #include "KernelProxy.h"
 #include "MountManager.h"
+#include "net/BaseSocketSubSystem.h"
+#include <netinet/in.h>
+#include "util/DebugPrint.h"
 
 static pthread_once_t kp_once_ = PTHREAD_ONCE_INIT;
 KernelProxy *KernelProxy::kp_instance_;
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 256
 #endif
 
 KernelProxy::KernelProxy() {
   if (pthread_mutex_init(&kp_lock_, NULL)) assert(0);
@@ skipping 12 matching lines @@
   ret = mm_.AddMount(console_mount, "/dev/fd");
   assert(ret == 0);
   int fd = open("/dev/fd/0", O_CREAT | O_RDWR, 0);
   assert(fd == 0);
   fd = open("/dev/fd/1", O_CREAT | O_RDWR, 0);
   assert(fd == 1);
   fd = open("/dev/fd/2", O_CREAT | O_RDWR, 0);
   assert(fd == 2);
 }
 
+void KernelProxy::SetSS(BaseSocketSubSystem* bss) {

[Evgeniy Stepanov, 2012/05/23 15:35:13]

A more descriptive setter name pls.

[vissi, 2012/05/25 11:08:50]

Done.

+  ss = bss;
+}
+
+void KernelProxy::RemoveFileStream(int fd) {
+  this->close(fd);
+}
+
+int KernelProxy::AddFileStream(FileStream* stream) {
+  SimpleAutoLock lock(&kp_lock_);
+
+  // Setup file handle.
+  int handle_slot = open_files_.Alloc();
+  int fd = fds_.Alloc();
+  FileDescriptor* file = fds_.At(fd);
+  file->handle = handle_slot;
+  FileHandle* handle = open_files_.At(handle_slot);
+
+  // init should be safe because we have the kernel proxy lock
+  if (pthread_mutex_init(&handle->lock, NULL)) assert(0);
+
+  handle->mount = (Mount*) NULL;
+  handle->stream = (FileStream*) NULL;
+  handle->use_count = 1;
+
+  return fd;
+}
+
 KernelProxy *KernelProxy::KPInstance() {
   pthread_once(&kp_once_, Instantiate);
   return kp_instance_;
 }
 
 void KernelProxy::Instantiate() {
   assert(!kp_instance_);
   kp_instance_ = new KernelProxy();
 }
 
@@ skipping 115 matching lines @@
     }
   }
 
   mount->Ref(st.st_ino);
   mount->Ref();
   // Setup file handle.
   int handle_slot = open_files_.Alloc();
   int fd = fds_.Alloc();
   FileDescriptor* file = fds_.At(fd);
   file->handle = handle_slot;
-  FileHandle *handle = open_files_.At(handle_slot);
+  FileHandle* handle = open_files_.At(handle_slot);
 
   // init should be safe because we have the kernel proxy lock
   if (pthread_mutex_init(&handle->lock, NULL)) assert(0);
 
   handle->mount = mount;
+  handle->stream = NULL;
   handle->node = st.st_ino;
   handle->flags = flags;
   handle->use_count = 1;
 
   if (flags & O_APPEND) {
     handle->offset = st.st_size;
   } else {
     handle->offset = 0;
   }
 
   return fd;
 }
 
+ino_t KernelProxy::CreateSocket() {
+  SimpleAutoLock lock(&kp_lock_);
+  int handle_slot = open_files_.Alloc();
+  int fd = fds_.Alloc();
+  FileDescriptor* file = fds_.At(fd);
+  file->handle = handle_slot;
+  FileHandle *handle = open_files_.At(handle_slot);
+  handle->mount = NULL;
+  handle->stream = NULL;
+  handle->use_count = 1;
+  return fd;
+}
+
+struct hostent* KernelProxy::gethostbyname(const char* name) {
+  struct hostent *res = (struct hostent*) malloc(sizeof(struct hostent));
+  if (!res) return NULL;
+  res->h_addr_list = (char**) malloc(sizeof(char*) * 2);
+  if (!res->h_addr_list) return NULL;
+  res->h_addr_list[0] = (char*) malloc(sizeof(long int));
+  if (!res->h_addr_list[0]) return NULL;
+  *((long int*)res->h_addr_list[0]) = ss->gethostbyname(name);
+  res->h_addr_list[1] = NULL;
+  res->h_length = sizeof(long int);
+  return res;
+}
+
 int KernelProxy::open(const std::string& path, int flags, mode_t mode) {
   if (path.empty()) {
     errno = EINVAL;
     return -1;
   }
 
   Path p(path);
   if (path[0] != '/') {
     p = Path(cwd_.FormulatePath() + "/" + path);
   }
@@ skipping 19 matching lines @@
   }
   int h = file->handle;
   fds_.Free(fd);
   FileHandle *handle = open_files_.At(h);
   if (handle == NULL) {
     errno = EBADF;
     return -1;
   }
   handle->use_count--;
   ino_t node = handle->node;
-  Mount *mount = handle->mount;
-  if (handle->use_count <= 0) {
-    open_files_.Free(h);
-    mount->Unref(node);
+  if (handle->mount) {
+    Mount* mount = handle->mount;
+    if (handle->use_count <= 0) {
+      open_files_.Free(h);
+      mount->Unref(node);
+    }
+    mount->Unref();
   }
-  mount->Unref();
   return 0;
 }
 
 ssize_t KernelProxy::read(int fd, void *buf, size_t count) {
   FileHandle *handle;
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
@@ skipping 357 matching lines @@
         ((amode & X_OK) && !(mode & X_OK))) {
         errno = EACCES;
         return -1;
     }
   }
   // By now we have checked access permissions for
   // each component of the path.
   return 0;
 }
 
-KernelProxy::FileHandle *KernelProxy::GetFileHandle(int fd) {
+FileHandle* KernelProxy::GetFileHandle(int fd) {
   SimpleAutoLock lock(&kp_lock_);
   FileDescriptor *file = fds_.At(fd);
   if (!file) {
     return NULL;
   }
   return open_files_.At(file->handle);
 }
 
 int KernelProxy::mkdir(const std::string& path, mode_t mode) {
   if (path.empty()) {
@@ skipping 37 matching lines @@
   if (mm_.InMountRootPath(abs_path)) {
     errno = EBUSY;
     return -1;
   }
 
   return mount->Rmdir(buf.st_ino);
 }
 
 #ifdef __GLIBC__
 int KernelProxy::socket(int domain, int type, int protocol) {
-  errno = ENOSYS;
-  fprintf(stderr, "socket has not been implemented!\n");
-  return -1;
+  return ss->socket(domain, type, protocol);
 }
 
 int KernelProxy::accept(int sockfd, struct sockaddr *addr,
     socklen_t* addrlen) {
-  errno = ENOSYS;
-  fprintf(stderr, "accept has not been implemented!\n");
-  return -1;
+  return ss->accept(GetFileHandle(sockfd), addr, addrlen);
 }
 
 int KernelProxy::bind(int sockfd, const struct sockaddr *addr,
                       socklen_t addrlen) {
-  errno = ENOSYS;
-  fprintf(stderr, "bind has not been implemented!\n");
-  return -1;
+  struct sockaddr_in* in_addr = (struct sockaddr_in*)addr;
+  return ss->bind(GetFileHandle(sockfd), in_addr->sin_addr.s_addr,
+    (unsigned short) ntohs(in_addr->sin_port));
 }
 
 int KernelProxy::listen(int sockfd, int backlog) {
-  errno = ENOSYS;
-  fprintf(stderr, "listen has not been implemented!\n");
-  return -1;
+  return ss->listen(GetFileHandle(sockfd), backlog);
 }
 
 int KernelProxy::connect(int sockfd, const struct sockaddr *addr,
                          socklen_t addrlen) {
-  errno = ENOSYS;
-  fprintf(stderr, "connect has not been implemented!\n");
-  return -1;
+  struct sockaddr_in* in_addr = (struct sockaddr_in*)addr;
+  return ss->connect(GetFileHandle(sockfd), in_addr->sin_addr.s_addr,
+    (unsigned short) ntohs(in_addr->sin_port));
 }
 
 int KernelProxy::send(int sockfd, const void *buf, size_t len, int flags) {
-  errno = ENOSYS;
-  fprintf(stderr, "send has not been implemented!\n");
-  return -1;
+  size_t nwr;
+  ss->write(GetFileHandle(sockfd), (const char*)buf, len, &nwr);
+  return nwr;
 }
 
 int KernelProxy::sendmsg(int sockfd, const struct msghdr *msg, int flags) {
   errno = ENOSYS;
   fprintf(stderr, "sendmsg has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::sendto(int sockfd, const void *buf, size_t len, int flags,
            const struct sockaddr *dest_addr, socklen_t addrlen) {
   errno = ENOSYS;
   fprintf(stderr, "sendto has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::recv(int sockfd, void *buf, size_t len, int flags) {
-  errno = ENOSYS;
-  fprintf(stderr, "recv has not been implemented!\n");
-  return -1;
+  size_t nread;
+  ss->read(GetFileHandle(sockfd), reinterpret_cast<char*>(buf), len, &nread);
+  return nread;
 }
 
 int KernelProxy::recvmsg(int sockfd, struct msghdr *msg, int flags) {
   errno = ENOSYS;
   fprintf(stderr, "recvmsg has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::recvfrom(int sockfd, void *buf, size_t len, int flags,
              struct sockaddr *dest_addr, socklen_t* addrlen) {
   errno = ENOSYS;
   fprintf(stderr, "recvfrom has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::select(int nfds, fd_set *readfds, fd_set *writefds,
            fd_set* exceptfds, const struct timeval *timeout) {
-  errno = ENOSYS;
-  fprintf(stderr, "select has not been implemented!\n");
-  return -1;
+  dbgprintf("int select() before mutex\n");
+  Mutex::Lock lock(ss->mutex());
+  dbgprintf("int select() after mutex\n");
+
+  timespec ts_abs;
+  if (timeout) {
+    timespec ts;
+    TIMEVAL_TO_TIMESPEC(timeout, &ts);
+    timeval tv_now;
+    gettimeofday(&tv_now, NULL);
+    int64_t current_time_us =
+        tv_now.tv_sec * kMicrosecondsPerSecond + tv_now.tv_usec;
+    int64_t wakeup_time_us =
+        current_time_us +
+        timeout->tv_sec * kMicrosecondsPerSecond + timeout->tv_usec;
+     ts_abs.tv_sec = wakeup_time_us / kMicrosecondsPerSecond;
+     ts_abs.tv_nsec =
+        (wakeup_time_us - ts_abs.tv_sec * kMicrosecondsPerSecond) *
+        kNanosecondsPerMicrosecond;
+  }
+
+  while (!(ss->IsReady(nfds, readfds, &FileStream::is_read_ready, false) ||
+          ss->IsReady(nfds, writefds, &FileStream::is_write_ready, false) ||
+          ss->IsReady(nfds, exceptfds, &FileStream::is_exception, false))) {
+    if (timeout) {
+      if (!timeout->tv_sec && !timeout->tv_usec)
+        break;
+
+      if (ss->cond().timedwait(ss->mutex(), &ts_abs)) {
+        if (errno == ETIMEDOUT)
+          break;
+        else
+          return -1;
+      }
+    } else {
+      ss->cond().wait(ss->mutex());
+    }
+  }
+
+  int nread = ss->IsReady(nfds, readfds, &FileStream::is_read_ready, true);
+  int nwrite = ss->IsReady(nfds, writefds, &FileStream::is_write_ready, true);
+  int nexcpt = ss->IsReady(nfds, exceptfds, &FileStream::is_exception, true);
+  if (nread < 0 || nwrite < 0 || nexcpt < 0) {
+    errno = EBADF;
+    return -1;
+  }
+  return nread + nwrite + nexcpt;
 }
 
 int KernelProxy::pselect(int nfds, fd_set *readfds, fd_set *writefds,
             fd_set* exceptfds, const struct timeval *timeout, void* sigmask) {
   errno = ENOSYS;
   fprintf(stderr, "pselect has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::getpeername(int sockfd, struct sockaddr *addr,
@@ skipping 18 matching lines @@
 }
 
 int KernelProxy::setsockopt(int sockfd, int level, int optname,
             const void *optval, socklen_t optlen) {
   errno = ENOSYS;
   fprintf(stderr, "setsockopt has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::shutdown(int sockfd, int how) {
-  errno = ENOSYS;
-  fprintf(stderr, "shutdown has not been implemented!\n");
-  return -1;
+  return close(sockfd);
 }
 
 int KernelProxy::epoll_create(int size) {
   errno = ENOSYS;
   fprintf(stderr, "epoll_create has not been implemented!\n");
   return -1;
 }
 
 int KernelProxy::epoll_create1(int flags) {
   errno = ENOSYS;
@@ skipping 36 matching lines @@
 
 int KernelProxy::ppoll(struct pollfd *fds, nfds_t nfds,
           const struct timespec *timeout,
           const sigset_t *sigmask, size_t sigset_size) {
   errno = ENOSYS;
   fprintf(stderr, "ppoll has not been implemented!\n");
   return -1;
 }
 #endif