nacl_io: Add SOCK_DGRAM support to socketpair()

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 238 matching lines @@
 }
 
 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_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_LT(ki_socketpair(AF_UNIX, SOCK_RAW, 0, sv), 0);
   EXPECT_EQ(errno, EPROTOTYPE);
   EXPECT_LT(ki_socketpair(AF_MAX, SOCK_STREAM, 0, sv), 0);
   EXPECT_EQ(errno, EAFNOSUPPORT);
 }
 
 class UnixSocketTest : public ::testing::Test {
  public:
   UnixSocketTest() { sv_[0] = sv_[1] = -1; }
 
   void SetUp() {
@@ skipping 19 matching lines @@
   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]);
+
+  errno = 0;
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_));
+  EXPECT_EQ(0, errno);
+  EXPECT_LE(0, sv_[0]);
+  EXPECT_LE(0, sv_[1]);
 }
 
-TEST_F(UnixSocketTest, SendRecv) {
+TEST_F(UnixSocketTest, SendRecvStream) {
   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.
+  // A reader should block after trying 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) {
+TEST_F(UnixSocketTest, RecvNonBlockingStream) {
   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_F(UnixSocketTest, SendRecvDgram) {
+  char outbuf1[256], outbuf2[128];

[Sam Clegg, 2016/02/08 17:30:55]

nit: put these one on each line

[cernekee, 2016/02/08 22:53:29]

Done.

+  char inbuf[512];
+
+  memset(outbuf1, 0xA4, sizeof(outbuf1));
+  memset(outbuf2, 0xA5, sizeof(outbuf2));
+  memset(inbuf, 0x3C, sizeof(inbuf));
+
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_));
+
+  int len1 = ki_send(sv_[0], outbuf1, sizeof(outbuf1), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf1), len1);
+
+  // The buffers should be different.
+  EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+
+  int len2 = ki_send(sv_[0], outbuf2, sizeof(outbuf2), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf2), len2);
+
+  // Make sure the datagram boundaries are respected.
+  len1 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf1), len1);
+  EXPECT_EQ(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+
+  len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf2), len2);
+  EXPECT_EQ(0, memcmp(outbuf2, inbuf, sizeof(outbuf2)));
+
+  // A reader should block after trying to read at this point.
+  EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT));
+  EXPECT_EQ(EAGAIN, errno);
+
+  // Send a datagram larger than the recv buffer, and check for overflow.
+  memset(inbuf, 0x3C, sizeof(inbuf));
+  EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+  len1 = ki_send(sv_[1], outbuf1, sizeof(outbuf1), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf1), len1);
+
+  len2 = ki_recv(sv_[0], inbuf, 16, /* flags */ 0);
+  EXPECT_EQ(16, len2);
+  EXPECT_EQ(0, memcmp(outbuf1, inbuf, 16));
+  EXPECT_EQ(0x3C, inbuf[16]);
+
+  // Send data back in the opposite direction, and make sure the call
+  // blocks when there is no more data to read.

[Sam Clegg, 2016/02/08 17:30:55]

Didn't you already send data in the opposite direction just above?  Maybe just
attempt to recv again here.  That would also verify that the remainder of the
packet (above the 16 bytes you received) was discarded.

[cernekee, 2016/02/08 22:53:29]

Done.

+  memset(inbuf, 0x3C, sizeof(inbuf));
+  EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+  len1 = ki_send(sv_[1], outbuf1, sizeof(outbuf1), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf1), len1);
+
+  EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+
+  len2 = ki_recv(sv_[0], inbuf, sizeof(inbuf), /* flags */ 0);
+  EXPECT_EQ(sizeof(outbuf1), len2);
+
+  EXPECT_EQ(0, memcmp(outbuf1, inbuf, sizeof(outbuf1)));
+  EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT));
+  EXPECT_EQ(EAGAIN, errno);
+}
+
+TEST_F(UnixSocketTest, RecvNonBlockingDgram) {
+  char buf[128];
+
+  EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 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);
   EXPECT_EQ(network_bytes[3], 0x11);
 }
@@ skipping 255 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