[NaCl SDK] nacl_io: Add initial implementations of kill and signal

native_client_sdk/src/libraries/nacl_io/kernel_proxy.cc

 // Copyright (c) 2012 The Chromium 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 "nacl_io/kernel_proxy.h"
 
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
+#include <unistd.h>
 
 #include <iterator>
 #include <string>
 
+#include "nacl_io/dbgprint.h"
 #include "nacl_io/host_resolver.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/mount.h"
 #include "nacl_io/mount_dev.h"
 #include "nacl_io/mount_html5fs.h"
 #include "nacl_io/mount_http.h"
 #include "nacl_io/mount_mem.h"
 #include "nacl_io/mount_node.h"
 #include "nacl_io/mount_node_tcp.h"
 #include "nacl_io/mount_node_udp.h"
 #include "nacl_io/mount_passthrough.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/typed_mount_factory.h"
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 256
 #endif
 
 namespace nacl_io {
 
-KernelProxy::KernelProxy() : dev_(0), ppapi_(NULL) {
+KernelProxy::KernelProxy() : dev_(0), ppapi_(NULL),
+                             sigwinch_handler_(SIG_IGN) {
 }
 
 KernelProxy::~KernelProxy() {
   // Clean up the MountFactories.
   for (MountFactoryMap_t::iterator i = factories_.begin();
        i != factories_.end();
        ++i) {
     delete i->second;
   }
 
@@ skipping 644 matching lines @@
 
   error = handle->node()->Tcsetattr(optional_actions, termios_p);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
+int KernelProxy::kill(pid_t pid, int sig) {
+  // Currently we don't even pretend that other processes exist
+  // so we can only send a signal to outselves.  For kill(2)
+  // pid 0 means the current process group and -1 means all the
+  // processes we have permission to send signals to.
+  if (pid != getpid() && pid != -1 && pid != 0) {
+    errno = ESRCH;
+    return -1;
+  }
+
+  switch (sig) {

[binji, 2013/08/21 17:42:01]

is there danger in calling default handlers if the user has sigset them and then
kill'ed them? Why not just call whatever handlers you have available?

[Sam Clegg, 2013/08/22 03:32:45]

I'm not sure what you mean.

[binji, 2013/08/22 18:09:36]

I just mean, if we had a generic SignalHandler class, where the caller can
arbitrarily set handlers, is there any issue with just calling them here?

I suppose it is irrelevant unless you refactor the logic here to be more
generic--I'd prefer it, but I'm not going to hold up the CL for it.

+    case SIGWINCH:
+      //dbgprintf("kill SIGWINCH handler=%p\n", sigwinch_handler_);
+      if (sigwinch_handler_ != SIG_IGN)
+        sigwinch_handler_(SIGWINCH);
+      break;
+
+    case SIGUSR1:
+    case SIGUSR2:
+      break;
+
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+
+  return 0;
+}
+
+sighandler_t KernelProxy::signal(int signum, sighandler_t handler) {
+  return sigset(signum, handler);

[binji, 2013/08/21 17:42:01]

if sigset and signal are identical, I'd rather see only one implementation in
kernel_proxy, and have the each wrapper to the one implementation.

[Sam Clegg, 2013/08/22 03:32:45]

They are not quite identical.  But the differences seem pretty subtle.
sigset has an additional special value of SIG_HOLD, which we currently
don't support.

Done.

+}
+
+sighandler_t KernelProxy::sigset(int signum, sighandler_t handler) {
+  switch (signum) {
+    // Handled signals.
+    case SIGWINCH: {
+      sighandler_t old_value = sigwinch_handler_;

[binji, 2013/08/21 17:42:01]

I know you're only handling SIGWINCH, but you might as well handle this with an
array of signal handlers rather than a switch. Are there any signal types that
require special behavior?

[Sam Clegg, 2013/08/22 03:32:45]

KILL and STOP can never be handled, aside from that you are correctly.  I
was just lazy and didn't want to create the signal -> handler mapping datatype.

+      if (handler == SIG_DFL)
+        handler = SIG_IGN;
+      //dbgprintf("registering handler: %p\n", handler);

[binji, 2013/08/21 17:42:01]

remove

[Sam Clegg, 2013/08/22 03:32:45]

Done.

+      sigwinch_handler_ = handler;
+      return old_value;
+    }
+
+    // Known signals
+    case SIGHUP:
+    case SIGINT:
+    case SIGKILL:
+    case SIGPIPE:
+    case SIGPOLL:
+    case SIGPROF:
+    case SIGTERM:
+    case SIGCHLD:
+    case SIGURG:
+    case SIGFPE:
+    case SIGILL:
+    case SIGQUIT:
+    case SIGSEGV:
+    case SIGTRAP:
+      if (handler == SIG_DFL)
+        return SIG_DFL;
+      break;
+  }
+
+  errno = EINVAL;
+  return SIG_ERR;
+}
+
 #ifdef PROVIDES_SOCKET_API
 
 int KernelProxy::select(int nfds, fd_set* readfds, fd_set* writefds,
                         fd_set* exceptfds, struct timeval* timeout) {
   ScopedEventListener listener(new EventListener);
   std::vector<struct pollfd> fds;
 
   fd_set readout, writeout, exceptout;
 
   FD_ZERO(&readout);
@@ skipping 523 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io