[NaCl SDK] nacl_io: implement set/getsockopt for TCP_NODELAY.

native_client_sdk/src/tests/nacl_io_socket_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 326 matching lines @@
   char inbuf[512];
 
   memset(outbuf, 1, sizeof(outbuf));
 
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
 
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 
   ASSERT_EQ(0, ki_connect(sock_, (sockaddr*) &addr, addrlen))
-      << "Failed with " << errno << ": " << strerror(errno) << "\n";
+      << "Failed with " << errno << ": " << strerror(errno);
 
   // Send two different messages to the echo server and verify the
   // response matches.
   strcpy(outbuf, "hello");
   memset(inbuf, 0, sizeof(inbuf));
   ASSERT_EQ(sizeof(outbuf), ki_write(sock_, outbuf, sizeof(outbuf)))
       << "socket write failed with: " << strerror(errno);
   ASSERT_EQ(sizeof(outbuf), ki_read(sock_, inbuf, sizeof(inbuf)));
   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 
@@ skipping 11 matching lines @@
   memset(outbuf, 1, sizeof(outbuf));
 
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
 
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 
   SetNonBlocking(sock_);
   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
   ASSERT_EQ(EINPROGRESS, errno)
-     << "expected EINPROGRESS but got: " << strerror(errno) << "\n";
+     << "expected EINPROGRESS but got: " << strerror(errno);

[binji, 2013/12/02 20:55:32]

nit: 4 space indent

[Sam Clegg, 2013/12/02 22:55:44]

Done.

   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
   ASSERT_EQ(EALREADY, errno);
 
   // Wait for the socket connection to complete using poll()
   struct pollfd pollfd = { sock_, POLLIN|POLLOUT, 0 };
   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
   ASSERT_EQ(POLLOUT, pollfd.revents);
 
   // Attempts to connect again should yield EISCONN
   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
@@ skipping 23 matching lines @@
 TEST_F(SocketTest, Setsockopt) {
   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
   EXPECT_GT(sock1_, -1);
 
   // It should not be possible to set SO_ERROR using setsockopt.
   int socket_error = 10;
   socklen_t len = sizeof(socket_error);
   ASSERT_EQ(-1, ki_setsockopt(sock1_, SOL_SOCKET, SO_ERROR,
                               &socket_error, len));
   ASSERT_EQ(ENOPROTOOPT, errno);
+}
 
+TEST_F(SocketTest, Sockopt_TCP_NODELAY) {
+  int option = 0;
+  socklen_t len = sizeof(option);
+  // Getting and setting TCP_NODELAY on UDP socket should fail
+  sock1_ = socket(AF_INET, SOCK_DGRAM, 0);
+  ASSERT_EQ(-1, ki_setsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, len));
+  ASSERT_EQ(ENOPROTOOPT, errno);
+  ASSERT_EQ(-1, ki_getsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
+  ASSERT_EQ(ENOPROTOOPT, errno);
+
+  // Getting and setting TCP_NODELAY on TCP socket should preserve value
+  sock2_ = socket(AF_INET, SOCK_STREAM, 0);

[binji, 2013/12/02 20:55:32]

this leaks the previous sock2_ ... do we care?

[Sam Clegg, 2013/12/02 22:55:44]

The previous one is sock1_, right?

[binji, 2013/12/02 22:58:43]

Sorry, I thought this was one of the tests that automatically created a new
socket. n/m

+  ASSERT_EQ(0, ki_getsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
+  ASSERT_EQ(0, option);
+  ASSERT_EQ(sizeof(option), len);
+
+  option = 1;
+  len = sizeof(option);
+  ASSERT_EQ(0, ki_setsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, len))
+    << "Failed with " << errno << ": " << strerror(errno);

[binji, 2013/12/02 20:55:32]

nit: 4 space indent

[Sam Clegg, 2013/12/02 22:55:44]

Done.

+  ASSERT_EQ(1, option);

[binji, 2013/12/02 20:55:32]

is there an easy way to test that this actually set the option on the PPAPI
socket?

Hm, looks like there's no PPB_TCPSocket.GetOption

[Sam Clegg, 2013/12/02 22:55:44]

Yeah.. ideally we would also actually test this by sending packets,
but I couldn't find a good way to do this, even just on linux.

 }
 
 TEST_F(SocketTest, Sockopt_KEEPALIVE) {
   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
   ASSERT_GT(sock1_, -1);
   sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
   ASSERT_GT(sock2_, -1);
 
   int value = 0;
   socklen_t len = sizeof(value);
@@ skipping 71 matching lines @@
   int* inbuf_int = (int*)inbuf;
   for (int i = 0; i < LARGE_SEND_BYTES/sizeof(int); i++) {
     outbuf_int[i] = i;
   }
 
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
 
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(sock_, (sockaddr*) &addr, addrlen))
-      << "Failed with " << errno << ": " << strerror(errno) << "\n";
+      << "Failed with " << errno << ": " << strerror(errno);
 
   // Call send an recv until all bytes have been transfered.
   while (bytes_received < LARGE_SEND_BYTES) {
     if (bytes_sent < LARGE_SEND_BYTES) {
       int sent = ki_send(sock_, outbuf + bytes_sent,
                       LARGE_SEND_BYTES - bytes_sent, MSG_DONTWAIT);
       if (sent < 0)
         ASSERT_EQ(EWOULDBLOCK, errno) << "send failed: " << strerror(errno);
       else
         bytes_sent += sent;
@@ skipping 55 matching lines @@
   // Bind and Listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0,  ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // Connect to listening socket, and send greeting
   int client_sock = sock2_;
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   addrlen = sizeof(addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
-    << "Failed with " << errno << ": " << strerror(errno) << "\n";
+    << "Failed with " << errno << ": " << strerror(errno);
 
   ASSERT_EQ(greeting_len, ki_send(client_sock, client_greeting,
                                   greeting_len, 0));
 
   // Pass in addrlen that is larger than our actual address to make
   // sure that it is correctly set back to sizeof(sockaddr_in)
   addrlen = sizeof(addr) + 10;
   int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_GT(new_socket, -1)
-    << "accept failed with " << errno << ": " << strerror(errno) << "\n";
+    << "accept failed with " << errno << ": " << strerror(errno);
 
   // Verify addr and addrlen were set correctly
   ASSERT_EQ(addrlen, sizeof(sockaddr_in));
   sockaddr_in client_addr;
   ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr, &addrlen));
   ASSERT_EQ(client_addr.sin_family, addr.sin_family);
   ASSERT_EQ(client_addr.sin_port, addr.sin_port);
   ASSERT_EQ(client_addr.sin_addr.s_addr, addr.sin_addr.s_addr);
 
   // Recv greeting from client and send reply
@@ skipping 33 matching lines @@
   // not readable to indicate that no connections are available
   // to accept.
   struct pollfd pollfd = { server_sock, POLLIN|POLLOUT, 0 };
   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 
   // Connect to listening socket
   int client_sock = sock2_;
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   addrlen = sizeof(addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
-    << "Failed with " << errno << ": " << strerror(errno) << "\n";
+    << "Failed with " << errno << ": " << strerror(errno);
 
   // Not poll again but with an infintie timeout.
   pollfd.fd = server_sock;
   pollfd.events = POLLIN | POLLOUT;
   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
 
   // Now non-blocking accept should return the new socket
   int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_socket)
-    << "accept failed with: " << strerror(errno) << "\n";
+    << "accept failed with: " << strerror(errno);
   ASSERT_EQ(0, ki_close(new_socket));
 
   // Accept calls should once again fail with EAGAIN
   ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
   ASSERT_EQ(EAGAIN, errno);
 
   // As should polling the listening socket
   pollfd.fd = server_sock;
   pollfd.events = POLLIN | POLLOUT;
   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 }
 
 TEST_F(SocketTestTCP, SendRecvAfterRemoteShutdown) {
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
 
   int server_sock = sock1_;
   int client_sock = sock2_;
 
   // bind and listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
-    << "Failed with " << errno << ": " << strerror(errno) << "\n";
+    << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   const char* send_buf = "hello world";
   ASSERT_EQ(strlen(send_buf), ki_send(new_sock, send_buf, strlen(send_buf), 0));
 
   // Recv first 10 bytes
   char buf[256];
@@ skipping 21 matching lines @@
   int client_sock = sock2_;
 
   // bind and listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
-    << "Failed with " << errno << ": " << strerror(errno) << "\n";
+    << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   // Close the new socket
   ASSERT_EQ(0, ki_shutdown(client_sock, SHUT_RDWR));
 
   // Attempt to read/write after shutdown
   char buffer[10];
@@ skipping 11 matching lines @@
   int client_sock = sock2_;
 
   // bind and listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
-    << "Failed with " << errno << ": " << strerror(errno) << "\n";
+    << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   // send a fairly large amount of data and immediately close
   // the socket.
   void* buffer = alloca(SEND_BYTES);
   ASSERT_EQ(SEND_BYTES, ki_send(client_sock, buffer, SEND_BYTES, 0));
   ASSERT_EQ(0, ki_close(client_sock));
 
   // avoid double close of sock2_
   sock2_ = -1;
 
   // Attempt to recv() all the sent data.  None should be lost.
   int remainder = SEND_BYTES;
   while (remainder > 0) {
     int rtn = ki_recv(new_sock, buffer, remainder, 0);
     ASSERT_GT(rtn, 0);
     remainder -= rtn;
   }
 
   ASSERT_EQ(0, ki_close(new_sock));
 }
 
 #endif  // PROVIDES_SOCKET_API