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 "base/KernelProxy.h"
 #include <assert.h>
+#include <netinet/in.h>
+#include <sys/time.h>
 #include <list>
 #include <utility>
-#include "../console/ConsoleMount.h"
-#include "../dev/DevMount.h"
-#include "KernelProxy.h"
+#include "console/ConsoleMount.h"
+#include "dev/DevMount.h"
 #include "MountManager.h"
+#include "net/BaseSocketSubSystem.h"
+#include "net/SocketSubSystem.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::SetSocketSubSystem(BaseSocketSubSystem* bss) {
+  ss = bss;
+}
+
+void KernelProxy::RemoveFileStream(int fd) {
+  this->close(fd);
+}
+
+int KernelProxy::AddFileStream(FileStream* stream, int fd) {
+  SimpleAutoLock lock(&kp_lock_);
+
+  // Setup file handle.
+  int handle_slot = open_files_.AllocAt(fd);
+  if (fds_.AllocAt(fd) != fd) return -1;
+  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;
+}
+
+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;
 }
 
+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 12 matching lines @@
 int KernelProxy::close(int fd) {
   SimpleAutoLock lock(&kp_lock_);
 
   FileDescriptor* file = fds_.At(fd);
   if (file == NULL) {
     errno = EBADF;
     return -1;
   }
   int h = file->handle;
   fds_.Free(fd);
-  FileHandle *handle = open_files_.At(h);
+  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();
+  } else {
+    ss->close(handle->stream);
   }
-  mount->Unref();
   return 0;
 }
 
 ssize_t KernelProxy::read(int fd, void *buf, size_t count) {
-  FileHandle *handle;
+  FileHandle* handle;
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
 
   SimpleAutoLock(&handle->lock);
 
-  // Check that this file handle can be read from.
-  if ((handle->flags & O_ACCMODE) == O_WRONLY ||
-      is_dir(handle->mount, handle->node)) {
+  if (handle->mount) {
+    // Check that this file handle can be read from.
+    if ((handle->flags & O_ACCMODE) == O_WRONLY ||
+        is_dir(handle->mount, handle->node)) {
+      errno = EBADF;
+      return -1;
+    }
+
+    ssize_t n = handle->mount->Read(handle->node, handle->offset, buf, count);
+    if (n > 0) {
+      handle->offset += n;
+    }
+    return n;
+  } else if (handle->stream) {
+    // TODO(vissi): more elaborate implementation
+    return recv(fd, buf, count, 0);
+  } else {
     errno = EBADF;
     return -1;
   }
-
-  ssize_t n = handle->mount->Read(handle->node, handle->offset, buf, count);
-  if (n > 0) {
-    handle->offset += n;
-  }
-  return n;
 }
 
 ssize_t KernelProxy::write(int fd, const void *buf, size_t count) {
-  FileHandle *handle;
+  FileHandle* handle;
 
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
 
   SimpleAutoLock(&handle->lock);
 
-  // Check that this file handle can be written to.
-  if ((handle->flags & O_ACCMODE) == O_RDONLY ||
-      is_dir(handle->mount, handle->node)) {
+  if (handle->mount) {
+    // Check that this file handle can be written to.
+    if ((handle->flags & O_ACCMODE) == O_RDONLY ||
+        is_dir(handle->mount, handle->node)) {
+      errno = EBADF;
+      return -1;
+    }
+
+    ssize_t n = handle->mount->Write(handle->node, handle->offset, buf, count);
+
+    if (n > 0) {
+      handle->offset += n;
+    }
+    return n;
+  } else if (handle->stream) {
+    // TODO(vissi): more elaborate implementation
+    return send(fd, buf, count, 0);
+  } else {
     errno = EBADF;
     return -1;
   }
-
-  ssize_t n = handle->mount->Write(handle->node, handle->offset, buf, count);
-
-  if (n > 0) {
-    handle->offset += n;
-  }
-  return n;
 }
 
 int KernelProxy::fstat(int fd, struct stat *buf) {
-  FileHandle *handle;
+  FileHandle* handle;
 
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
   SimpleAutoLock(&handle->lock);
   return handle->mount->Stat(handle->node, buf);
 }
 
 int KernelProxy::ioctl(int fd, unsigned long request) {
   errno = ENOSYS;
   fprintf(stderr, "ioctl has not been implemented!\n");
   assert(0);
   return -1;
 }
 
 int KernelProxy::kill(pid_t pid, int sig) {
   errno = ENOSYS;
   fprintf(stderr, "kill has not been implemented!\n");
   assert(0);
   return -1;
 }
 
 int KernelProxy::getdents(int fd, void *buf, unsigned int count) {
-  FileHandle *handle;
+  FileHandle* handle;
 
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
 
   SimpleAutoLock(&handle->lock);
 
   int ret = handle->mount->Getdents(handle->node, handle->offset,
                                     (struct dirent*)buf, count);
 
   if (ret != -1) {
     // TODO(bradnelson): think of a better interface for Mount::Getdents.
     // http://code.google.com/p/naclports/issues/detail?id=18
     handle->offset += ret / sizeof(struct dirent);
   }
   return ret;
 }
 
 int KernelProxy::fsync(int fd) {
-  FileHandle *handle;
+  FileHandle* handle;
 
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
   SimpleAutoLock(&handle->lock);
   return handle->mount->Fsync(handle->node);
 }
 
 int KernelProxy::isatty(int fd) {
-  FileHandle *handle;
+  FileHandle* handle;
 
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return 0;
   }
-  SimpleAutoLock(&handle->lock);
   return handle->mount->Isatty(handle->node);
 }
 
+int KernelProxy::dup2(int fd, int newfd) {
+  FileStream* stream = GetFileHandle(fd) > 0
+    ? GetFileHandle(fd)->stream : NULL;
+  if (!stream)
+    return EBADF;
+
+  AddFileStream(stream, newfd);
+  return 0;
+}
+
+int KernelProxy::IsReady(int nfds, fd_set* fds,
+    bool (FileStream::*is_ready)(), bool apply) {
+  if (!fds)
+    return 0;
+
+  int nset = 0;
+  for (int i = 0; i < nfds; i++) {
+    if (FD_ISSET(i, fds)) {
+      FileStream* stream = GetFileHandle(i) > 0 ?
+        GetFileHandle(i)->stream : NULL;
+      if (!stream)
+        return -1;
+      if ((stream->*is_ready)()) {
+        if (!apply)
+          return 1;
+        else
+          nset++;
+      } else {
+        if (apply)
+          FD_CLR(i, fds);
+      }
+    }
+  }
+  return nset;
+}
+
 int KernelProxy::dup(int oldfd) {
   SimpleAutoLock lock(&kp_lock_);
 
+  FileHandle* fh = GetFileHandle(oldfd);
+  if (!fh) {
+    errno = EBADF;
+    return -1;
+  }
+  if (fh->mount == NULL) {
+    FileStream* stream = GetFileHandle(oldfd) > 0
+      ? GetFileHandle(oldfd)->stream : NULL;
+    if (!stream)
+      return EBADF;
+    int new_fd = AddFileStream(stream);
+    return new_fd;
+  }
   FileDescriptor* oldfile = fds_.At(oldfd);
   if (oldfile == NULL) {
     errno = EBADF;
     return -1;
   }
   int newfd = fds_.Alloc();
   FileDescriptor *newfile = fds_.At(newfd);
   int h = oldfile->handle;
   newfile->handle = h;
-  FileHandle *handle = open_files_.At(h);
+  FileHandle* handle = open_files_.At(h);
   // init should be safe because we have the kernel proxy lock
   if (pthread_mutex_init(&handle->lock, NULL)) assert(0);
 
   if (handle == NULL) {
     errno = EBADF;
     return -1;
   }
   ++handle->use_count;
   handle->mount->Ref(handle->node);
   handle->mount->Ref();
   return newfd;
 }
 
 off_t KernelProxy::lseek(int fd, off_t offset, int whence) {
-  FileHandle *handle;
+  FileHandle* handle;
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
 
   SimpleAutoLock(&handle->lock);
 
   off_t next;
   ssize_t len;
@@ skipping 206 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) {
+KernelProxy::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;
+  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);
+  // this means it is a socket (not a mount handle) and it's implementation
+  // determined by handle->stream type is defined later
+  handle->mount = NULL;
+  handle->stream = NULL;
+  handle->use_count = 1;
+  return fd;
 }
 
 int KernelProxy::accept(int sockfd, struct sockaddr *addr,
     socklen_t* addrlen) {
-  errno = ENOSYS;
-  fprintf(stderr, "accept has not been implemented!\n");
-  return -1;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  FileStream* ret = ss->accept(GetFileHandle(sockfd)->stream, addr, addrlen);
+  if (!ret)
+    return AddFileStream(ret);
+  else
+    return -1;
 }
 
 int KernelProxy::bind(int sockfd, const struct sockaddr *addr,
                       socklen_t addrlen) {
-  errno = ENOSYS;
-  fprintf(stderr, "bind has not been implemented!\n");
-  return -1;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  struct sockaddr_in* in_addr = (struct sockaddr_in*)addr;
+  return ss->bind(&(GetFileHandle(sockfd)->stream), 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;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  return ss->listen(GetFileHandle(sockfd)->stream, 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;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  struct sockaddr_in* in_addr = (struct sockaddr_in*)addr;
+  return ss->connect(&(GetFileHandle(sockfd)->stream), 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;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  ss->write(GetFileHandle(sockfd)->stream, (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;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  ss->read(GetFileHandle(sockfd)->stream,
+    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;
+  Mutex::Lock lock(mutex());
+
+  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 (!(IsReady(nfds, readfds, &FileStream::is_read_ready, false) ||
+          IsReady(nfds, writefds, &FileStream::is_write_ready, false) ||
+          IsReady(nfds, exceptfds, &FileStream::is_exception, false))) {
+    if (timeout) {
+      if (!timeout->tv_sec && !timeout->tv_usec)
+        break;
+
+      if (cond().timedwait(mutex(), &ts_abs)) {
+        if (errno == ETIMEDOUT)
+          break;
+        else
+          return -1;
+      }
+    } else {
+      cond().wait(mutex());
+    }
+  }
+
+  int nread = IsReady(nfds, readfds, &FileStream::is_read_ready, true);
+  int nwrite = IsReady(nfds, writefds, &FileStream::is_write_ready, true);
+  int nexcpt = 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;
+  if (GetFileHandle(sockfd) == 0) return EBADF;
+  return ss->shutdown(GetFileHandle(sockfd)->stream, how);
 }
 
 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