src/native_client_sdk/src/tests/nacl_io_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 "gmock/gmock.h"
  18 #include "gtest/gtest.h"
  19
  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
  25 #ifdef PROVIDES_SOCKET_API
  26
  27 using namespace nacl_io;
  28 using namespace sdk_util;
  29
  30 namespace {
  31 class SocketTest : public ::testing::Test {
  32  public:
  33   SocketTest() {}
  34
  35   void SetUp() {
  36     ki_init(&kp_);
  37   }
  38
  39   void TearDown() {
  40     ki_uninit();
  41   }
  42
  43  protected:
  44   KernelProxy kp_;
  45 };
  46
  47 }  // namespace
  48
  49 TEST_F(SocketTest, Accept) {
  50   struct sockaddr addr = {};
  51   socklen_t len = 0;
  52
  53   EXPECT_LT(ki_accept(123, NULL, &len), 0);
  54   EXPECT_EQ(errno, EFAULT);
  55   EXPECT_LT(ki_accept(123, &addr, NULL), 0);
  56   EXPECT_EQ(errno, EFAULT);
  57   EXPECT_LT(ki_accept(123, NULL, NULL), 0);
  58   EXPECT_EQ(errno, EFAULT);
  59   EXPECT_LT(ki_accept(-1, &addr, &len), 0);
  60   EXPECT_EQ(errno, EBADF);
  61   EXPECT_LT(ki_accept(0, &addr, &len), 0);
  62   EXPECT_EQ(errno, ENOTSOCK);
  63 }
  64
  65 TEST_F(SocketTest, Bind) {
  66   const struct sockaddr const_addr = {};
  67   socklen_t len = 0;
  68
  69   EXPECT_LT(ki_bind(123, NULL, len), 0);
  70   EXPECT_EQ(errno, EFAULT);
  71   EXPECT_LT(ki_bind(-1, &const_addr, len), 0);
  72   EXPECT_EQ(errno, EBADF);
  73   EXPECT_LT(ki_bind(0, &const_addr, len), 0);
  74   EXPECT_EQ(errno, ENOTSOCK);
  75 }
  76
  77 TEST_F(SocketTest, Connect) {
  78   const struct sockaddr const_addr = {};
  79   socklen_t len = 0;
  80
  81   EXPECT_LT(ki_connect(123, NULL, len), 0);
  82   EXPECT_EQ(errno, EFAULT);
  83   EXPECT_LT(ki_connect(-1, &const_addr, len), 0);
  84   EXPECT_EQ(errno, EBADF);
  85   EXPECT_LT(ki_connect(0, &const_addr, len), 0);
  86   EXPECT_EQ(errno, ENOTSOCK);
  87 }
  88
  89 TEST_F(SocketTest, Getpeername) {
  90   struct sockaddr addr = {};
  91   socklen_t len = 0;
  92
  93   EXPECT_LT(ki_getpeername(123, NULL, &len), 0);
  94   EXPECT_EQ(errno, EFAULT);
  95   EXPECT_LT(ki_getpeername(123, &addr, NULL), 0);
  96   EXPECT_EQ(errno, EFAULT);
  97   EXPECT_LT(ki_getpeername(123, NULL, NULL), 0);
  98   EXPECT_EQ(errno, EFAULT);
  99   EXPECT_LT(ki_getpeername(-1, &addr, &len), 0);
 100   EXPECT_EQ(errno, EBADF);
 101   EXPECT_LT(ki_getpeername(0, &addr, &len), 0);
 102   EXPECT_EQ(errno, ENOTSOCK);
 103 }
 104
 105 TEST_F(SocketTest, Getsockname) {
 106   struct sockaddr addr = {};
 107   socklen_t len = 0;
 108
 109   EXPECT_LT(ki_getsockname(123, NULL, &len), 0);
 110   EXPECT_EQ(errno, EFAULT);
 111   EXPECT_LT(ki_getsockname(123, &addr, NULL), 0);
 112   EXPECT_EQ(errno, EFAULT);
 113   EXPECT_LT(ki_getsockname(123, NULL, NULL), 0);
 114   EXPECT_EQ(errno, EFAULT);
 115   EXPECT_LT(ki_getsockname(-1, &addr, &len), 0);
 116   EXPECT_EQ(errno, EBADF);
 117   EXPECT_LT(ki_getsockname(0, &addr, &len), 0);
 118   EXPECT_EQ(errno, ENOTSOCK);
 119 }
 120
 121 TEST_F(SocketTest, Getsockopt) {
 122   socklen_t len = 10;
 123   char optval[len];
 124
 125   EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, optval, NULL), 0);
 126   EXPECT_EQ(errno, EFAULT);
 127   EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, &len), 0);
 128   EXPECT_EQ(errno, EFAULT);
 129   EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, NULL), 0);
 130   EXPECT_EQ(errno, EFAULT);
 131   EXPECT_LT(ki_getsockopt(-1, SOL_SOCKET, SO_ACCEPTCONN, optval, &len), 0);
 132   EXPECT_EQ(errno, EBADF);
 133   EXPECT_LT(ki_getsockopt(0, SOL_SOCKET, SO_ACCEPTCONN, optval, &len), 0);
 134   EXPECT_EQ(errno, ENOTSOCK);
 135 }
 136
 137 TEST_F(SocketTest, Listen) {
 138   EXPECT_LT(ki_listen(-1, 123), 0);
 139   EXPECT_EQ(errno, EBADF);
 140   EXPECT_LT(ki_listen(0, 123), 0);
 141   EXPECT_EQ(errno, ENOTSOCK);
 142 }
 143
 144 TEST_F(SocketTest, Recv) {
 145   size_t len = 10;
 146   char buf[len];
 147
 148   EXPECT_LT(ki_recv(123, NULL, len, 0), 0);
 149   EXPECT_EQ(errno, EFAULT);
 150   EXPECT_LT(ki_recv(-1, buf, len, 0), 0);
 151   EXPECT_EQ(errno, EBADF);
 152   EXPECT_LT(ki_recv(0, buf, len, 0), 0);
 153   EXPECT_EQ(errno, ENOTSOCK);
 154 }
 155
 156 TEST_F(SocketTest, Recvfrom) {
 157   size_t len = 10;
 158   char buf[len];
 159   struct sockaddr addr = {};
 160   socklen_t addrlen = 4;
 161
 162   EXPECT_LT(ki_recvfrom(123, NULL, len, 0, &addr, &addrlen), 0);
 163   EXPECT_EQ(errno, EFAULT);
 164   EXPECT_LT(ki_recvfrom(123, buf, len, 0, &addr, NULL), 0);
 165   EXPECT_EQ(errno, EFAULT);
 166   EXPECT_LT(ki_recvfrom(-1, buf, len, 0, &addr, &addrlen), 0);
 167   EXPECT_EQ(errno, EBADF);
 168   EXPECT_LT(ki_recvfrom(0, buf, len, 0, &addr, &addrlen), 0);
 169   EXPECT_EQ(errno, ENOTSOCK);
 170 }
 171
 172 TEST_F(SocketTest, Recvmsg) {
 173   struct msghdr msg = {};
 174
 175   EXPECT_LT(ki_recvmsg(123, NULL, 0), 0);
 176   EXPECT_EQ(errno, EFAULT);
 177   EXPECT_LT(ki_recvmsg(-1, &msg, 0), 0);
 178   EXPECT_EQ(errno, EBADF);
 179   EXPECT_LT(ki_recvmsg(0, &msg, 0), 0);
 180   EXPECT_EQ(errno, ENOTSOCK);
 181 }
 182
 183 TEST_F(SocketTest, Send) {
 184   size_t len = 10;
 185   char buf[len];
 186
 187   EXPECT_LT(ki_send(123, NULL, len, 0), 0);
 188   EXPECT_EQ(errno, EFAULT);
 189   EXPECT_LT(ki_send(-1, buf, len, 0), 0);
 190   EXPECT_EQ(errno, EBADF);
 191   EXPECT_LT(ki_send(0, buf, len, 0), 0);
 192   EXPECT_EQ(errno, ENOTSOCK);
 193 }
 194
 195 TEST_F(SocketTest, Sendto) {
 196   size_t len = 10;
 197   char buf[len];
 198   struct sockaddr addr = {};
 199   socklen_t addrlen = 4;
 200
 201   EXPECT_LT(ki_sendto(123, NULL, len, 0, &addr, addrlen), 0);
 202   EXPECT_EQ(errno, EFAULT);
 203   EXPECT_LT(ki_sendto(-1, buf, len, 0, &addr, addrlen), 0);
 204   EXPECT_EQ(errno, EBADF);
 205   EXPECT_LT(ki_sendto(0, buf, len, 0, &addr, addrlen), 0);
 206   EXPECT_EQ(errno, ENOTSOCK);
 207 }
 208
 209 TEST_F(SocketTest, Sendmsg) {
 210   struct msghdr msg = {};
 211
 212   EXPECT_LT(ki_sendmsg(123, NULL, 0), 0);
 213   EXPECT_EQ(errno, EFAULT);
 214   EXPECT_LT(ki_sendmsg(-1, &msg, 0), 0);
 215   EXPECT_EQ(errno, EBADF);
 216   EXPECT_LT(ki_sendmsg(0, &msg, 0), 0);
 217   EXPECT_EQ(errno, ENOTSOCK);
 218 }
 219
 220 TEST_F(SocketTest, Setsockopt) {
 221   socklen_t len = 10;
 222   char optval[len];
 223
 224   // Passing a bad address as optval should generate EFAULT
 225   EXPECT_EQ(-1, ki_setsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, len));
 226   EXPECT_EQ(errno, EFAULT);
 227
 228   // Passing a bad socket descriptor should generate EBADF
 229   EXPECT_EQ(-1, ki_setsockopt(-1, SOL_SOCKET, SO_ACCEPTCONN, optval, len));
 230   EXPECT_EQ(errno, EBADF);
 231
 232   // Passing an FD that is valid but not a socket should generate ENOTSOCK
 233   EXPECT_EQ(-1, ki_setsockopt(0, SOL_SOCKET, SO_ACCEPTCONN, optval, len));
 234   EXPECT_EQ(errno, ENOTSOCK);
 235 }
 236
 237 TEST_F(SocketTest, Shutdown) {
 238   EXPECT_LT(ki_shutdown(-1, SHUT_RDWR), 0);
 239   EXPECT_EQ(errno, EBADF);
 240   EXPECT_LT(ki_shutdown(0, SHUT_RDWR), 0);
 241   EXPECT_EQ(errno, ENOTSOCK);
 242 }
 243
 244 TEST_F(SocketTest, Socket) {
 245   EXPECT_LT(ki_socket(AF_UNIX, SOCK_STREAM, 0), 0);
 246   EXPECT_EQ(errno, EAFNOSUPPORT);
 247   EXPECT_LT(ki_socket(AF_INET, SOCK_RAW, 0), 0);
 248   EXPECT_EQ(errno, EPROTONOSUPPORT);
 249 }
 250
 251 TEST_F(SocketTest, Socketpair) {
 252   int sv[2];
 253   EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0);
 254   EXPECT_EQ(errno, EFAULT);
 255   EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
 256   EXPECT_EQ(errno, EAFNOSUPPORT);
 257   EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0);
 258   EXPECT_EQ(errno, EPROTONOSUPPORT);
 259   EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0);
 260   EXPECT_EQ(errno, EPROTONOSUPPORT);
 261 }
 262
 263 // These utility functions are only used for newlib (glibc provides its own
 264 // implementations of these functions).
 265 #if !defined(__GLIBC__)
 266
 267 TEST(SocketUtilityFunctions, Hstrerror) {
 268   EXPECT_STREQ(hstrerror(2718),
 269                "Unknown error in gethostbyname: 2718.");
 270 }
 271
 272 TEST(SocketUtilityFunctions, Htonl) {
 273   uint32_t host_long = 0x44332211;
 274   uint32_t network_long = htonl(host_long);
 275   uint8_t network_bytes[4];
 276   memcpy(network_bytes, &network_long, 4);
 277   EXPECT_EQ(network_bytes[0], 0x44);
 278   EXPECT_EQ(network_bytes[1], 0x33);
 279   EXPECT_EQ(network_bytes[2], 0x22);
 280   EXPECT_EQ(network_bytes[3], 0x11);
 281 }
 282
 283 TEST(SocketUtilityFunctions, Htons) {
 284   uint16_t host_short = 0x2211;
 285   uint16_t network_short = htons(host_short);
 286   uint8_t network_bytes[2];
 287   memcpy(network_bytes, &network_short, 2);
 288   EXPECT_EQ(network_bytes[0], 0x22);
 289   EXPECT_EQ(network_bytes[1], 0x11);
 290 }
 291
 292 static struct in_addr generate_ipv4_addr(int tuple1, int tuple2,
 293                                          int tuple3, int tuple4) {
 294   unsigned char addr[4];
 295   addr[0] = static_cast<unsigned char>(tuple1);
 296   addr[1] = static_cast<unsigned char>(tuple2);
 297   addr[2] = static_cast<unsigned char>(tuple3);
 298   addr[3] = static_cast<unsigned char>(tuple4);
 299   struct in_addr real_addr;
 300   memcpy(&real_addr, addr, 4);
 301   return real_addr;
 302 }
 303
 304 static struct in6_addr generate_ipv6_addr(int* tuples) {
 305   unsigned char addr[16];
 306   for (int i = 0; i < 8; i++) {
 307     addr[2*i] = (tuples[i] >> 8) & 0xFF;
 308     addr[2*i+1] = tuples[i] & 0xFF;
 309   }
 310   struct in6_addr real_addr;
 311   memcpy(&real_addr, addr, 16);
 312   return real_addr;
 313 }
 314
 315 TEST(SocketUtilityFunctions, Inet_ntoa) {
 316   char* stringified_addr = inet_ntoa(generate_ipv4_addr(0,0,0,0));
 317   ASSERT_TRUE(NULL != stringified_addr);
 318   EXPECT_STREQ("0.0.0.0", stringified_addr);
 319
 320   stringified_addr = inet_ntoa(generate_ipv4_addr(127,0,0,1));
 321   ASSERT_TRUE(NULL != stringified_addr);
 322   EXPECT_STREQ("127.0.0.1", stringified_addr);
 323
 324   stringified_addr = inet_ntoa(generate_ipv4_addr(255,255,255,255));
 325   ASSERT_TRUE(NULL != stringified_addr);
 326   EXPECT_STREQ("255.255.255.255", stringified_addr);
 327 }
 328
 329 TEST(SocketUtilityFunctions, Inet_ntop_ipv4) {
 330   char stringified_addr[INET_ADDRSTRLEN];
 331
 332   struct in_addr real_addr = generate_ipv4_addr(0,0,0,0);
 333   EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
 334                                 stringified_addr, INET_ADDRSTRLEN));
 335   EXPECT_STREQ("0.0.0.0", stringified_addr);
 336
 337   real_addr = generate_ipv4_addr(127,0,0,1);
 338   EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
 339                                 stringified_addr, INET_ADDRSTRLEN));
 340   EXPECT_STREQ("127.0.0.1", stringified_addr);
 341
 342   real_addr = generate_ipv4_addr(255,255,255,255);
 343   EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
 344                                 stringified_addr, INET_ADDRSTRLEN));
 345   EXPECT_STREQ("255.255.255.255", stringified_addr);
 346 }
 347
 348 TEST(SocketUtilityFunctions, Inet_ntop_ipv6) {
 349   char stringified_addr[INET6_ADDRSTRLEN];
 350
 351   {
 352     int addr_tuples[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 353     struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
 354     EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
 355                                   stringified_addr, INET6_ADDRSTRLEN));
 356     EXPECT_STREQ("0:0:0:0:0:0:0:0", stringified_addr);
 357   }
 358
 359   {
 360     int addr_tuples[8] = { 0x1234, 0xa, 0x12, 0x0000,
 361                                 0x5678, 0x9abc, 0xdef, 0xffff };
 362     struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
 363     EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
 364                                   stringified_addr, INET6_ADDRSTRLEN));
 365     EXPECT_STREQ("1234:a:12:0:5678:9abc:def:ffff", stringified_addr);
 366   }
 367
 368   {
 369     int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff,
 370                                 0xffff, 0xffff, 0xffff, 0xffff };
 371     struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
 372     EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
 373                                   stringified_addr, INET6_ADDRSTRLEN));
 374     EXPECT_STREQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", stringified_addr);
 375   }
 376 }
 377
 378 TEST(SocketUtilityFunctions, Inet_ntop_failure) {
 379   char addr_name[INET6_ADDRSTRLEN];
 380   int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff,
 381                               0xffff, 0xffff, 0xffff, 0xffff };
 382   struct in6_addr ipv6_addr = generate_ipv6_addr(addr_tuples);
 383   struct in_addr ipv4_addr = generate_ipv4_addr(255,255,255,255);
 384
 385   EXPECT_TRUE(NULL == inet_ntop(AF_UNIX, &ipv6_addr,
 386                                 addr_name, INET6_ADDRSTRLEN));
 387   EXPECT_EQ(errno, EAFNOSUPPORT);
 388
 389   EXPECT_TRUE(NULL == inet_ntop(AF_INET, &ipv4_addr,
 390                                 addr_name, INET_ADDRSTRLEN - 1));
 391   EXPECT_EQ(errno, ENOSPC);
 392
 393   EXPECT_TRUE(NULL == inet_ntop(AF_INET6, &ipv6_addr,
 394                                 addr_name, INET6_ADDRSTRLEN - 1));
 395   EXPECT_EQ(errno, ENOSPC);
 396 }
 397
 398 TEST(SocketUtilityFunctions, Ntohs) {
 399   uint8_t network_bytes[2] = { 0x22, 0x11 };
 400   uint16_t network_short;
 401   memcpy(&network_short, network_bytes, 2);
 402   uint16_t host_short = ntohs(network_short);
 403   EXPECT_EQ(host_short, 0x2211);
 404 }
 405
 406 TEST(SocketUtilityFunctions, Ntohl) {
 407   uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 };
 408   uint32_t network_long;
 409   memcpy(&network_long, network_bytes, 4);
 410   uint32_t host_long = ntohl(network_long);
 411   EXPECT_EQ(host_long, 0x44332211);
 412 }
 413
 414 #endif  // !defined(__GLIBC__)
 415 #endif  // PROVIDES_SOCKETPAIR_API