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

native_client_sdk/src/tests/nacl_io_test/syscalls_test.cc

+// Copyright 2013 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 <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "nacl_io/kernel_intercept.h"
+#include "nacl_io/kernel_proxy.h"
+
+using namespace nacl_io;
+using namespace sdk_util;
+
+namespace {
+class TestsWithKI : public ::testing::Test {
+ public:
+  TestsWithKI() {}
+
+  void SetUp() {
+    ki_init(&kp_);
+  }
+
+  void TearDown() {
+    ki_uninit();
+  }
+
+ protected:
+  KernelProxy kp_;
+};
+
+class SyscallsKill : public TestsWithKI {
+};
+
+class SyscallsSignal : public TestsWithKI {
+};
+
+TEST_F(SyscallsKill, KillSignals) {
+  // SIGSEGV can't be sent via kill(2)
+  ASSERT_EQ(-1, kill(0, SIGSEGV)) << "kill(SEGV) failed to return an error";
+  ASSERT_EQ(EINVAL, errno) << "kill(SEGV) failedd to set errno to EINVAL";
+
+  // Our implemenation should understand SIGWINCH
+  ASSERT_EQ(0, kill(0, SIGWINCH)) << "kill(SIGWINCH) failed: " << errno;
+
+  // And USR1/USR2
+  ASSERT_EQ(0, kill(0, SIGUSR1)) << "kill(SIGUSR1) failed: " << errno;
+  ASSERT_EQ(0, kill(0, SIGUSR2)) << "kill(SIGUSR2) failed: " << errno;
+}
+
+TEST_F(SyscallsKill, KillPIDValues) {
+  // Any PID other than 0, -1 and getpid() should yield ESRCH
+  // since there is only one valid process under NaCl
+  int mypid = getpid();
+  ASSERT_EQ(0, kill(0, SIGWINCH));
+  ASSERT_EQ(0, kill(-1, SIGWINCH));
+  ASSERT_EQ(0, kill(mypid, SIGWINCH));
+
+  // Don't use mypid + 1 since getpid() actually returns -1
+  // when the IRT interface is missing (e.g. within chrome),
+  // and 0 is always a valid PID when calling kill().
+  int invalid_pid = mypid + 10;
+  ASSERT_EQ(-1, kill(invalid_pid, SIGWINCH));
+  ASSERT_EQ(ESRCH, errno);
+}
+
+static bool g_handler_called = false;
+void sighandler(int) {
+  g_handler_called = true;
+}
+
+TEST_F(SyscallsSignal, SignalValues) {
+  ASSERT_EQ(signal(SIGSEGV, sighandler), SIG_ERR)
+      << "registering SEGV handler didn't fail";
+  ASSERT_EQ(errno, EINVAL) << "signal(SEGV) failed to set errno to EINVAL";
+
+  ASSERT_EQ(signal(-1, sighandler), SIG_ERR)
+      << "registering handler for invalid signal didn't fail";
+  ASSERT_EQ(errno, EINVAL) << "signal(-1) failed to set errno to EINVAL";
+}
+
+TEST_F(SyscallsSignal, HandlerValues) {
+  // Unsupported signal.
+  ASSERT_NE(SIG_ERR, signal(SIGSEGV, SIG_DFL));
+  ASSERT_EQ(SIG_ERR, signal(SIGSEGV, SIG_IGN));
+  ASSERT_EQ(SIG_ERR, signal(SIGSEGV, sighandler));
+
+  // Supported signal.
+  ASSERT_NE(SIG_ERR, signal(SIGWINCH, SIG_DFL));
+  ASSERT_NE(SIG_ERR, signal(SIGWINCH, SIG_IGN));
+  ASSERT_NE(SIG_ERR, signal(SIGWINCH, sighandler));
+}
+
+TEST_F(SyscallsSignal, Sigwinch) {
+  g_handler_called = false;
+
+  // Register WINCH handler
+  sighandler_t newsig = sighandler;
+  sighandler_t oldsig = signal(SIGWINCH, newsig);
+  ASSERT_NE(oldsig, SIG_ERR);
+
+  // Send signal.
+  kill(0, SIGWINCH);
+
+  // Verify that handler was called
+  EXPECT_TRUE(g_handler_called);
+
+  // Restore existing handler
+  oldsig = signal(SIGWINCH, oldsig);
+
+  // Verify the our newsig was returned as previous handler
+  ASSERT_EQ(oldsig, newsig);
+}
+
+}  // namespace