src/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, ki_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      ki_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, ki_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     ki_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(SocketTestTCP, TCPConnectFails) {
 396   sockaddr_in addr;
 397   socklen_t addrlen = sizeof(addr);
 398
 399   // 10 is an unassigned well-known port, nothing should be bound to it.
 400   IP4ToSockAddr(LOCAL_HOST, 10, &addr);
 401   ASSERT_EQ(-1, ki_connect(sock1_, (sockaddr*) &addr, addrlen));
 402   ASSERT_EQ(ECONNREFUSED, errno);
 403 }
 404
 405 TEST_F(SocketTest, Getsockopt) {
 406   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 407   EXPECT_GT(sock1_, -1);
 408   int socket_error = 99;
 409   socklen_t len = sizeof(socket_error);
 410
 411   // Test for valid option (SO_ERROR) which should be 0 when a socket
 412   // is first created.
 413   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_ERROR,
 414                              &socket_error, &len));
 415   ASSERT_EQ(0, socket_error);
 416   ASSERT_EQ(sizeof(socket_error), len);
 417
 418   // Test for an invalid option (-1)
 419   ASSERT_EQ(-1, ki_getsockopt(sock1_, SOL_SOCKET, -1, &socket_error, &len));
 420   ASSERT_EQ(ENOPROTOOPT, errno);
 421 }
 422
 423 TEST_F(SocketTest, Setsockopt) {
 424   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 425   EXPECT_GT(sock1_, -1);
 426
 427   // It should not be possible to set SO_ERROR using setsockopt.
 428   int socket_error = 10;
 429   socklen_t len = sizeof(socket_error);
 430   ASSERT_EQ(-1, ki_setsockopt(sock1_, SOL_SOCKET, SO_ERROR,
 431                               &socket_error, len));
 432   ASSERT_EQ(ENOPROTOOPT, errno);
 433 }
 434
 435 TEST_F(SocketTest, Sockopt_TCP_NODELAY) {
 436   int option = 0;
 437   socklen_t len = sizeof(option);
 438   // Getting and setting TCP_NODELAY on UDP socket should fail
 439   sock1_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 440   ASSERT_EQ(-1, ki_setsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, len));
 441   ASSERT_EQ(ENOPROTOOPT, errno);
 442   ASSERT_EQ(-1, ki_getsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
 443   ASSERT_EQ(ENOPROTOOPT, errno);
 444
 445   // Getting and setting TCP_NODELAY on TCP socket should preserve value
 446   sock2_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 447   ASSERT_EQ(0, ki_getsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
 448   ASSERT_EQ(0, option);
 449   ASSERT_EQ(sizeof(option), len);
 450
 451   option = 1;
 452   len = sizeof(option);
 453   ASSERT_EQ(0, ki_setsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, len))
 454       << "Failed with " << errno << ": " << strerror(errno);
 455   ASSERT_EQ(1, option);
 456 }
 457
 458 TEST_F(SocketTest, Sockopt_KEEPALIVE) {
 459   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 460   ASSERT_GT(sock1_, -1);
 461   sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 462   ASSERT_GT(sock2_, -1);
 463
 464   int value = 0;
 465   socklen_t len = sizeof(value);
 466   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_KEEPALIVE, &value, &len));
 467   ASSERT_EQ(0, value);
 468   ASSERT_EQ(sizeof(int), len);
 469 }
 470
 471 // Disabled until we support SO_LINGER (i.e. syncronouse close()/shutdown())
 472 // TODO(sbc): re-enable once we fix http://crbug.com/312401
 473 TEST_F(SocketTest, DISABLED_Sockopt_LINGER) {
 474   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 475   ASSERT_GT(sock1_, -1);
 476   sock2_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
 477   ASSERT_GT(sock2_, -1);
 478
 479   struct linger linger = { 7, 8 };
 480   socklen_t len = sizeof(linger);
 481   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, &len));
 482   ASSERT_EQ(0, linger.l_onoff);
 483   ASSERT_EQ(0, linger.l_linger);
 484   ASSERT_EQ(sizeof(struct linger), len);
 485   ASSERT_EQ(0, ki_getsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, &len));
 486   ASSERT_EQ(0, linger.l_onoff);
 487   ASSERT_EQ(0, linger.l_linger);
 488   ASSERT_EQ(sizeof(struct linger), len);
 489
 490   linger.l_onoff = 1;
 491   linger.l_linger = 77;
 492   len = sizeof(linger);
 493   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, len));
 494   linger.l_onoff = 1;
 495   linger.l_linger = 88;
 496   ASSERT_EQ(0, ki_setsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, len));
 497
 498   len = sizeof(linger);
 499   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_LINGER, &linger, &len));
 500   ASSERT_EQ(1, linger.l_onoff);
 501   ASSERT_EQ(77, linger.l_linger);
 502   ASSERT_EQ(sizeof(struct linger), len);
 503   ASSERT_EQ(0, ki_getsockopt(sock2_, SOL_SOCKET, SO_LINGER, &linger, &len));
 504   ASSERT_EQ(1, linger.l_onoff);
 505   ASSERT_EQ(88, linger.l_linger);
 506   ASSERT_EQ(sizeof(struct linger), len);
 507 }
 508
 509 TEST_F(SocketTest, Sockopt_REUSEADDR) {
 510   int value = 1;
 511   socklen_t len = sizeof(value);
 512   sock1_ = ki_socket(AF_INET, SOCK_STREAM, 0);
 513
 514   ASSERT_GT(sock1_, -1);
 515   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_REUSEADDR, &value, len));
 516
 517   value = 0;
 518   len = sizeof(value);
 519   ASSERT_EQ(0, ki_getsockopt(sock1_, SOL_SOCKET, SO_REUSEADDR, &value, &len));
 520   ASSERT_EQ(1, value);
 521   ASSERT_EQ(sizeof(int), len);
 522 }
 523
 524 // The size of the data to send is deliberately chosen to be
 525 // larger than the TCP buffer in nacl_io.
 526 // TODO(sbc): use ioctl to discover the actual buffer size at
 527 // runtime.
 528 #define LARGE_SEND_BYTES (800 * 1024)
 529 TEST_F(SocketTestWithServer, LargeSend) {
 530   char* outbuf = (char*)malloc(LARGE_SEND_BYTES);
 531   char* inbuf = (char*)malloc(LARGE_SEND_BYTES);
 532   int bytes_sent = 0;
 533   int bytes_received = 0;
 534
 535   // Fill output buffer with ascending integers
 536   int* outbuf_int = (int*)outbuf;
 537   int* inbuf_int = (int*)inbuf;
 538   for (int i = 0; i < LARGE_SEND_BYTES/sizeof(int); i++) {
 539     outbuf_int[i] = i;
 540   }
 541
 542   sockaddr_in addr;
 543   socklen_t addrlen = sizeof(addr);
 544
 545   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 546   ASSERT_EQ(0, ki_connect(sock_, (sockaddr*) &addr, addrlen))
 547       << "Failed with " << errno << ": " << strerror(errno);
 548
 549   // Call send an recv until all bytes have been transfered.
 550   while (bytes_received < LARGE_SEND_BYTES) {
 551     if (bytes_sent < LARGE_SEND_BYTES) {
 552       int sent = ki_send(sock_, outbuf + bytes_sent,
 553                       LARGE_SEND_BYTES - bytes_sent, MSG_DONTWAIT);
 554       if (sent < 0)
 555         ASSERT_EQ(EWOULDBLOCK, errno) << "send failed: " << strerror(errno);
 556       else
 557         bytes_sent += sent;
 558     }
 559
 560     int received = ki_recv(sock_, inbuf + bytes_received,
 561                            LARGE_SEND_BYTES - bytes_received, MSG_DONTWAIT);
 562     if (received < 0)
 563       ASSERT_EQ(EWOULDBLOCK, errno) << "recv failed: " << strerror(errno);
 564     else
 565       bytes_received += received;
 566   }
 567
 568   // Make sure there is nothing else to recv at this point
 569   char dummy[10];
 570   ASSERT_EQ(-1, ki_recv(sock_, dummy, 10, MSG_DONTWAIT));
 571   ASSERT_EQ(EWOULDBLOCK, errno);
 572
 573   int errors = 0;
 574   for (int i = 0; i < LARGE_SEND_BYTES/4; i++) {
 575     if (inbuf_int[i] != outbuf_int[i]) {
 576       printf("%d: in=%d out=%d\n", i, inbuf_int[i], outbuf_int[i]);
 577       if (errors++ > 50)
 578         break;
 579     }
 580   }
 581
 582   for (int i = 0; i < LARGE_SEND_BYTES; i++) {
 583     ASSERT_EQ(outbuf[i], inbuf[i]) << "cmp failed at " << i;
 584   }
 585
 586   ASSERT_EQ(0, memcmp(inbuf, outbuf, LARGE_SEND_BYTES));
 587
 588   free(inbuf);
 589   free(outbuf);
 590 }
 591
 592 TEST_F(SocketTestUDP, Listen) {
 593   EXPECT_EQ(-1, ki_listen(sock1_, 10));
 594   EXPECT_EQ(errno, ENOTSUP);
 595 }
 596
 597 TEST_F(SocketTestUDP, Sockopt_BUFSIZE) {
 598   int option = 1024*1024;
 599   socklen_t len = sizeof(option);
 600
 601   ASSERT_EQ(0, Bind(sock1_, LOCAL_HOST, ANY_PORT));
 602
 603   // Modify the test to verify the change by calling getsockopt
 604   // once UDPInterface supports GetOption() call
 605   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_RCVBUF, &option, len))
 606     << "failed with: " << strerror(errno);
 607   ASSERT_EQ(0, ki_setsockopt(sock1_, SOL_SOCKET, SO_SNDBUF, &option, len))
 608     << "failed with: " << strerror(errno);
 609 }
 610
 611 TEST_F(SocketTestTCP, Listen) {
 612   sockaddr_in addr;
 613   socklen_t addrlen = sizeof(addr);
 614   const char* client_greeting = "hello";
 615   const char* server_reply = "reply";
 616   const int greeting_len = strlen(client_greeting);
 617   const int reply_len = strlen(server_reply);
 618
 619   int server_sock = sock1_;
 620
 621   // Accept before listen should fail
 622   ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
 623
 624   // Listen should fail on unbound socket
 625   ASSERT_EQ(-1,  ki_listen(server_sock, 10));
 626
 627   // Bind and Listen
 628   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 629   ASSERT_EQ(0,  ki_listen(server_sock, 10))
 630     << "listen failed with: " << strerror(errno);
 631
 632   // Connect to listening socket, and send greeting
 633   int client_sock = sock2_;
 634   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 635   addrlen = sizeof(addr);
 636   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 637     << "Failed with " << errno << ": " << strerror(errno);
 638
 639   ASSERT_EQ(greeting_len, ki_send(client_sock, client_greeting,
 640                                   greeting_len, 0));
 641
 642   // Pass in addrlen that is larger than our actual address to make
 643   // sure that it is correctly set back to sizeof(sockaddr_in)
 644   sockaddr_in client_addr[2];
 645   sockaddr_in cmp_addr;
 646   memset(&client_addr[0], 0, sizeof(client_addr[0]));
 647   memset(&client_addr[1], 0xab, sizeof(client_addr[1]));
 648   memset(&cmp_addr, 0xab, sizeof(cmp_addr));
 649   addrlen = sizeof(client_addr[0]) + 10;
 650   int new_socket = ki_accept(server_sock, (sockaddr*)&client_addr[0],
 651                              &addrlen);
 652   ASSERT_GT(new_socket, -1)
 653     << "accept failed with " << errno << ": " << strerror(errno);
 654   ASSERT_EQ(addrlen, sizeof(sockaddr_in));
 655   // Check that client_addr[1] and cmp_addr are the same (not overwritten).
 656   ASSERT_EQ(0, memcmp(&client_addr[1], &cmp_addr, sizeof(cmp_addr)));
 657   ASSERT_EQ(0xabab, client_addr[1].sin_port);
 658
 659   // Verify addr and addrlen were set correctly
 660   ASSERT_EQ(addrlen, sizeof(sockaddr_in));
 661   ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr[1],
 662                               &addrlen));
 663   ASSERT_EQ(client_addr[1].sin_family, client_addr[0].sin_family);
 664   ASSERT_EQ(client_addr[1].sin_port, client_addr[0].sin_port);
 665   ASSERT_EQ(client_addr[1].sin_addr.s_addr, client_addr[0].sin_addr.s_addr);
 666
 667   // Try a call where the supplied len is smaller than the expected length.
 668   // The API should only write up to that amount, but should return the
 669   // expected length.
 670   sockaddr_in client_addr2;
 671   memset(&client_addr2, 0, sizeof(client_addr2));
 672   socklen_t truncated_len = sizeof(client_addr2.sin_family);
 673   ASSERT_GT(sizeof(sockaddr_in), truncated_len);
 674   ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr2,
 675                               &truncated_len));
 676   ASSERT_EQ(sizeof(sockaddr_in), truncated_len);
 677   ASSERT_EQ(client_addr2.sin_family, client_addr[0].sin_family);
 678   ASSERT_EQ(client_addr2.sin_port, 0);
 679   ASSERT_EQ(client_addr2.sin_addr.s_addr, 0);
 680
 681   // Recv greeting from client and send reply
 682   char inbuf[512];
 683   ASSERT_EQ(greeting_len, ki_recv(new_socket, inbuf, sizeof(inbuf), 0));
 684   inbuf[greeting_len] = 0;
 685   ASSERT_STREQ(inbuf, client_greeting);
 686   ASSERT_EQ(reply_len, ki_send(new_socket, server_reply, reply_len, 0));
 687
 688   // Recv reply on client socket
 689   ASSERT_EQ(reply_len, ki_recv(client_sock, inbuf, sizeof(inbuf), 0));
 690   inbuf[reply_len] = 0;
 691   ASSERT_STREQ(inbuf, server_reply);
 692
 693   ASSERT_EQ(0, ki_close(new_socket));
 694 }
 695
 696 TEST_F(SocketTestTCP, BindAndGetSockName) {
 697   sockaddr_in addr;
 698   socklen_t addrlen = sizeof(addr);
 699
 700   // Bind
 701   ASSERT_EQ(0, Bind(sock1_, LOCAL_HOST, 0));
 702   EXPECT_EQ(0, ki_getsockname(sock1_, (struct sockaddr*)&addr, &addrlen));
 703   EXPECT_NE(0, addr.sin_port);
 704 }
 705
 706 TEST_F(SocketTestTCP, ListenNonBlocking) {
 707   int server_sock = sock1_;
 708
 709   // Set non-blocking
 710   SetNonBlocking(server_sock);
 711
 712   // bind and listen
 713   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 714   ASSERT_EQ(0, ki_listen(server_sock, 10))
 715     << "listen failed with: " << strerror(errno);
 716
 717   // Accept should fail with EAGAIN since there is no incomming
 718   // connection.
 719   sockaddr_in addr;
 720   socklen_t addrlen = sizeof(addr);
 721   ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
 722   ASSERT_EQ(EAGAIN, errno);
 723
 724   // If we poll the listening socket it should also return
 725   // not readable to indicate that no connections are available
 726   // to accept.
 727   struct pollfd pollfd = { server_sock, POLLIN|POLLOUT, 0 };
 728   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 729
 730   // Connect to listening socket
 731   int client_sock = sock2_;
 732   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 733   addrlen = sizeof(addr);
 734   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 735     << "Failed with " << errno << ": " << strerror(errno);
 736
 737   // Not poll again but with an infintie timeout.
 738   pollfd.fd = server_sock;
 739   pollfd.events = POLLIN | POLLOUT;
 740   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
 741
 742   // Now non-blocking accept should return the new socket
 743   int new_socket = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
 744   ASSERT_NE(-1, new_socket)
 745     << "accept failed with: " << strerror(errno);
 746   ASSERT_EQ(0, ki_close(new_socket));
 747
 748   // Accept calls should once again fail with EAGAIN
 749   ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
 750   ASSERT_EQ(EAGAIN, errno);
 751
 752   // As should polling the listening socket
 753   pollfd.fd = server_sock;
 754   pollfd.events = POLLIN | POLLOUT;
 755   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 756 }
 757
 758 TEST_F(SocketTestTCP, SendRecvAfterRemoteShutdown) {
 759   sockaddr_in addr;
 760   socklen_t addrlen = sizeof(addr);
 761
 762   int server_sock = sock1_;
 763   int client_sock = sock2_;
 764
 765   // bind and listen
 766   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 767   ASSERT_EQ(0, ki_listen(server_sock, 10))
 768     << "listen failed with: " << strerror(errno);
 769
 770   // connect to listening socket
 771   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 772   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 773     << "Failed with " << errno << ": " << strerror(errno);
 774
 775   addrlen = sizeof(addr);
 776   int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
 777   ASSERT_NE(-1, new_sock);
 778
 779   const char* send_buf = "hello world";
 780   ASSERT_EQ(strlen(send_buf), ki_send(new_sock, send_buf, strlen(send_buf), 0));
 781
 782   // Recv first 10 bytes
 783   char buf[256];
 784   ASSERT_EQ(10, ki_recv(client_sock, buf, 10, 0));
 785
 786   // Close the new socket
 787   ASSERT_EQ(0, ki_close(new_sock));
 788
 789   // Recv remainder
 790   int bytes_remaining = strlen(send_buf) - 10;
 791   ASSERT_EQ(bytes_remaining, ki_recv(client_sock, buf, 256, 0));
 792
 793   // Attempt to read/write after remote shutdown, with no bytes remainging
 794   ASSERT_EQ(0, ki_recv(client_sock, buf, 10, 0));
 795   ASSERT_EQ(0, ki_recv(client_sock, buf, 10, 0));
 796   ASSERT_EQ(-1, ki_send(client_sock, buf, 10, 0));
 797   ASSERT_EQ(errno, EPIPE);
 798 }
 799
 800 TEST_F(SocketTestTCP, SendRecvAfterLocalShutdown) {
 801   sockaddr_in addr;
 802   socklen_t addrlen = sizeof(addr);
 803
 804   int server_sock = sock1_;
 805   int client_sock = sock2_;
 806
 807   // bind and listen
 808   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 809   ASSERT_EQ(0, ki_listen(server_sock, 10))
 810     << "listen failed with: " << strerror(errno);
 811
 812   // connect to listening socket
 813   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 814   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 815     << "Failed with " << errno << ": " << strerror(errno);
 816
 817   addrlen = sizeof(addr);
 818   int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
 819   ASSERT_NE(-1, new_sock);
 820
 821   // Close the new socket
 822   ASSERT_EQ(0, ki_shutdown(client_sock, SHUT_RDWR));
 823
 824   // Attempt to read/write after shutdown
 825   char buffer[10];
 826   ASSERT_EQ(0, ki_recv(client_sock, buffer, sizeof(buffer), 0));
 827   ASSERT_EQ(-1, ki_send(client_sock, buffer, sizeof(buffer), 0));
 828   ASSERT_EQ(errno, EPIPE);
 829 }
 830
 831 #define SEND_BYTES (1024)
 832 TEST_F(SocketTestTCP, SendBufferedDataAfterShutdown) {
 833   sockaddr_in addr;
 834   socklen_t addrlen = sizeof(addr);
 835
 836   int server_sock = sock1_;
 837   int client_sock = sock2_;
 838
 839   // bind and listen
 840   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 841   ASSERT_EQ(0, ki_listen(server_sock, 10))
 842     << "listen failed with: " << strerror(errno);
 843
 844   // connect to listening socket
 845   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 846   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 847     << "Failed with " << errno << ": " << strerror(errno);
 848
 849   addrlen = sizeof(addr);
 850   int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
 851   ASSERT_NE(-1, new_sock);
 852
 853   // send a fairly large amount of data and immediately close
 854   // the socket.
 855   void* buffer = alloca(SEND_BYTES);
 856   ASSERT_EQ(SEND_BYTES, ki_send(client_sock, buffer, SEND_BYTES, 0));
 857   ASSERT_EQ(0, ki_close(client_sock));
 858
 859   // avoid double close of sock2_
 860   sock2_ = -1;
 861
 862   // Attempt to recv() all the sent data.  None should be lost.
 863   int remainder = SEND_BYTES;
 864   while (remainder > 0) {
 865     int rtn = ki_recv(new_sock, buffer, remainder, 0);
 866     ASSERT_GT(rtn, 0);
 867     remainder -= rtn;
 868   }
 869
 870   ASSERT_EQ(0, ki_close(new_sock));
 871 }
 872
 873 TEST_F(SocketTestTCP, Sockopt_BUFSIZE) {
 874   int option = 1024*1024;
 875   socklen_t len = sizeof(option);
 876   sockaddr_in addr;
 877   socklen_t addrlen = sizeof(addr);
 878
 879   int server_sock = sock1_;
 880   int client_sock = sock2_;
 881
 882   // bind and listen
 883   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
 884   ASSERT_EQ(0, ki_listen(server_sock, 10))
 885     << "listen failed with: " << strerror(errno);
 886
 887   // connect to listening socket
 888   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
 889   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
 890     << "Failed with " << errno << ": " << strerror(errno);
 891
 892   addrlen = sizeof(addr);
 893   int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
 894   ASSERT_NE(-1, new_sock);
 895
 896   // Modify the test to verify the change by calling getsockopt
 897   // once TCPInterface supports GetOption() call
 898   ASSERT_EQ(0, ki_setsockopt(sock2_, SOL_SOCKET, SO_RCVBUF, &option, len))
 899       << "failed with: " << strerror(errno);
 900   ASSERT_EQ(0, ki_setsockopt(sock2_, SOL_SOCKET, SO_SNDBUF, &option, len))
 901       << "failed with: " << strerror(errno);
 902 }
 903
 904 #endif  // PROVIDES_SOCKET_API