socket_test.cc revision 3551c9c881056c480085172ff9840cab31610854
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 27using namespace nacl_io; 28using namespace sdk_util; 29 30namespace { 31class 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 49TEST_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 65TEST_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 77TEST_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 89TEST_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 105TEST_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 121TEST_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 137TEST_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 144TEST_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 156TEST_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 172TEST_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 183TEST_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 195TEST_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 209TEST_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 220TEST_F(SocketTest, Setsockopt) { 221 socklen_t len = 10; 222 char optval[len]; 223 224 EXPECT_LT(ki_setsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, len), 0); 225 EXPECT_EQ(errno, EFAULT); 226 EXPECT_LT(ki_setsockopt(-1, SOL_SOCKET, SO_ACCEPTCONN, optval, len), 0); 227 EXPECT_EQ(errno, EBADF); 228 EXPECT_LT(ki_setsockopt(0, SOL_SOCKET, SO_ACCEPTCONN, optval, len), 0); 229 EXPECT_EQ(errno, ENOTSOCK); 230} 231 232TEST_F(SocketTest, Shutdown) { 233 EXPECT_LT(ki_shutdown(-1, SHUT_RDWR), 0); 234 EXPECT_EQ(errno, EBADF); 235 EXPECT_LT(ki_shutdown(0, SHUT_RDWR), 0); 236 EXPECT_EQ(errno, ENOTSOCK); 237} 238 239TEST_F(SocketTest, Socket) { 240 EXPECT_LT(ki_socket(AF_UNIX, SOCK_STREAM, 0), 0); 241 EXPECT_EQ(errno, EAFNOSUPPORT); 242 EXPECT_LT(ki_socket(AF_INET, SOCK_RAW, 0), 0); 243 EXPECT_EQ(errno, EPROTONOSUPPORT); 244} 245 246TEST_F(SocketTest, Socketpair) { 247 int sv[2]; 248 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0); 249 EXPECT_EQ(errno, EFAULT); 250 EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0); 251 EXPECT_EQ(errno, EAFNOSUPPORT); 252 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0); 253 EXPECT_EQ(errno, EPROTONOSUPPORT); 254 EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0); 255 EXPECT_EQ(errno, EPROTONOSUPPORT); 256} 257 258// These utility functions are only used for newlib (glibc provides its own 259// implementations of these functions). 260#if !defined(__GLIBC__) 261 262TEST(SocketUtilityFunctions, Hstrerror) { 263 EXPECT_STREQ(hstrerror(2718), 264 "Unknown error in gethostbyname: 2718."); 265} 266 267TEST(SocketUtilityFunctions, Htonl) { 268 uint32_t host_long = 0x44332211; 269 uint32_t network_long = htonl(host_long); 270 uint8_t network_bytes[4]; 271 memcpy(network_bytes, &network_long, 4); 272 EXPECT_EQ(network_bytes[0], 0x44); 273 EXPECT_EQ(network_bytes[1], 0x33); 274 EXPECT_EQ(network_bytes[2], 0x22); 275 EXPECT_EQ(network_bytes[3], 0x11); 276} 277 278TEST(SocketUtilityFunctions, Htons) { 279 uint16_t host_short = 0x2211; 280 uint16_t network_short = htons(host_short); 281 uint8_t network_bytes[2]; 282 memcpy(network_bytes, &network_short, 2); 283 EXPECT_EQ(network_bytes[0], 0x22); 284 EXPECT_EQ(network_bytes[1], 0x11); 285} 286 287static struct in_addr generate_ipv4_addr(int tuple1, int tuple2, 288 int tuple3, int tuple4) { 289 unsigned char addr[4]; 290 addr[0] = static_cast<unsigned char>(tuple1); 291 addr[1] = static_cast<unsigned char>(tuple2); 292 addr[2] = static_cast<unsigned char>(tuple3); 293 addr[3] = static_cast<unsigned char>(tuple4); 294 struct in_addr real_addr; 295 memcpy(&real_addr, addr, 4); 296 return real_addr; 297} 298 299static struct in6_addr generate_ipv6_addr(int* tuples) { 300 unsigned char addr[16]; 301 for (int i = 0; i < 8; i++) { 302 addr[2*i] = (tuples[i] >> 8) & 0xFF; 303 addr[2*i+1] = tuples[i] & 0xFF; 304 } 305 struct in6_addr real_addr; 306 memcpy(&real_addr, addr, 16); 307 return real_addr; 308} 309 310TEST(SocketUtilityFunctions, Inet_ntoa) { 311 char* stringified_addr = inet_ntoa(generate_ipv4_addr(0,0,0,0)); 312 ASSERT_TRUE(NULL != stringified_addr); 313 EXPECT_STREQ("0.0.0.0", stringified_addr); 314 315 stringified_addr = inet_ntoa(generate_ipv4_addr(127,0,0,1)); 316 ASSERT_TRUE(NULL != stringified_addr); 317 EXPECT_STREQ("127.0.0.1", stringified_addr); 318 319 stringified_addr = inet_ntoa(generate_ipv4_addr(255,255,255,255)); 320 ASSERT_TRUE(NULL != stringified_addr); 321 EXPECT_STREQ("255.255.255.255", stringified_addr); 322} 323 324TEST(SocketUtilityFunctions, Inet_ntop_ipv4) { 325 char stringified_addr[INET_ADDRSTRLEN]; 326 327 struct in_addr real_addr = generate_ipv4_addr(0,0,0,0); 328 EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr, 329 stringified_addr, INET_ADDRSTRLEN)); 330 EXPECT_STREQ("0.0.0.0", stringified_addr); 331 332 real_addr = generate_ipv4_addr(127,0,0,1); 333 EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr, 334 stringified_addr, INET_ADDRSTRLEN)); 335 EXPECT_STREQ("127.0.0.1", stringified_addr); 336 337 real_addr = generate_ipv4_addr(255,255,255,255); 338 EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr, 339 stringified_addr, INET_ADDRSTRLEN)); 340 EXPECT_STREQ("255.255.255.255", stringified_addr); 341} 342 343TEST(SocketUtilityFunctions, Inet_ntop_ipv6) { 344 char stringified_addr[INET6_ADDRSTRLEN]; 345 346 { 347 int addr_tuples[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 348 struct in6_addr real_addr = generate_ipv6_addr(addr_tuples); 349 EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr, 350 stringified_addr, INET6_ADDRSTRLEN)); 351 EXPECT_STREQ("0:0:0:0:0:0:0:0", stringified_addr); 352 } 353 354 { 355 int addr_tuples[8] = { 0x1234, 0xa, 0x12, 0x0000, 356 0x5678, 0x9abc, 0xdef, 0xffff }; 357 struct in6_addr real_addr = generate_ipv6_addr(addr_tuples); 358 EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr, 359 stringified_addr, INET6_ADDRSTRLEN)); 360 EXPECT_STREQ("1234:a:12:0:5678:9abc:def:ffff", stringified_addr); 361 } 362 363 { 364 int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff, 365 0xffff, 0xffff, 0xffff, 0xffff }; 366 struct in6_addr real_addr = generate_ipv6_addr(addr_tuples); 367 EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr, 368 stringified_addr, INET6_ADDRSTRLEN)); 369 EXPECT_STREQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", stringified_addr); 370 } 371} 372 373TEST(SocketUtilityFunctions, Inet_ntop_failure) { 374 char addr_name[INET6_ADDRSTRLEN]; 375 int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff, 376 0xffff, 0xffff, 0xffff, 0xffff }; 377 struct in6_addr ipv6_addr = generate_ipv6_addr(addr_tuples); 378 struct in_addr ipv4_addr = generate_ipv4_addr(255,255,255,255); 379 380 EXPECT_TRUE(NULL == inet_ntop(AF_UNIX, &ipv6_addr, 381 addr_name, INET6_ADDRSTRLEN)); 382 EXPECT_EQ(errno, EAFNOSUPPORT); 383 384 EXPECT_TRUE(NULL == inet_ntop(AF_INET, &ipv4_addr, 385 addr_name, INET_ADDRSTRLEN - 1)); 386 EXPECT_EQ(errno, ENOSPC); 387 388 EXPECT_TRUE(NULL == inet_ntop(AF_INET6, &ipv6_addr, 389 addr_name, INET6_ADDRSTRLEN - 1)); 390 EXPECT_EQ(errno, ENOSPC); 391} 392 393TEST(SocketUtilityFunctions, Ntohs) { 394 uint8_t network_bytes[2] = { 0x22, 0x11 }; 395 uint16_t network_short; 396 memcpy(&network_short, network_bytes, 2); 397 uint16_t host_short = ntohs(network_short); 398 EXPECT_EQ(host_short, 0x2211); 399} 400 401TEST(SocketUtilityFunctions, Ntohl) { 402 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; 403 uint32_t network_long; 404 memcpy(&network_long, network_bytes, 4); 405 uint32_t host_long = ntohl(network_long); 406 EXPECT_EQ(host_long, 0x44332211); 407} 408 409#endif // !defined(__GLIBC__) 410#endif // PROVIDES_SOCKETPAIR_API 411