native_client_sdk/src/tests/nacl_io_socket_test/socket_test.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <arpa/inet.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <netinet/in.h>
   9 #include <pthread.h>
  10 #include <sys/types.h>
  11 #include <sys/socket.h>
  12 #include <sys/stat.h>
  13
  14 #include <map>
  15 #include <string>
  16
  17 #include "echo_server.h"
  18 #include "gmock/gmock.h"
  19 #include "gtest/gtest.h"
  20 #include "nacl_io/kernel_intercept.h"
  21 #include "nacl_io/kernel_proxy.h"
  22 #include "nacl_io/ossocket.h"
  23 #include "nacl_io/ostypes.h"
  24 #include "ppapi/cpp/message_loop.h"
  25 #include "ppapi_simple/ps.h"
  26
  27 #ifdef PROVIDES_SOCKET_API
  28
  29 using namespace nacl_io;
  30 using namespace sdk_util;
  31
  32 #define LOCAL_HOST 0x7F000001
  33 #define PORT1 4006
  34 #define PORT2 4007
  35 #define ANY_PORT 0
  36
  37 namespace {
  38
  39 void IP4ToSockAddr(uint32_t ip, uint16_t port, struct sockaddr_in* addr) {
  40   memset(addr, 0, sizeof(*addr));
  41
  42   addr->sin_family = AF_INET;
  43   addr->sin_port = htons(port);
  44   addr->sin_addr.s_addr = htonl(ip);
  45 }
  46
  47 static int ki_fcntl_wrapper(int fd, int request, ...) {
  48   va_list ap;
  49   va_start(ap, request);
  50   int rtn = ki_fcntl(fd, request, ap);
  51   va_end(ap);
  52   return rtn;
  53 }
  54
  55 static void SetNonBlocking(int sock) {
  56   int flags = ki_fcntl_wrapper(sock, F_GETFL);
  57   ASSERT_NE(-1, flags);
  58   flags |= O_NONBLOCK;
  59   ASSERT_EQ(0, ki_fcntl_wrapper(sock, F_SETFL, flags));
  60   ASSERT_EQ(flags, ki_fcntl_wrapper(sock, F_GETFL));
  61 }
  62
  63 class SocketTest : public ::testing::Test {
  64  public:
  65   SocketTest() : sock1_(-1), sock2_(-1) {}
  66
  67   void TearDown() {
  68     if (sock1_ != -1)
  69       EXPECT_EQ(0, ki_close(sock1_));
  70     if (sock2_ != -1)
  71       EXPECT_EQ(0, ki_close(sock2_));
  72   }
  73
  74   int Bind(int fd, uint32_t ip, uint16_t port) {
  75     sockaddr_in addr;
  76     socklen_t addrlen = sizeof(addr);
  77
  78     IP4ToSockAddr(ip, port, &addr);
  79     int err = ki_bind(fd, (sockaddr*)&addr, addrlen);
  80
  81     if (err == -1)
  82       return errno;
  83     return 0;
  84   }
  85
  86  protected:
  87   int sock1_;
  88   int sock2_;
  89 };
  90
  91 class SocketTestUDP : public SocketTest {
  92  public:
  93   SocketTestUDP() {}
  94
  95   void SetUp() {
  96     sock1_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
  97     sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
  98
  99     EXPECT_GT(sock1_, -1);
 100     EXPECT_GT(sock2_, -1);
 101   }
 102 };
 103
 104 class SocketTestTCP : public SocketTest {
 105  public:
 106   SocketTestTCP() {}
 107
 108   void SetUp() {
 109     sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 110     sock2_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 111
 112     EXPECT_GT(sock1_, -1);
 113     EXPECT_GT(sock2_, -1);
 114   }
 115 };
 116
 117 class SocketTestWithServer : public ::testing::Test {
 118  public:
 119   SocketTestWithServer() : instance_(PSGetInstanceId()) {
 120     pthread_mutex_init(&ready_lock_, NULL);
 121     pthread_cond_init(&ready_cond_, NULL);
 122   }
 123
 124   void ServerThreadMain() {
 125     loop_.AttachToCurrentThread();
 126     pp::Instance instance(PSGetInstanceId());
 127     EchoServer server(&instance, PORT1, ServerLog, &ready_cond_, &ready_lock_);
 128     loop_.Run();
 129   }
 130
 131   static void* ServerThreadMainStatic(void* arg) {
 132     SocketTestWithServer* test = (SocketTestWithServer*)arg;
 133     test->ServerThreadMain();
 134     return NULL;
 135   }
 136
 137   void SetUp() {
 138     loop_ = pp::MessageLoop(&instance_);
 139     pthread_mutex_lock(&ready_lock_);
 140
 141     // Start an echo server on a background thread.
 142     pthread_create(&server_thread_, NULL, ServerThreadMainStatic, this);
 143
 144     // Wait for thread to signal that it is ready to accept connections.
 145     pthread_cond_wait(&ready_cond_, &ready_lock_);
 146     pthread_mutex_unlock(&ready_lock_);
 147
 148     sock_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 149     EXPECT_GT(sock_, -1);
 150   }
 151
 152   void TearDown() {
 153     // Stop the echo server and the background thread it runs on
 154     loop_.PostQuit(true);
 155     pthread_join(server_thread_, NULL);
 156     ASSERT_EQ(0, ki_close(sock_));
 157   }
 158
 159   static void ServerLog(const char* msg) {
 160     // Uncomment to see logs of echo server on stdout
 161     //printf("server: %s\n", msg);
 162   }
 163
 164  protected:
 165   int sock_;
 166   pp::MessageLoop loop_;
 167   pp::Instance instance_;
 168   pthread_cond_t ready_cond_;
 169   pthread_mutex_t ready_lock_;
 170   pthread_t server_thread_;
 171 };
 172
 173 }  // namespace
 174
 175 TEST(SocketTestSimple, Socket) {
 176   EXPECT_EQ(-1, ki_socket(AF_UNIX, SOCK_STREAM, 0));
 177   EXPECT_EQ(errno, EAFNOSUPPORT);
 178
 179   // We don't support RAW sockets
 180   EXPECT_EQ(-1, ki_socket(AF_INET, SOCK_RAW, IPPROTO_TCP));
 181   EXPECT_EQ(EPROTONOSUPPORT, errno);
 182
 183   // Invalid type
 184   EXPECT_EQ(-1, ki_socket(AF_INET, -1, 0));
 185   EXPECT_EQ(EINVAL, errno);
 186
 187   int sock1_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 188   EXPECT_NE(-1, sock1_);
 189
 190   int sock2_ = ki_socket(AF_INET6, SOCK_DGRAM, 0);
 191   EXPECT_NE(-1, sock2_);
 192
 193   int sock3 = ki_socket(AF_INET, SOCK_STREAM, 0);
 194   EXPECT_NE(-1, sock3);
 195
 196   int sock4 = ki_socket(AF_INET6, SOCK_STREAM, 0);
 197   EXPECT_NE(-1, sock4);
 198
 199   ki_close(sock1_);
 200   ki_close(sock2_);
 201   ki_close(sock3);
 202   ki_close(sock4);
 203 }
 204
 205 TEST_F(SocketTestUDP, Bind) {
 206   // Bind away.
 207   EXPECT_EQ(0, Bind(sock1_, LOCAL_HOST, PORT1));
 208
 209   // Invalid to rebind a socket.
 210   EXPECT_EQ(EINVAL, Bind(sock1_, LOCAL_HOST, PORT1));
 211
 212   // Addr in use.
 213   EXPECT_EQ(EADDRINUSE, Bind(sock2_, LOCAL_HOST, PORT1));
 214
 215   // Bind with a wildcard.
 216   EXPECT_EQ(0, Bind(sock2_, LOCAL_HOST, ANY_PORT));
 217
 218   // Invalid to rebind after wildcard
 219   EXPECT_EQ(EINVAL, Bind(sock2_, LOCAL_HOST, PORT1));
 220 }
 221
 222 TEST_F(SocketTestUDP, SendRcv) {
 223   char outbuf[256];
 224   char inbuf[512];
 225
 226   memset(outbuf, 1, sizeof(outbuf));
 227   memset(inbuf, 0, sizeof(inbuf));
 228
 229   EXPECT_EQ(0, Bind(sock1_, LOCAL_HOST, PORT1));
 230   EXPECT_EQ(0, Bind(sock2_, LOCAL_HOST, PORT2));
 231
 232   sockaddr_in addr;
 233   socklen_t addrlen = sizeof(addr);
 234   IP4ToSockAddr(LOCAL_HOST, PORT2, &addr);
 235
 236   int len1 =
 237      ki_sendto(sock1_, outbuf, sizeof(outbuf), 0, (sockaddr*) &addr, addrlen);
 238   EXPECT_EQ(sizeof(outbuf), len1);
 239
 240   // Ensure the buffers are different
 241   EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 242   memset(&addr, 0, sizeof(addr));
 243
 244   // Try to receive the previously sent packet
 245   int len2 =
 246     ki_recvfrom(sock2_, inbuf, sizeof(inbuf), 0, (sockaddr*) &addr, &addrlen);
 247   EXPECT_EQ(sizeof(outbuf), len2);
 248   EXPECT_EQ(sizeof(sockaddr_in), addrlen);
 249   EXPECT_EQ(PORT1, htons(addr.sin_port));
 250
 251   // Now they should be the same
 252   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 253 }
 254
 255 TEST_F(SocketTestUDP, SendRcvUnbound) {
 256   char outbuf[256];
 257   char inbuf[512];
 258
 259   memset(outbuf, 1, sizeof(outbuf));
 260   memset(inbuf, 0, sizeof(inbuf));
 261
 262   // Don't bind sock1_, this will automatically bind sock1_ to a random port
 263   // at the time of the first send.
 264   EXPECT_EQ(0, Bind(sock2_, LOCAL_HOST, PORT2));
 265
 266   sockaddr_in addr;
 267   sockaddr_in addr2;
 268   socklen_t addrlen = sizeof(addr2);
 269   IP4ToSockAddr(LOCAL_HOST, PORT2, &addr2);
 270
 271   // The first send hasn't occurred, so the socket is not yet bound.
 272   socklen_t out_addrlen = sizeof(addr);
 273   ASSERT_EQ(0, getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
 274   EXPECT_EQ(addrlen, out_addrlen);
 275   EXPECT_EQ(0, htonl(addr.sin_addr.s_addr));
 276   EXPECT_EQ(0, htons(addr.sin_port));
 277
 278   int len1 =
 279      sendto(sock1_, outbuf, sizeof(outbuf), 0, (sockaddr*) &addr2, addrlen);
 280   EXPECT_EQ(sizeof(outbuf), len1);
 281
 282   // After the first send, the socket should be bound; the port is set, but
 283   // the address is still 0.
 284   ASSERT_EQ(0, getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
 285   EXPECT_EQ(addrlen, out_addrlen);
 286   EXPECT_EQ(0, htonl(addr.sin_addr.s_addr));
 287   EXPECT_NE(0, htons(addr.sin_port));
 288
 289   // Ensure the buffers are different
 290   EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 291
 292   // Try to receive the previously sent packet
 293   int len2 =
 294     recvfrom(sock2_, inbuf, sizeof(inbuf), 0, (sockaddr*) &addr, &addrlen);
 295   EXPECT_EQ(sizeof(outbuf), len2);
 296   EXPECT_EQ(sizeof(sockaddr_in), addrlen);
 297   EXPECT_EQ(LOCAL_HOST, htonl(addr.sin_addr.s_addr));
 298   EXPECT_NE(0, htons(addr.sin_port));
 299
 300   // Now they should be the same
 301   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 302 }
 303
 304 const size_t kQueueSize = 65536 * 8;
 305 TEST_F(SocketTestUDP, FullFifo) {
 306   char outbuf[16 * 1024];
 307
 308   ASSERT_EQ(0, Bind(sock1_, LOCAL_HOST, PORT1));
 309   ASSERT_EQ(0, Bind(sock2_, LOCAL_HOST, PORT2));
 310
 311   sockaddr_in addr;
 312   socklen_t addrlen = sizeof(addr);
 313   IP4ToSockAddr(LOCAL_HOST, PORT2, &addr);
 314
 315   size_t total = 0;
 316   while (total < kQueueSize * 8) {
 317     int len = ki_sendto(sock1_, outbuf, sizeof(outbuf), MSG_DONTWAIT,
 318                      (sockaddr*) &addr, addrlen);
 319
 320     if (len <= 0) {
 321       EXPECT_EQ(-1, len);
 322       EXPECT_EQ(EWOULDBLOCK, errno);
 323       break;
 324     }
 325
 326     if (len >= 0) {
 327       EXPECT_EQ(sizeof(outbuf), len);
 328       total += len;
 329     }
 330   }
 331   EXPECT_GT(total, kQueueSize - 1);
 332   EXPECT_LT(total, kQueueSize * 8);
 333 }
 334
 335 TEST_F(SocketTestWithServer, TCPConnect) {
 336   char outbuf[256];
 337   char inbuf[512];
 338
 339   memset(outbuf, 1, sizeof(outbuf));
 340
 341   sockaddr_in addr;
 342   socklen_t addrlen = sizeof(addr);
 343
 344   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 345
 346   ASSERT_EQ(0, ki_connect(sock_, (sockaddr*) &addr, addrlen))
 347       << "Failed with " << errno << ": " << strerror(errno);
 348
 349   // Send two different messages to the echo server and verify the
 350   // response matches.
 351   strcpy(outbuf, "hello");
 352   memset(inbuf, 0, sizeof(inbuf));
 353   ASSERT_EQ(sizeof(outbuf), ki_write(sock_, outbuf, sizeof(outbuf)))
 354       << "socket write failed with: " << strerror(errno);
 355   ASSERT_EQ(sizeof(outbuf), ki_read(sock_, inbuf, sizeof(inbuf)));
 356   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 357
 358   strcpy(outbuf, "world");
 359   memset(inbuf, 0, sizeof(inbuf));
 360   ASSERT_EQ(sizeof(outbuf), ki_write(sock_, outbuf, sizeof(outbuf)));
 361   ASSERT_EQ(sizeof(outbuf), ki_read(sock_, inbuf, sizeof(inbuf)));
 362   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 363 }
 364
 365 TEST_F(SocketTestWithServer, TCPConnectNonBlock) {
 366   char outbuf[256];
 367   //char inbuf[512];
 368
 369   memset(outbuf, 1, sizeof(outbuf));
 370
 371   sockaddr_in addr;
 372   socklen_t addrlen = sizeof(addr);
 373
 374   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 375
 376   SetNonBlocking(sock_);
 377   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
 378   ASSERT_EQ(EINPROGRESS, errno)
 379      << "expected EINPROGRESS but got: " << strerror(errno);
 380   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
 381   ASSERT_EQ(EALREADY, errno);
 382
 383   // Wait for the socket connection to complete using poll()
 384   struct pollfd pollfd = { sock_, POLLIN|POLLOUT, 0 };
 385   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
 386   ASSERT_EQ(POLLOUT, pollfd.revents);
 387
 388   // Attempts to connect again should yield EISCONN
 389   ASSERT_EQ(-1, ki_connect(sock_, (sockaddr*) &addr, addrlen));
 390   ASSERT_EQ(EISCONN, errno);
 391
 392   // And SO_ERROR should be 0.
 393 }
 394
 395 TEST_F(SocketTest, Getsockopt) {
 396   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 397   EXPECT_GT(sock1_, -1);
 398   int socket_error = 99;
 399   socklen_t len = sizeof(socket_error);
 400
 401   // Test for valid option (SO_ERROR) which should be 0 when a socket
 402   // is first created.
 403   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_ERROR,
 404                              &socket_error, &len));
 405   ASSERT_EQ(0, socket_error);
 406   ASSERT_EQ(sizeof(socket_error), len);
 407
 408   // Test for an invalid option (-1)
 409   ASSERT_EQ(-1, ki_getsockopt(sock1_, SOL_SOCKET, -1, &socket_error, &len));
 410   ASSERT_EQ(ENOPROTOOPT, errno);
 411 }
 412
 413 TEST_F(SocketTest, Setsockopt) {
 414   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 415   EXPECT_GT(sock1_, -1);
 416
 417   // It should not be possible to set SO_ERROR using setsockopt.
 418   int socket_error = 10;
 419   socklen_t len = sizeof(socket_error);
 420   ASSERT_EQ(-1, ki_setsockopt(sock1_, SOL_SOCKET, SO_ERROR,
 421                               &socket_error, len));
 422   ASSERT_EQ(ENOPROTOOPT, errno);
 423 }
 424
 425 TEST_F(SocketTest, Sockopt_TCP_NODELAY) {
 426   int option = 0;
 427   socklen_t len = sizeof(option);
 428   // Getting and setting TCP_NODELAY on UDP socket should fail
 429   sock1_ = socket(AF_INET, SOCK_DGRAM, 0);
 430   ASSERT_EQ(-1, ki_setsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, len));
 431   ASSERT_EQ(ENOPROTOOPT, errno);
 432   ASSERT_EQ(-1, ki_getsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
 433   ASSERT_EQ(ENOPROTOOPT, errno);
 434
 435   // Getting and setting TCP_NODELAY on TCP socket should preserve value
 436   sock2_ = socket(AF_INET, SOCK_STREAM, 0);
 437   ASSERT_EQ(0, ki_getsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
 438   ASSERT_EQ(0, option);
 439   ASSERT_EQ(sizeof(option), len);
 440
 441   option = 1;
 442   len = sizeof(option);
 443   ASSERT_EQ(0, ki_setsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, len))
 444       << "Failed with " << errno << ": " << strerror(errno);
 445   ASSERT_EQ(1, option);
 446 }
 447
 448 TEST_F(SocketTest, Sockopt_KEEPALIVE) {
 449   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 450   ASSERT_GT(sock1_, -1);
 451   sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 452   ASSERT_GT(sock2_, -1);
 453
 454   int value = 0;
 455   socklen_t len = sizeof(value);
 456   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_KEEPALIVE, &value, &len));
 457   ASSERT_EQ(0, value);
 458   ASSERT_EQ(sizeof(int), len);
 459 }
 460
 461 // Disabled until we support SO_LINGER (i.e. syncronouse close()/shutdown())
 462 // TODO(sbc): re-enable once we fix http://crbug.com/312401
 463 TEST_F(SocketTest, DISABLED_Sockopt_LINGER) {
 464   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 465   ASSERT_GT(sock1_, -1);
 466   sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 467   ASSERT_GT(sock2_, -1);
 468
 469   struct linger linger = { 7, 8 };
 470   socklen_t len = sizeof(linger);
 471   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, &len));
 472   ASSERT_EQ(0, linger.l_onoff);
 473   ASSERT_EQ(0, linger.l_linger);
 474   ASSERT_EQ(sizeof(struct linger), len);
 475   ASSERT_EQ(0, ki_getsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, &len));
 476   ASSERT_EQ(0, linger.l_onoff);
 477   ASSERT_EQ(0, linger.l_linger);
 478   ASSERT_EQ(sizeof(struct linger), len);
 479
 480   linger.l_onoff = 1;
 481   linger.l_linger = 77;
 482   len = sizeof(linger);
 483   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, len));
 484   linger.l_onoff = 1;
 485   linger.l_linger = 88;
 486   ASSERT_EQ(0, ki_setsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, len));
 487
 488   len = sizeof(linger);
 489   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, &len));
 490   ASSERT_EQ(1, linger.l_onoff);
 491   ASSERT_EQ(77, linger.l_linger);
 492   ASSERT_EQ(sizeof(struct linger), len);
 493   ASSERT_EQ(0, ki_getsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, &len));
 494   ASSERT_EQ(1, linger.l_onoff);
 495   ASSERT_EQ(88, linger.l_linger);
 496   ASSERT_EQ(sizeof(struct linger), len);
 497 }
 498
 499 TEST_F(SocketTest, Sockopt_REUSEADDR) {
 500   int value = 1;
 501   socklen_t len = sizeof(value);
 502   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 503
 504   ASSERT_GT(sock1_, -1);
 505   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_REUSEADDR, &value, len));
 506
 507   value = 0;
 508   len = sizeof(value);
 509   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_REUSEADDR, &value, &len));
 510   ASSERT_EQ(1, value);
 511   ASSERT_EQ(sizeof(int), len);
 512 }
 513
 514 // The size of the data to send is deliberately chosen to be
 515 // larger than the TCP buffer in nacl_io.
 516 // TODO(sbc): use ioctl to discover the actual buffer size at
 517 // runtime.
 518 #define LARGE_SEND_BYTES (800 * 1024)
 519 TEST_F(SocketTestWithServer, LargeSend) {
 520   char* outbuf = (char*)malloc(LARGE_SEND_BYTES);
 521   char* inbuf = (char*)malloc(LARGE_SEND_BYTES);
 522   int bytes_sent = 0;
 523   int bytes_received = 0;
 524
 525   // Fill output buffer with ascending integers
 526   int* outbuf_int = (int*)outbuf;
 527   int* inbuf_int = (int*)inbuf;
 528   for (int i = 0; i < LARGE_SEND_BYTES/sizeof(int); i++) {
 529     outbuf_int[i] = i;
 530   }
 531
 532   sockaddr_in addr;
 533   socklen_t addrlen = sizeof(addr);
 534
 535   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 536   ASSERT_EQ(0, ki_connect(sock_, (sockaddr*) &addr, addrlen))
 537       << "Failed with " << errno << ": " << strerror(errno);
 538
 539   // Call send an recv until all bytes have been transfered.
 540   while (bytes_received < LARGE_SEND_BYTES) {
 541     if (bytes_sent < LARGE_SEND_BYTES) {
 542       int sent = ki_send(sock_, outbuf + bytes_sent,
 543                       LARGE_SEND_BYTES - bytes_sent, MSG_DONTWAIT);
 544       if (sent < 0)
 545         ASSERT_EQ(EWOULDBLOCK, errno) << "send failed: " << strerror(errno);
 546       else
 547         bytes_sent += sent;
 548     }
 549
 550     int received = ki_recv(sock_, inbuf + bytes_received,
 551                            LARGE_SEND_BYTES - bytes_received, MSG_DONTWAIT);
 552     if (received < 0)
 553       ASSERT_EQ(EWOULDBLOCK, errno) << "recv failed: " << strerror(errno);
 554     else
 555       bytes_received += received;
 556   }
 557
 558   // Make sure there is nothing else to recv at this point
 559   char dummy[10];
 560   ASSERT_EQ(-1, ki_recv(sock_, dummy, 10, MSG_DONTWAIT));
 561   ASSERT_EQ(EWOULDBLOCK, errno);
 562
 563   int errors = 0;
 564   for (int i = 0; i < LARGE_SEND_BYTES/4; i++) {
 565     if (inbuf_int[i] != outbuf_int[i]) {
 566       printf("%d: in=%d out=%d\n", i, inbuf_int[i], outbuf_int[i]);
 567       if (errors++ > 50)
 568         break;
 569     }
 570   }
 571
 572   for (int i = 0; i < LARGE_SEND_BYTES; i++) {
 573     ASSERT_EQ(outbuf[i], inbuf[i]) << "cmp failed at " << i;
 574   }
 575
 576   ASSERT_EQ(0, memcmp(inbuf, outbuf, LARGE_SEND_BYTES));
 577
 578   free(inbuf);
 579   free(outbuf);
 580 }
 581
 582 TEST_F(SocketTestUDP, Listen) {
 583   EXPECT_EQ(-1, ki_listen(sock1_, 10));
 584   EXPECT_EQ(errno, ENOTSUP);
 585 }
 586
 587 TEST_F(SocketTestTCP, Listen) {
 588   sockaddr_in addr;
 589   socklen_t addrlen = sizeof(addr);
 590   const char* client_greeting = "hello";
 591   const char* server_reply = "reply";
 592   const int greeting_len = strlen(client_greeting);
 593   const int reply_len = strlen(server_reply);
 594
 595   int server_sock = sock1_;
 596
 597   // Accept before listen should fail
 598   ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
 599
 600   // Listen should fail on unbound socket
 601   ASSERT_EQ(-1,  ki_listen(server_sock, 10));
 602
 603   // Bind and Listen
 604   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 605   ASSERT_EQ(0,  ki_listen(server_sock, 10))
 606     << "listen failed with: " << strerror(errno);
 607
 608   // Connect to listening socket, and send greeting
 609   int client_sock = sock2_;
 610   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 611   addrlen = sizeof(addr);
 612   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 613     << "Failed with " << errno << ": " << strerror(errno);
 614
 615   ASSERT_EQ(greeting_len, ki_send(client_sock, client_greeting,
 616                                   greeting_len, 0));
 617
 618   // Pass in addrlen that is larger than our actual address to make
 619   // sure that it is correctly set back to sizeof(sockaddr_in)
 620   addrlen = sizeof(addr) + 10;
 621   int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
 622   ASSERT_GT(new_socket, -1)
 623     << "accept failed with " << errno << ": " << strerror(errno);
 624
 625   // Verify addr and addrlen were set correctly
 626   ASSERT_EQ(addrlen, sizeof(sockaddr_in));
 627   sockaddr_in client_addr;
 628   ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr, &addrlen));
 629   ASSERT_EQ(client_addr.sin_family, addr.sin_family);
 630   ASSERT_EQ(client_addr.sin_port, addr.sin_port);
 631   ASSERT_EQ(client_addr.sin_addr.s_addr, addr.sin_addr.s_addr);
 632
 633   // Recv greeting from client and send reply
 634   char inbuf[512];
 635   ASSERT_EQ(greeting_len, ki_recv(new_socket, inbuf, sizeof(inbuf), 0));
 636   inbuf[greeting_len] = 0;
 637   ASSERT_STREQ(inbuf, client_greeting);
 638   ASSERT_EQ(reply_len, ki_send(new_socket, server_reply, reply_len, 0));
 639
 640   // Recv reply on client socket
 641   ASSERT_EQ(reply_len, ki_recv(client_sock, inbuf, sizeof(inbuf), 0));
 642   inbuf[reply_len] = 0;
 643   ASSERT_STREQ(inbuf, server_reply);
 644
 645   ASSERT_EQ(0, ki_close(new_socket));
 646 }
 647
 648 TEST_F(SocketTestTCP, ListenNonBlocking) {
 649   int server_sock = sock1_;
 650
 651   // Set non-blocking
 652   SetNonBlocking(server_sock);
 653
 654   // bind and listen
 655   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 656   ASSERT_EQ(0, ki_listen(server_sock, 10))
 657     << "listen failed with: " << strerror(errno);
 658
 659   // Accept should fail with EAGAIN since there is no incomming
 660   // connection.
 661   sockaddr_in addr;
 662   socklen_t addrlen = sizeof(addr);
 663   ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
 664   ASSERT_EQ(EAGAIN, errno);
 665
 666   // If we poll the listening socket it should also return
 667   // not readable to indicate that no connections are available
 668   // to accept.
 669   struct pollfd pollfd = { server_sock, POLLIN|POLLOUT, 0 };
 670   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 671
 672   // Connect to listening socket
 673   int client_sock = sock2_;
 674   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 675   addrlen = sizeof(addr);
 676   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 677     << "Failed with " << errno << ": " << strerror(errno);
 678
 679   // Not poll again but with an infintie timeout.
 680   pollfd.fd = server_sock;
 681   pollfd.events = POLLIN | POLLOUT;
 682   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
 683
 684   // Now non-blocking accept should return the new socket
 685   int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
 686   ASSERT_NE(-1, new_socket)
 687     << "accept failed with: " << strerror(errno);
 688   ASSERT_EQ(0, ki_close(new_socket));
 689
 690   // Accept calls should once again fail with EAGAIN
 691   ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
 692   ASSERT_EQ(EAGAIN, errno);
 693
 694   // As should polling the listening socket
 695   pollfd.fd = server_sock;
 696   pollfd.events = POLLIN | POLLOUT;
 697   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 698 }
 699
 700 TEST_F(SocketTestTCP, SendRecvAfterRemoteShutdown) {
 701   sockaddr_in addr;
 702   socklen_t addrlen = sizeof(addr);
 703
 704   int server_sock = sock1_;
 705   int client_sock = sock2_;
 706
 707   // bind and listen
 708   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 709   ASSERT_EQ(0, ki_listen(server_sock, 10))
 710     << "listen failed with: " << strerror(errno);
 711
 712   // connect to listening socket
 713   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 714   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 715     << "Failed with " << errno << ": " << strerror(errno);
 716
 717   addrlen = sizeof(addr);
 718   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
 719   ASSERT_NE(-1, new_sock);
 720
 721   const char* send_buf = "hello world";
 722   ASSERT_EQ(strlen(send_buf), ki_send(new_sock, send_buf, strlen(send_buf), 0));
 723
 724   // Recv first 10 bytes
 725   char buf[256];
 726   ASSERT_EQ(10, ki_recv(client_sock, buf, 10, 0));
 727
 728   // Close the new socket
 729   ASSERT_EQ(0, ki_close(new_sock));
 730
 731   // Recv remainder
 732   int bytes_remaining = strlen(send_buf) - 10;
 733   ASSERT_EQ(bytes_remaining, ki_recv(client_sock, buf, 256, 0));
 734
 735   // Attempt to read/write after remote shutdown, with no bytes remainging
 736   ASSERT_EQ(0, ki_recv(client_sock, buf, 10, 0));
 737   ASSERT_EQ(0, ki_recv(client_sock, buf, 10, 0));
 738   ASSERT_EQ(-1, ki_send(client_sock, buf, 10, 0));
 739   ASSERT_EQ(errno, EPIPE);
 740 }
 741
 742 TEST_F(SocketTestTCP, SendRecvAfterLocalShutdown) {
 743   sockaddr_in addr;
 744   socklen_t addrlen = sizeof(addr);
 745
 746   int server_sock = sock1_;
 747   int client_sock = sock2_;
 748
 749   // bind and listen
 750   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 751   ASSERT_EQ(0, ki_listen(server_sock, 10))
 752     << "listen failed with: " << strerror(errno);
 753
 754   // connect to listening socket
 755   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 756   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 757     << "Failed with " << errno << ": " << strerror(errno);
 758
 759   addrlen = sizeof(addr);
 760   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
 761   ASSERT_NE(-1, new_sock);
 762
 763   // Close the new socket
 764   ASSERT_EQ(0, ki_shutdown(client_sock, SHUT_RDWR));
 765
 766   // Attempt to read/write after shutdown
 767   char buffer[10];
 768   ASSERT_EQ(0, ki_recv(client_sock, buffer, sizeof(buffer), 0));
 769   ASSERT_EQ(-1, ki_send(client_sock, buffer, sizeof(buffer), 0));
 770   ASSERT_EQ(errno, EPIPE);
 771 }
 772
 773 #define SEND_BYTES (1024)
 774 TEST_F(SocketTestTCP, SendBufferedDataAfterShutdown) {
 775   sockaddr_in addr;
 776   socklen_t addrlen = sizeof(addr);
 777
 778   int server_sock = sock1_;
 779   int client_sock = sock2_;
 780
 781   // bind and listen
 782   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 783   ASSERT_EQ(0, ki_listen(server_sock, 10))
 784     << "listen failed with: " << strerror(errno);
 785
 786   // connect to listening socket
 787   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 788   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 789     << "Failed with " << errno << ": " << strerror(errno);
 790
 791   addrlen = sizeof(addr);
 792   int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
 793   ASSERT_NE(-1, new_sock);
 794
 795   // send a fairly large amount of data and immediately close
 796   // the socket.
 797   void* buffer = alloca(SEND_BYTES);
 798   ASSERT_EQ(SEND_BYTES, ki_send(client_sock, buffer, SEND_BYTES, 0));
 799   ASSERT_EQ(0, ki_close(client_sock));
 800
 801   // avoid double close of sock2_
 802   sock2_ = -1;
 803
 804   // Attempt to recv() all the sent data.  None should be lost.
 805   int remainder = SEND_BYTES;
 806   while (remainder > 0) {
 807     int rtn = ki_recv(new_sock, buffer, remainder, 0);
 808     ASSERT_GT(rtn, 0);
 809     remainder -= rtn;
 810   }
 811
 812   ASSERT_EQ(0, ki_close(new_sock));
 813 }
 814
 815 #endif  // PROVIDES_SOCKET_API