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>
+#if __GLIBC__
+#include <netinet/in.h>
+#endif
+#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
 
+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);
 }
 
+#ifdef __GLIBC__
+void KernelProxy::SetSocketSubSystem(BaseSocketSubSystem* bss) {
+  socket_subsystem_ = 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;
+}
+#endif
+
 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;
+#if __GLIBC__
+  handle->stream = NULL;
+#endif
   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* ghn_res = NULL;

[Dmitry Polukhin, 2012/05/31 14:06:45]

They should be thread local and static (or in unnamed namespace) to avoid
collision with user variables.

[vissi, 2012/06/01 09:12:57]

Now they are static. You mean C++11 thread_local keyword?

[Dmitry Polukhin, 2012/06/01 09:52:13]

I meant __thread for GCC
http://gcc.gnu.org/onlinedocs/gcc-3.3.1/gcc/Thread-Local.html
But usually it is used indirectly via macro that expands to compiler specific
keyword. But it won't remove memory leak completely because when thread exists
the objects will be lost.

+char** ghn_addr_list = NULL;
+char* ghn_item = NULL;
+
+#if __GLIBC__
+struct hostent* KernelProxy::gethostbyname(const char* name) {
+  struct hostent *res = ghn_res == NULL
+    ? (ghn_res = (struct hostent*) malloc(sizeof(struct hostent)))
+    : ghn_res;
+  if (!res) return NULL;
+  res->h_addr_list = ghn_addr_list == NULL
+    ? (ghn_addr_list = (char**) malloc(sizeof(char*) * 2))
+    : ghn_addr_list;
+  if (!res->h_addr_list) return NULL;
+  res->h_addr_list[0] = ghn_item == NULL
+    ? (ghn_item = (char*) malloc(sizeof(long int)))
+    : ghn_item;
+  if (!res->h_addr_list[0]) return NULL;
+  *((long int*)res->h_addr_list[0]) = socket_subsystem_->gethostbyname(name);
+  res->h_addr_list[1] = NULL;
+  res->h_length = sizeof(long int);
+  return res;
+}
+#endif
+
 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);
   }
 
   std::pair<Mount *, std::string> m_and_p =
     mm_.GetMount(p.FormulatePath());
 
   if (!(m_and_p.first)) {
     errno = ENOENT;
     return -1;
   }
 
   return OpenHandle(m_and_p.first, m_and_p.second, flags, mode);
 }
 
 int KernelProxy::close(int fd) {
-  SimpleAutoLock lock(&kp_lock_);
+  SimpleAutoLock* lock = new SimpleAutoLock(&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();
+#if __GLIBC__
+  } else {
+    FileStream* stream = handle->stream;
+    delete lock;
+    socket_subsystem_->close(stream);
+    SimpleAutoLock lock(&kp_lock_);
+    if (handle->use_count <= 0) {
+      open_files_.Free(h);
+    }
+    return 0;
+#endif
   }
-  mount->Unref();
+  delete lock;
   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);
+  if (handle->mount) {
+    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)) {
+      errno = EBADF;
+      return -1;
+    }
 
-  // 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;
+#if __GLIBC__
+  } else if (handle->stream) {
+    // TODO(vissi): more elaborate implementation
+    return recv(fd, buf, count, 0);
+#endif
   }
-
-  ssize_t n = handle->mount->Read(handle->node, handle->offset, buf, count);
-  if (n > 0) {
-    handle->offset += n;
-  }
-  return n;
+  errno = EBADF;
+  return -1;
 }
 
 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);
+  if (handle->mount) {
+    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)) {
+      errno = EBADF;
+      return -1;
+    }
 
-  // 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;
+#if __GLIBC__
+  } else if (handle->stream) {
+    // TODO(vissi): more elaborate implementation
+    return send(fd, buf, count, 0);
+#endif
   }
-
-  ssize_t n = handle->mount->Write(handle->node, handle->offset, buf, count);
-
-  if (n > 0) {
-    handle->offset += n;
-  }
-  return n;
+  errno = EBADF;
+  return -1;
 }
 
 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) {
+  SimpleAutoLock lock(&kp_lock_);
+  int handle_slot = fds_.At(fd)->handle;
+  if (fds_.AllocAt(fd) != fd) return -1;
+  FileDescriptor* file = fds_.At(newfd);
+  file->handle = handle_slot;
+  return 0;
+}
+
+#if __GLIBC__
+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;
+}
+#endif
+
 int KernelProxy::dup(int oldfd) {
   SimpleAutoLock lock(&kp_lock_);
 
+  FileHandle* fh = GetFileHandle(oldfd);
+  if (!fh) {
+    errno = EBADF;
+    return -1;
+  }
+#if __GLIBC__
+  if (fh->mount == NULL) {
+    FileStream* stream = GetFileHandle(oldfd) > 0
+      ? GetFileHandle(oldfd)->stream : NULL;
+    if (!stream)
+      return EBADF;
+    SimpleAutoLock lock(&kp_lock_);
+    int handle_slot = fds_.At(oldfd)->handle;
+    int newfd = fds_.Alloc();
+    FileDescriptor* file = fds_.At(newfd);
+    file->handle = handle_slot;
+    return newfd;
+  }
+#endif
   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 = socket_subsystem_->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 socket_subsystem_->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 socket_subsystem_->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 socket_subsystem_->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;
+  if (GetFileHandle(sockfd) == 0)
+    return EBADF;
+  size_t nwr;
+  socket_subsystem_->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;
+  if (GetFileHandle(sockfd) == 0)
+    return EBADF;
+  size_t nread;
+  socket_subsystem_->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;
+  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))) {
+    Mutex::Lock lock(select_mutex());
+    if (timeout) {
+      if (!timeout->tv_sec && !timeout->tv_usec)
+        break;
+
+      if (select_cond().timedwait(select_mutex(), &ts_abs)) {
+        if (errno == ETIMEDOUT)
+          break;
+        else
+          return -1;
+      }
+    } else {
+      select_cond().wait(select_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 socket_subsystem_->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