[NaCl SDK] nacl_io: Add support for basic socketpairs.

native_client_sdk/src/tests/nacl_io_test/socket_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 <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <pthread.h>
 #include <sys/types.h>
@@ skipping 225 matching lines @@
   EXPECT_EQ(errno, ENOTSOCK);
 }
 
 TEST_F(SocketTest, Shutdown) {
   EXPECT_LT(ki_shutdown(-1, SHUT_RDWR), 0);
   EXPECT_EQ(errno, EBADF);
   EXPECT_LT(ki_shutdown(0, SHUT_RDWR), 0);
   EXPECT_EQ(errno, ENOTSOCK);
 }
 
-TEST_F(SocketTest, Socket) {
-  EXPECT_LT(ki_socket(AF_UNIX, SOCK_STREAM, 0), 0);
-  EXPECT_EQ(errno, EAFNOSUPPORT);
+TEST_F(SocketTest, SocketInetRawUnsupported) {
   EXPECT_LT(ki_socket(AF_INET, SOCK_RAW, 0), 0);
   EXPECT_EQ(errno, EPROTONOSUPPORT);
 }
 
-TEST_F(SocketTest, Socketpair) {
+TEST_F(SocketTest, SocketpairUnsupported) {
   int sv[2];
   EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0);
   EXPECT_EQ(errno, EFAULT);
-  EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
+  EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0);
+  EXPECT_EQ(errno, EOPNOTSUPP);
+  EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0);
+  EXPECT_EQ(errno, EOPNOTSUPP);
+  EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv), 0);
+  EXPECT_EQ(errno, EPROTOTYPE);
+  EXPECT_LT(ki_socketpair(AF_MAX, SOCK_STREAM, 0, sv), 0);
   EXPECT_EQ(errno, EAFNOSUPPORT);
-  EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0);
-  EXPECT_EQ(errno, EPROTONOSUPPORT);
-  EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0);
-  EXPECT_EQ(errno, EPROTONOSUPPORT);
+}
+
+class UnixSocketTest : public ::testing::Test {
+ public:
+  UnixSocketTest() { sv_[0] = sv_[1] = -1; }
+
+  void SetUp() {
+    ASSERT_EQ(0, ki_push_state_for_testing());
+    ASSERT_EQ(0, ki_init(&kp_));
+  }
+
+  void TearDown() {
+    if (sv_[0] != -1)
+      EXPECT_EQ(0, ki_close(sv_[0]));
+    if (sv_[1] != -1)
+      EXPECT_EQ(0, ki_close(sv_[1]));
+    ki_uninit();
+  }
+
+ protected:
+  KernelProxy kp_;
+
+  int sv_[2];
+};
+
+TEST_F(UnixSocketTest, Socket) {
+  EXPECT_EQ(-1, ki_socket(AF_UNIX, SOCK_STREAM, 0));
+  EXPECT_EQ(EAFNOSUPPORT, errno);
+}
+
+TEST_F(UnixSocketTest, Socketpair) {
+  errno = 0;
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_));
+  EXPECT_EQ(0, errno);
+  EXPECT_LE(0, sv_[0]);
+  EXPECT_LE(0, sv_[1]);
+}
+
+TEST_F(UnixSocketTest, SendRecv) {
+  char outbuf[256];
+  char inbuf[512];
+
+  memset(outbuf, 0xA5, sizeof(outbuf));
+  memset(inbuf, 0x3C, sizeof(inbuf));
+
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_));
+
+  int len1 = ki_send(sv_[0], outbuf, sizeof(outbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf), len1);
+
+  // The buffers should be different.
+  EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
+
+  int len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf), len2);
+
+  EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
+
+  // A reader should block after to read at this point.
+  EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT));
+  EXPECT_EQ(EAGAIN, errno);
+
+  // Send data back in the opposite direction.
+  memset(inbuf, 0x3C, sizeof(inbuf));
+  EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
+  len1 = ki_send(sv_[1], outbuf, sizeof(outbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf), len1);
+
+  EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
+
+  len2 = ki_recv(sv_[0], inbuf, sizeof(inbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf), len2);
+
+  EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
+  EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT));
+  EXPECT_EQ(EAGAIN, errno);
+}
+
+TEST_F(UnixSocketTest, RecvNonBlocking) {
+  char buf[128];
+
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_));
+
+  EXPECT_EQ(-1, ki_recv(sv_[0], buf, sizeof(buf), MSG_DONTWAIT));
+  EXPECT_EQ(EAGAIN, errno);
+
+  struct pollfd pollfd = {sv_[0], POLLIN | POLLOUT, 0};
+  EXPECT_EQ(1, ki_poll(&pollfd, 1, 0));
+  EXPECT_EQ(POLLOUT, pollfd.revents & POLLOUT);
+  EXPECT_NE(POLLIN, pollfd.revents & POLLIN);
 }
 
 TEST(SocketUtilityFunctions, Htonl) {
   uint32_t host_long = 0x44332211;
   uint32_t network_long = htonl(host_long);
   uint8_t network_bytes[4];
   memcpy(network_bytes, &network_long, 4);
   EXPECT_EQ(network_bytes[0], 0x44);
   EXPECT_EQ(network_bytes[1], 0x33);
   EXPECT_EQ(network_bytes[2], 0x22);
@@ skipping 257 matching lines @@
 
 TEST(SocketUtilityFunctions, Ntohl) {
   uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 };
   uint32_t network_long;
   memcpy(&network_long, network_bytes, 4);
   uint32_t host_long = ntohl(network_long);
   EXPECT_EQ(host_long, 0x44332211);
 }
 
 #endif  // PROVIDES_SOCKETPAIR_API