changes in memory mount and socket subsystem to port thttpd

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>
 #ifndef __GLIBC__
 #include <nacl-mounts/net/newlib_compat.h>
 #else
@@ skipping 17 matching lines @@
 #define MAXPATHLEN 256
 #endif
 
 static const int64_t kMicrosecondsPerSecond = 1000 * 1000;
 static const int64_t kNanosecondsPerMicrosecond = 1000;
 
 KernelProxy::KernelProxy() {
   if (pthread_mutex_init(&kp_lock_, NULL)) assert(0);
   cwd_ = Path("/");
   mm_.Init();
-
   // Setup file descriptors 0, 1, and 2 for STDIN, STDOUT, and STDERR
   int ret = mkdir("/dev", 0777);
   assert(ret == 0);
   DevMount* dev_mount = new DevMount();
   ret = mm_.AddMount(dev_mount, "/dev");
   assert(ret == 0);
   ret = mkdir("/dev/fd", 0777);
   assert(ret == 0);
   ConsoleMount *console_mount = new ConsoleMount();
   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);
+  socket_subsystem_ = NULL;
 }
 
 void KernelProxy::SetSocketSubSystem(BaseSocketSubSystem* bss) {
   socket_subsystem_ = bss;
 }
 
 void KernelProxy::RemoveSocket(int fd) {
   this->close(fd);
 }
 
 int KernelProxy::AddSocket(Socket* 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 = reinterpret_cast<Mount*>(NULL);
-  handle->stream = reinterpret_cast<Socket*>(NULL);
+  handle->stream = stream;
   handle->use_count = 1;
 
   return fd;
 }
 
 KernelProxy *KernelProxy::KPInstance() {
   pthread_once(&kp_once_, Instantiate);
   return kp_instance_;
 }
 
@@ skipping 330 matching lines @@
 
 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;
-
   // 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);
@@ skipping 37 matching lines @@
 }
 
 int KernelProxy::IsReady(int nfds, fd_set* fds,
     bool (Socket::*is_ready)(), bool apply) {
   if (!fds)
     return 0;
 
   int nset = 0;
   for (int i = 0; i < nfds; i++) {
     if (FD_ISSET(i, fds)) {
-      Socket* stream = GetFileHandle(i) > 0 ?
-        GetFileHandle(i)->stream : NULL;
-      if (!stream)
+      FileHandle* h = GetFileHandle(i);
+      if (h == NULL) {
         return -1;
+      }
+      Socket* stream = h->stream;
       if ((stream->*is_ready)()) {
         if (!apply)
           return 1;
         else
           nset++;
       } else {
         if (apply)
           FD_CLR(i, fds);
       }
     }
@@ skipping 342 matching lines @@
   handle->use_count = 1;
   return fd;
 }
 
 int KernelProxy::accept(int sockfd, struct sockaddr *addr,
     socklen_t* addrlen) {
   if (GetFileHandle(sockfd) == 0)
     return EBADF;
   Socket* ret = socket_subsystem_->accept(GetFileHandle(sockfd)->stream,
     addr, addrlen);
-  if (ret)
+  if (ret) {
+    struct sockaddr_in* iaddr = (struct sockaddr_in*) addr;
+    iaddr->sin_family = AF_INET;
+    iaddr->sin_port = 9000;
     return AddSocket(ret);
-  else
+  } else {
     return -1;
+  }
 }
 
 int KernelProxy::bind(int sockfd, const struct sockaddr *addr,
                       socklen_t addrlen) {
   if (GetFileHandle(sockfd) == 0)
     return EBADF;
   struct sockaddr_in* in_addr = (struct sockaddr_in*)addr;
   return socket_subsystem_->bind(&(GetFileHandle(sockfd)->stream),
       addr, addrlen);
 }
@@ skipping 90 matching lines @@
 
   while (!(IsReady(nfds, readfds, &Socket::is_read_ready, false) ||
           IsReady(nfds, writefds, &Socket::is_write_ready, false) ||
           IsReady(nfds, exceptfds, &Socket::is_exception, false))) {
     SimpleAutoLock lock(select_mutex().get());
     if (timeout) {
       if (!timeout->tv_sec && !timeout->tv_usec)
         break;
 
       if (select_cond().timedwait(select_mutex(), &ts_abs)) {
-        if (errno == ETIMEDOUT)
+        if (errno == ETIMEDOUT) {
           break;
-        else
+        } else {
+          dbgprintf("select: timedwait problem %m\n");
           return -1;
+        }
       }
     } else {
       select_cond().wait(select_mutex());
     }
   }
 
   int nread = IsReady(nfds, readfds, &Socket::is_read_ready, true);
   int nwrite = IsReady(nfds, writefds, &Socket::is_write_ready, true);
   int nexcpt = IsReady(nfds, exceptfds, &Socket::is_exception, true);
   if (nread < 0 || nwrite < 0 || nexcpt < 0) {
     errno = EBADF;
+    dbgprintf("select: EBADF problem %m\n");
     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;
@@ skipping 15 matching lines @@
 
 int KernelProxy::getsockopt(int sockfd, int level, int optname, void *optval,
                socklen_t* optlen) {
   errno = ENOSYS;
   fprintf(stderr, "getsockopt has not been implemented!\n");
   return -1;
 }
 
 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;
+  socket_subsystem_->setsockopt(GetFileHandle(sockfd)->stream, level,
+      optname, optval, optlen);
+  return 0;
 }
 
 int KernelProxy::shutdown(int sockfd, int how) {
   FileHandle* fh = GetFileHandle(sockfd);
   if (fh == 0)
     return EBADF;
   return socket_subsystem_->shutdown(fh->stream, how);
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int sv[2]) {
   errno = ENOSYS;
   fprintf(stderr, "socketpair has not been implemented!\n");
   return -1;
 }