Socket subsystem implementation

libraries/nacl-mounts/base/Entry.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 <errno.h>
 #include <irt.h>
 #ifdef __GLIBC__
 #include <irt_syscalls.h>
 #endif
@@ skipping 151 matching lines @@
   }
 
   int symlink(const char *path1, const char *path2) {
     return kp->symlink(path1, path2);
   }
 
   int kill(pid_t pid, int sig) {
     return kp->kill(pid, sig);
   }
 
+  struct hostent* gethostbyname(const char* name) {
+    return kp->gethostbyname(name);
+  }
+
   int unlink(const char *path) {
     return kp->unlink(path);
   }
 
   ssize_t __real_read(int fd, void *buf, size_t count) {
     if (REAL(read)) {
       size_t nread;
       int error = REAL(read)(fd, buf, count, &nread);
       if (error) {
         errno = error;
@@ skipping 215 matching lines @@
                 struct sockaddr *src_addr, socklen_t *addrlen, int* ret) {
     *ret = kp->recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
     return (*ret < 0) ? errno : 0;
   }
 
   int WRAP(recvmsg) (int sockfd, struct msghdr *msg, int flags, int* ret) {
     *ret = kp->recvmsg(sockfd, msg, flags);
     return (*ret < 0) ? errno : 0;
   }
 
+  struct hostent* WRAP(gethostbyname) (const char* name) {
+    return kp->gethostbyname(name);
+  }
+
+
   int WRAP(getsockname) (int sockfd, struct sockaddr* addr,
                          socklen_t* addrlen) {
     return (kp->getsockname(sockfd, addr, addrlen)) < 0 ? errno : 0;
   }
 
   int WRAP(getpeername) (int sockfd, struct sockaddr* addr,
                          socklen_t* addrlen) {
     return (kp->getpeername(sockfd, addr, addrlen) < 0) ? errno : 0;
   }
 
@@ skipping 10 matching lines @@
   }
 
   int WRAP(socketpair) (int domain, int type, int protocol, int sv[2]) {
     return (kp->socketpair(domain, type, protocol, sv) < 0) ? errno : 0;
   }
 
   int WRAP(shutdown) (int sockfd, int how) {
     return (kp->shutdown(sockfd, how) < 0) ? errno : 0;
   }
 
-  int WRAP(epoll_create) (int size, int* ret) {
-    *ret = kp->epoll_create(size);
-    return (*ret < 0) ? errno : 0;
-  }
-
-  int WRAP(epoll_ctl) (int epfd, int op, int fd, struct epoll_event *event) {
-    return (kp->epoll_ctl(epfd, op, fd, event) < 0) ? errno : 0;
-  }
-
-  int WRAP(epoll_wait) (int epfd, struct epoll_event *events,
-                        int maxevents, int timeout, int *count) {
-    *count = kp->epoll_wait(epfd, events, maxevents, timeout);
-    return (*count < 0) ? errno : 0;
-  }
-
-  int WRAP(epoll_pwait) (int epfd, struct epoll_event *events,
-                         int maxevents, int timeout, const sigset_t *sigmask,
-                         size_t sigset_size, int *count) {
-    *count = kp->epoll_pwait(epfd, events, maxevents, timeout, sigmask,
-                           sigset_size);
-    return (*count < 0) ? errno : 0;
-  }
-
-  int WRAP(poll) (struct pollfd *fds, nfds_t nfds, int timeout, int *count) {
-    *count = kp->poll(fds, nfds, timeout);
-    return (*count < 0) ? errno : 0;
-  }
-
-  int WRAP(ppoll) (struct pollfd *fds, nfds_t nfds,
-                   const struct timespec *timeout, const sigset_t *sigmask,
-                   size_t sigset_size, int *count) {
-    *count = kp->ppoll(fds, nfds, timeout, sigmask, sigset_size);
-    return (*count < 0) ? errno : 0;
-  }
 #endif
 }
 
 static struct NaClMountsStaticInitializer {
     NaClMountsStaticInitializer() {
       DO_WRAP(fdio, close);
       DO_WRAP(fdio, fstat);
       DO_WRAP(fdio, getdents);
       DO_WRAP(fdio, read);
       DO_WRAP(fdio, seek);
@@ skipping 18 matching lines @@
       DO_WRAP(net, sendmsg);
       DO_WRAP(net, recv);
       DO_WRAP(net, recvfrom);
       DO_WRAP(net, recvmsg);
       DO_WRAP(net, getpeername);
       DO_WRAP(net, getsockname);
       DO_WRAP(net, getsockopt);
       DO_WRAP(net, setsockopt);
       DO_WRAP(net, socketpair);
       DO_WRAP(net, shutdown);
-
-      DO_WRAP(net, epoll_create);
-      DO_WRAP(net, epoll_ctl);
-      DO_WRAP(net, epoll_wait);
-      DO_WRAP(net, epoll_pwait);
-      DO_WRAP(net, poll);
-      DO_WRAP(net, ppoll);
 #endif
     }
   } nacl_mounts_static_initializer;
 
 #ifndef __GLIBC__
 
 
 // Several more that newlib lacks, that don't route to kernel proxy for now.
 
 extern "C" {
@@ skipping 42 matching lines @@
   return 0;
 }
 
 void (*signal(int sig, void (*func)(int)))(int) {
   return reinterpret_cast<void(*)(int)>(-1);
 }
 
 };
 
 #endif // !__GLIBC__