1 /* Advanced tests for UNIX Domain Sockets - by D.C. van Moolenbroek */ 2 /* 3 * This is a somewhat random collection of in-depth tests, complementing the 4 * more general functionality tests in test56. The overall test set is still 5 * by no means expected to be "complete." The subtests are in random order. 6 */ 7 #include <stdlib.h> 8 #include <string.h> 9 #include <sys/wait.h> 10 #include <sys/socket.h> 11 #include <sys/un.h> 12 #include <sys/ioctl.h> 13 #include <sys/sysctl.h> 14 #include <signal.h> 15 #include <unistd.h> 16 #include <fcntl.h> 17 #include <stddef.h> 18 #include <assert.h> 19 20 #include "common.h" 21 #include "socklib.h" 22 23 #define ITERATIONS 1 24 25 #define SOCK_PATH_A "sock_a" 26 #define SOCK_PATH_B "sock_b" 27 #define SOCK_PATH_C "sock_c" 28 #define SOCK_PATH_D "sock_d" 29 30 #define SOCK_PATH_A_X ".//sock_a" 31 #define SOCK_PATH_A_Y "./././sock_a" 32 33 #define PRINT_STATS 0 34 35 /* 36 * Check that the given returned socket address matches the given path. A NULL 37 * path may be passed in to indicate the result should be for an unbound 38 * socket. 39 */ 40 static void 41 check_addr(struct sockaddr_un * sun, socklen_t len, const char * path) 42 { 43 44 if (len < offsetof(struct sockaddr_un, sun_path)) e(0); 45 46 if (sun->sun_family != AF_UNIX) e(0); 47 if (sun->sun_len != len - ((path != NULL) ? 1 : 0)) e(0); 48 49 len -= offsetof(struct sockaddr_un, sun_path); 50 51 if (path != NULL) { 52 if (len != strlen(path) + 1) e(0); 53 if (sun->sun_path[len - 1] != '\0') e(0); 54 if (strcmp(sun->sun_path, path)) e(0); 55 } else 56 if (len != 0) e(0); 57 } 58 59 /* 60 * Get a socket of the given type, bound to the given path. Return the file 61 * descriptor, as well as the bound addres in 'sun'. 62 */ 63 static int 64 get_bound_socket(int type, const char * path, struct sockaddr_un * sun) 65 { 66 int fd; 67 68 if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0); 69 70 (void)unlink(path); 71 72 memset(sun, 0, sizeof(*sun)); 73 sun->sun_family = AF_UNIX; 74 strlcpy(sun->sun_path, path, sizeof(sun->sun_path)); 75 76 if (bind(fd, (struct sockaddr *)sun, sizeof(*sun)) != 0) e(0); 77 78 return fd; 79 } 80 81 /* 82 * Get a pair of connected sockets. 83 */ 84 static void 85 get_socket_pair(int type, int fd[2]) 86 { 87 struct sockaddr_un sunA, sunB; 88 89 if ((type & ~SOCK_FLAGS_MASK) == SOCK_DGRAM) { 90 fd[0] = get_bound_socket(type, SOCK_PATH_A, &sunA); 91 fd[1] = get_bound_socket(type, SOCK_PATH_B, &sunB); 92 93 if (connect(fd[0], (struct sockaddr *)&sunB, 94 sizeof(sunB)) != 0) e(0); 95 if (connect(fd[1], (struct sockaddr *)&sunA, 96 sizeof(sunA)) != 0) e(0); 97 98 if (unlink(SOCK_PATH_A) != 0) e(0); 99 if (unlink(SOCK_PATH_B) != 0) e(0); 100 } else 101 if (socketpair(AF_UNIX, type, 0, fd) != 0) e(0); 102 } 103 104 /* 105 * Return the receive buffer size of the given socket. 106 */ 107 static int 108 get_rcvbuf_len(int fd) 109 { 110 socklen_t len; 111 int val; 112 113 len = sizeof(val); 114 if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) != 0) e(0); 115 116 if (len != sizeof(val)) e(0); 117 if (val <= 0) e(0); 118 119 return val; 120 } 121 122 static const enum state unix_connect_states[] = { 123 S_NEW, S_N_SHUT_R, S_N_SHUT_W, S_N_SHUT_RW, 124 S_BOUND, S_LISTENING, S_L_SHUT_R, S_L_SHUT_W, 125 S_L_SHUT_RW, S_CONNECTING, S_CONNECTED, S_ACCEPTED, 126 S_SHUT_R, S_SHUT_W, S_SHUT_RW, S_RSHUT_R, 127 S_RSHUT_W, S_RSHUT_RW, S_SHUT2_R, S_SHUT2_W, 128 S_SHUT2_RW, S_PRE_EOF, S_AT_EOF, S_POST_EOF, 129 S_PRE_SHUT_R, S_EOF_SHUT_R, S_POST_SHUT_R, S_PRE_SHUT_W, 130 S_EOF_SHUT_W, S_POST_SHUT_W, S_PRE_SHUT_RW, S_EOF_SHUT_RW, 131 S_POST_SHUT_RW, S_AT_RESET, S_POST_RESET, S_POST_FAILED 132 /* 133 * It is impossible to generate the S_PRE_RESET state: we can 134 * only generate a reset on a connected socket for which the 135 * other end is pending acceptance, by closing the listening 136 * socket. That means we cannot send data to the connected end 137 * (from the listening socket) before triggering the reset. 138 * 139 * It is impossible to generate the S_FAILED state: even a non- 140 * blocking connect will always fail immediately when it cannot 141 * connect to the target. 142 */ 143 }; 144 145 static const int unix_connect_results[][__arraycount(unix_connect_states)] = { 146 [C_ACCEPT] = { 147 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 148 -EINVAL, -EAGAIN, -ECONNABORTED, -ECONNABORTED, 149 -ECONNABORTED, -EINVAL, -EINVAL, -EINVAL, 150 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 151 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 152 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 153 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 154 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 155 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 156 }, 157 [C_BIND] = { 158 0, 0, 0, 0, 159 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 160 -EINVAL, 0, 0, -EINVAL, 161 0, 0, 0, 0, 162 0, 0, 0, 0, 163 0, 0, 0, 0, 164 0, 0, 0, 0, 165 0, 0, 0, 0, 166 0, 0, 0, 0, 167 }, 168 [C_CONNECT] = { 169 0, 0, 0, 0, 170 0, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 171 -EOPNOTSUPP, -EALREADY, -EISCONN, -EISCONN, 172 -EISCONN, -EISCONN, -EISCONN, -EISCONN, 173 -EISCONN, -EISCONN, -EISCONN, -EISCONN, 174 -EISCONN, 0, 0, 0, 175 0, 0, 0, 0, 176 0, 0, 0, 0, 177 0, 0, 0, 0, 178 }, 179 [C_GETPEERNAME] = { 180 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 181 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 182 -ENOTCONN, -ENOTCONN, 0, 0, 183 0, 0, 0, 0, 184 0, 0, 0, 0, 185 0, -ENOTCONN, -ENOTCONN, -ENOTCONN, 186 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 187 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 188 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 189 }, 190 [C_GETSOCKNAME] = { 191 0, 0, 0, 0, 192 0, 0, 0, 0, 193 0, 0, 0, 0, 194 0, 0, 0, 0, 195 0, 0, 0, 0, 196 0, 0, 0, 0, 197 0, 0, 0, 0, 198 0, 0, 0, 0, 199 0, 0, 0, 0, 200 }, 201 [C_GETSOCKOPT_ERR] = { 202 0, 0, 0, 0, 203 0, 0, 0, 0, 204 0, 0, 0, 0, 205 0, 0, 0, 0, 206 0, 0, 0, 0, 207 0, 0, 0, 0, 208 0, 0, 0, 0, 209 0, 0, 0, 0, 210 0, -ECONNRESET, 0, 0, 211 }, 212 [C_GETSOCKOPT_KA] = { 213 0, 0, 0, 0, 214 0, 0, 0, 0, 215 0, 0, 0, 0, 216 0, 0, 0, 0, 217 0, 0, 0, 0, 218 0, 0, 0, 0, 219 0, 0, 0, 0, 220 0, 0, 0, 0, 221 0, 0, 0, 0, 222 }, 223 [C_GETSOCKOPT_RB] = { 224 0, 0, 0, 0, 225 0, 0, 0, 0, 226 0, 0, 0, 0, 227 0, 0, 0, 0, 228 0, 0, 0, 0, 229 0, 0, 0, 0, 230 0, 0, 0, 0, 231 0, 0, 0, 0, 232 0, 0, 0, 0, 233 }, 234 [C_IOCTL_NREAD] = { 235 0, 0, 0, 0, 236 0, 0, 0, 0, 237 0, 0, 0, 0, 238 0, 0, 0, 0, 239 0, 0, 0, 0, 240 0, 1, 0, 0, 241 0, 0, 0, 1, 242 0, 0, 0, 0, 243 0, 0, 0, 0, 244 }, 245 [C_LISTEN] = { 246 -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, 247 0, 0, 0, 0, 248 0, -EINVAL, -EINVAL, -EINVAL, 249 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 250 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 251 -EINVAL, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, 252 -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, 253 -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, 254 -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, 255 }, 256 [C_RECV] = { 257 -ENOTCONN, 0, -ENOTCONN, 0, 258 -ENOTCONN, -ENOTCONN, 0, -ENOTCONN, 259 0, -EAGAIN, -EAGAIN, -EAGAIN, 260 0, -EAGAIN, 0, -EAGAIN, 261 0, 0, 0, 0, 262 0, 1, 0, 0, 263 0, 0, 0, 1, 264 0, 0, 0, 0, 265 0, -ECONNRESET, 0, -ENOTCONN, 266 }, 267 [C_RECVFROM] = { 268 -ENOTCONN, 0, -ENOTCONN, 0, 269 -ENOTCONN, -ENOTCONN, 0, -ENOTCONN, 270 0, -EAGAIN, -EAGAIN, -EAGAIN, 271 0, -EAGAIN, 0, -EAGAIN, 272 0, 0, 0, 0, 273 0, 1, 0, 0, 274 0, 0, 0, 1, 275 0, 0, 0, 0, 276 0, -ECONNRESET, 0, -ENOTCONN, 277 }, 278 [C_SEND] = { 279 -ENOTCONN, -ENOTCONN, -EPIPE, -EPIPE, 280 -ENOTCONN, -ENOTCONN, -ENOTCONN, -EPIPE, 281 -EPIPE, -EAGAIN, 1, 1, 282 1, -EPIPE, -EPIPE, -EPIPE, 283 1, -EPIPE, -EPIPE, -EPIPE, 284 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 285 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 286 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 287 -EPIPE, -ECONNRESET, -EPIPE, -ENOTCONN, 288 }, 289 [C_SENDTO] = { 290 -ENOTCONN, -ENOTCONN, -EPIPE, -EPIPE, 291 -ENOTCONN, -ENOTCONN, -ENOTCONN, -EPIPE, 292 -EPIPE, -EAGAIN, 1, 1, 293 1, -EPIPE, -EPIPE, -EPIPE, 294 1, -EPIPE, -EPIPE, -EPIPE, 295 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 296 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 297 -EPIPE, -EPIPE, -EPIPE, -EPIPE, 298 -EPIPE, -ECONNRESET, -EPIPE, -ENOTCONN, 299 }, 300 [C_SELECT_R] = { 301 1, 1, 1, 1, 302 1, 0, 1, 1, 303 1, 0, 0, 0, 304 1, 0, 1, 0, 305 1, 1, 1, 1, 306 1, 1, 1, 1, 307 1, 1, 1, 1, 308 1, 1, 1, 1, 309 1, 1, 1, 1, 310 }, 311 [C_SELECT_W] = { 312 1, 1, 1, 1, 313 1, 1, 1, 1, 314 1, 0, 1, 1, 315 1, 1, 1, 1, 316 1, 1, 1, 1, 317 1, 1, 1, 1, 318 1, 1, 1, 1, 319 1, 1, 1, 1, 320 1, 1, 1, 1, 321 }, 322 [C_SELECT_X] = { 323 0, 0, 0, 0, 324 0, 0, 0, 0, 325 0, 0, 0, 0, 326 0, 0, 0, 0, 327 0, 0, 0, 0, 328 0, 0, 0, 0, 329 0, 0, 0, 0, 330 0, 0, 0, 0, 331 0, 0, 0, 0, 332 }, 333 [C_SETSOCKOPT_BC] = { 334 0, 0, 0, 0, 335 0, 0, 0, 0, 336 0, 0, 0, 0, 337 0, 0, 0, 0, 338 0, 0, 0, 0, 339 0, 0, 0, 0, 340 0, 0, 0, 0, 341 0, 0, 0, 0, 342 0, 0, 0, 0, 343 }, 344 [C_SETSOCKOPT_KA] = { 345 0, 0, 0, 0, 346 0, 0, 0, 0, 347 0, 0, 0, 0, 348 0, 0, 0, 0, 349 0, 0, 0, 0, 350 0, 0, 0, 0, 351 0, 0, 0, 0, 352 0, 0, 0, 0, 353 0, 0, 0, 0, 354 }, 355 [C_SETSOCKOPT_L] = { 356 0, 0, 0, 0, 357 0, 0, 0, 0, 358 0, 0, 0, 0, 359 0, 0, 0, 0, 360 0, 0, 0, 0, 361 0, 0, 0, 0, 362 0, 0, 0, 0, 363 0, 0, 0, 0, 364 0, 0, 0, 0, 365 }, 366 [C_SETSOCKOPT_RA] = { 367 0, 0, 0, 0, 368 0, 0, 0, 0, 369 0, 0, 0, 0, 370 0, 0, 0, 0, 371 0, 0, 0, 0, 372 0, 0, 0, 0, 373 0, 0, 0, 0, 374 0, 0, 0, 0, 375 0, 0, 0, 0, 376 }, 377 [C_SHUTDOWN_R] = { 378 0, 0, 0, 0, 379 0, 0, 0, 0, 380 0, 0, 0, 0, 381 0, 0, 0, 0, 382 0, 0, 0, 0, 383 0, 0, 0, 0, 384 0, 0, 0, 0, 385 0, 0, 0, 0, 386 0, 0, 0, 0, 387 }, 388 [C_SHUTDOWN_RW] = { 389 0, 0, 0, 0, 390 0, 0, 0, 0, 391 0, 0, 0, 0, 392 0, 0, 0, 0, 393 0, 0, 0, 0, 394 0, 0, 0, 0, 395 0, 0, 0, 0, 396 0, 0, 0, 0, 397 0, 0, 0, 0, 398 }, 399 [C_SHUTDOWN_W] = { 400 0, 0, 0, 0, 401 0, 0, 0, 0, 402 0, 0, 0, 0, 403 0, 0, 0, 0, 404 0, 0, 0, 0, 405 0, 0, 0, 0, 406 0, 0, 0, 0, 407 0, 0, 0, 0, 408 0, 0, 0, 0, 409 }, 410 }; 411 412 /* 413 * Set up a connection-oriented socket file descriptor in the requested state 414 * and pass it to socklib_sweep_call() along with local and remote addresses 415 * and their length. 416 */ 417 static int 418 unix_connect_sweep(int domain, int type, int protocol __unused, 419 enum state state, enum call call) 420 { 421 struct sockaddr_un sunA, sunB, sunC; 422 char buf[1]; 423 socklen_t len; 424 fd_set fds; 425 int r, fd, fd2, fd3, tmpfd, val, fl; 426 427 (void)unlink(SOCK_PATH_A); 428 (void)unlink(SOCK_PATH_B); 429 (void)unlink(SOCK_PATH_C); 430 431 memset(&sunA, 0, sizeof(sunA)); 432 sunA.sun_family = AF_UNIX; 433 strlcpy(sunA.sun_path, SOCK_PATH_A, sizeof(sunA.sun_path)); 434 435 fd = fd3 = -1; 436 437 fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B, &sunB); 438 439 if (listen(fd2, 1) == -1) e(0); 440 441 switch (state) { 442 case S_NEW: 443 case S_N_SHUT_R: 444 case S_N_SHUT_W: 445 case S_N_SHUT_RW: 446 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 447 448 switch (state) { 449 case S_N_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break; 450 case S_N_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break; 451 case S_N_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 452 default: break; 453 } 454 455 break; 456 457 case S_BOUND: 458 case S_LISTENING: 459 case S_L_SHUT_R: 460 case S_L_SHUT_W: 461 case S_L_SHUT_RW: 462 fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A, 463 &sunA); 464 465 if (state == S_BOUND) 466 break; 467 468 if (listen(fd, 1) == -1) e(0); 469 470 switch (state) { 471 case S_L_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break; 472 case S_L_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break; 473 case S_L_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 474 default: break; 475 } 476 477 break; 478 479 case S_CONNECTING: 480 /* 481 * The following block is nonportable. On NetBSD, the 482 * LOCAL_CONNWAIT socket option is present but seems somewhat.. 483 * under-tested. On Linux, it is not possible to put a UNIX 484 * domain socket in a connecting state. 485 */ 486 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 487 488 val = 1; 489 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) 490 e(0); 491 492 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != -1) 493 e(0); 494 if (errno != EINPROGRESS) e(0); 495 496 break; 497 498 case S_CONNECTED: 499 case S_ACCEPTED: 500 case S_SHUT_R: 501 case S_SHUT_W: 502 case S_SHUT_RW: 503 case S_RSHUT_R: 504 case S_RSHUT_W: 505 case S_RSHUT_RW: 506 case S_SHUT2_R: 507 case S_SHUT2_W: 508 case S_SHUT2_RW: 509 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 510 511 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) 512 e(0); 513 514 len = sizeof(sunC); 515 if ((fd3 = accept(fd2, (struct sockaddr *)&sunC, &len)) < 0) 516 e(0); 517 518 if ((fl = fcntl(fd3, F_GETFL)) == -1) e(0); 519 if (fcntl(fd3, F_SETFL, fl | O_NONBLOCK) != 0) e(0); 520 521 /* Just to make sure, wait for the socket to be connected. */ 522 FD_ZERO(&fds); 523 FD_SET(fd, &fds); 524 if (select(fd + 1, NULL, &fds, NULL, NULL) != 1) e(0); 525 526 switch (state) { 527 case S_SHUT_R: 528 case S_SHUT2_R: if (shutdown(fd, SHUT_RD)) e(0); break; 529 case S_SHUT_W: 530 case S_SHUT2_W: if (shutdown(fd, SHUT_WR)) e(0); break; 531 case S_SHUT_RW: 532 case S_SHUT2_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 533 default: break; 534 } 535 536 switch (state) { 537 case S_RSHUT_R: 538 case S_SHUT2_R: if (shutdown(fd3, SHUT_RD)) e(0); break; 539 case S_RSHUT_W: 540 case S_SHUT2_W: if (shutdown(fd3, SHUT_WR)) e(0); break; 541 case S_RSHUT_RW: 542 case S_SHUT2_RW: if (shutdown(fd3, SHUT_RDWR)) e(0); break; 543 default: break; 544 } 545 546 if (state == S_ACCEPTED) { 547 tmpfd = fd; 548 fd = fd3; 549 fd3 = tmpfd; 550 } 551 552 break; 553 554 case S_PRE_EOF: 555 case S_AT_EOF: 556 case S_POST_EOF: 557 case S_PRE_SHUT_R: 558 case S_EOF_SHUT_R: 559 case S_POST_SHUT_R: 560 case S_PRE_SHUT_W: 561 case S_EOF_SHUT_W: 562 case S_POST_SHUT_W: 563 case S_PRE_SHUT_RW: 564 case S_EOF_SHUT_RW: 565 case S_POST_SHUT_RW: 566 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 567 568 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) 569 e(0); 570 571 len = sizeof(sunC); 572 if ((fd3 = accept(fd2, (struct sockaddr *)&sunC, &len)) < 0) 573 e(0); 574 575 if ((fl = fcntl(fd3, F_GETFL)) == -1) e(0); 576 if (fcntl(fd3, F_SETFL, fl | O_NONBLOCK) != 0) e(0); 577 578 if (send(fd3, "", 1, 0) != 1) e(0); 579 580 if (close(fd3) != 0) e(0); 581 fd3 = -1; 582 583 FD_ZERO(&fds); 584 FD_SET(fd, &fds); 585 if (select(fd + 1, &fds, NULL, NULL, NULL) != 1) e(0); 586 587 switch (state) { 588 case S_AT_EOF: 589 case S_EOF_SHUT_R: 590 case S_EOF_SHUT_W: 591 case S_EOF_SHUT_RW: 592 if (recv(fd, buf, sizeof(buf), 0) != 1) e(0); 593 break; 594 case S_POST_EOF: 595 case S_POST_SHUT_R: 596 case S_POST_SHUT_W: 597 case S_POST_SHUT_RW: 598 if (recv(fd, buf, sizeof(buf), 0) != 1) e(0); 599 if (recv(fd, buf, sizeof(buf), 0) != 0) e(0); 600 break; 601 default: 602 break; 603 } 604 605 switch (state) { 606 case S_PRE_SHUT_R: 607 case S_EOF_SHUT_R: 608 case S_POST_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break; 609 case S_PRE_SHUT_W: 610 case S_EOF_SHUT_W: 611 case S_POST_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break; 612 case S_PRE_SHUT_RW: 613 case S_EOF_SHUT_RW: 614 case S_POST_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 615 default: break; 616 } 617 618 break; 619 620 case S_AT_RESET: 621 case S_POST_RESET: 622 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 623 624 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) 625 e(0); 626 627 /* 628 * Closing the listening socket before the connection has been 629 * accepted should generate ECONNRESET on the connected socket. 630 * Well, should.. we choose to do that. So does Linux. NetBSD 631 * just returns EOF for that case. There are really no strong 632 * arguments for either behavior. 633 */ 634 if (close(fd2) != 0) e(0); 635 636 if (state == S_POST_RESET) 637 (void)recv(fd, buf, sizeof(buf), 0); 638 639 /* Recreate the listening socket just for consistency. */ 640 fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B, 641 &sunB); 642 643 if (listen(fd2, 1) == -1) e(0); 644 645 break; 646 647 case S_POST_FAILED: 648 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 649 650 memset(&sunC, 0, sizeof(sunC)); 651 sunC.sun_family = AF_UNIX; 652 strlcpy(sunC.sun_path, SOCK_PATH_C, sizeof(sunC.sun_path)); 653 654 r = connect(fd, (struct sockaddr *)&sunC, sizeof(sunC)); 655 if (r != -1 || errno != ENOENT) 656 e(0); 657 658 break; 659 660 default: 661 e(0); 662 } 663 664 r = socklib_sweep_call(call, fd, (struct sockaddr *)&sunA, 665 (struct sockaddr *)&sunB, sizeof(struct sockaddr_un)); 666 667 if (fd >= 0 && close(fd) != 0) e(0); 668 if (fd2 >= 0 && close(fd2) != 0) e(0); 669 if (fd3 >= 0 && close(fd3) != 0) e(0); 670 671 (void)unlink(SOCK_PATH_A); 672 (void)unlink(SOCK_PATH_B); 673 674 return r; 675 } 676 677 static const enum state unix_dgram_states[] = { 678 S_NEW, S_N_SHUT_R, S_N_SHUT_W, S_N_SHUT_RW, 679 S_BOUND, S_CONNECTED, S_SHUT_R, S_SHUT_W, 680 S_SHUT_RW, S_RSHUT_R, S_RSHUT_W, S_RSHUT_RW, 681 S_SHUT2_R, S_SHUT2_W, S_SHUT2_RW, S_PRE_RESET, 682 S_AT_RESET, S_POST_RESET 683 }; 684 685 static const int unix_dgram_results[][__arraycount(unix_dgram_states)] = { 686 [C_ACCEPT] = { 687 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 688 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 689 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 690 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 691 -EOPNOTSUPP, -EOPNOTSUPP, 692 }, 693 [C_BIND] = { 694 0, 0, 0, 0, 695 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 696 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 697 -EINVAL, -EINVAL, -EINVAL, -EINVAL, 698 -EINVAL, -EINVAL, 699 }, 700 [C_CONNECT] = { 701 0, 0, 0, 0, 702 0, 0, 0, 0, 703 0, 0, 0, 0, 704 0, 0, 0, -ECONNREFUSED, 705 -ECONNREFUSED, -ECONNREFUSED, 706 }, 707 [C_GETPEERNAME] = { 708 -ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN, 709 -ENOTCONN, 0, 0, 0, 710 0, 0, 0, 0, 711 0, 0, 0, -ENOTCONN, 712 -ENOTCONN, -ENOTCONN, 713 }, 714 [C_GETSOCKNAME] = { 715 0, 0, 0, 0, 716 0, 0, 0, 0, 717 0, 0, 0, 0, 718 0, 0, 0, 0, 719 0, 0, 720 }, 721 [C_GETSOCKOPT_ERR] = { 722 0, 0, 0, 0, 723 0, 0, 0, 0, 724 0, 0, 0, 0, 725 0, 0, 0, -ECONNRESET, 726 -ECONNRESET, 0, 727 }, 728 [C_GETSOCKOPT_KA] = { 729 0, 0, 0, 0, 730 0, 0, 0, 0, 731 0, 0, 0, 0, 732 0, 0, 0, 0, 733 0, 0, 734 }, 735 [C_GETSOCKOPT_RB] = { 736 0, 0, 0, 0, 737 0, 0, 0, 0, 738 0, 0, 0, 0, 739 0, 0, 0, 0, 740 0, 0, 741 }, 742 [C_IOCTL_NREAD] = { 743 0, 0, 0, 0, 744 0, 0, 0, 0, 745 0, 0, 0, 0, 746 0, 0, 0, 1, 747 0, 0, 748 }, 749 [C_LISTEN] = { 750 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 751 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 752 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 753 -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, 754 -EOPNOTSUPP, -EOPNOTSUPP, 755 }, 756 [C_RECV] = { 757 -EAGAIN, 0, -EAGAIN, 0, 758 -EAGAIN, -EAGAIN, 0, -EAGAIN, 759 0, -EAGAIN, -EAGAIN, -EAGAIN, 760 0, -EAGAIN, 0, 1, 761 -ECONNRESET, -EAGAIN, 762 }, 763 [C_RECVFROM] = { 764 -EAGAIN, 0, -EAGAIN, 0, 765 -EAGAIN, -EAGAIN, 0, -EAGAIN, 766 0, -EAGAIN, -EAGAIN, -EAGAIN, 767 0, -EAGAIN, 0, 1, 768 -ECONNRESET, -EAGAIN, 769 }, 770 [C_SEND] = { 771 -EDESTADDRREQ, -EDESTADDRREQ, -EPIPE, -EPIPE, 772 -EDESTADDRREQ, 1, 1, -EPIPE, 773 -EPIPE, -ENOBUFS, 1, -ENOBUFS, 774 -ENOBUFS, -EPIPE, -EPIPE, -ECONNRESET, 775 -ECONNRESET, -EDESTADDRREQ, 776 }, 777 [C_SENDTO] = { 778 1, 1, -EPIPE, -EPIPE, 779 1, 1, 1, -EPIPE, 780 -EPIPE, -ENOBUFS, 1, -ENOBUFS, 781 -ENOBUFS, -EPIPE, -EPIPE, -ECONNRESET, 782 -ECONNRESET, -ECONNREFUSED, 783 }, 784 [C_SELECT_R] = { 785 0, 1, 0, 1, 786 0, 0, 1, 0, 787 1, 0, 0, 0, 788 1, 0, 1, 1, 789 1, 0, 790 }, 791 [C_SELECT_W] = { 792 1, 1, 1, 1, 793 1, 1, 1, 1, 794 1, 1, 1, 1, 795 1, 1, 1, 1, 796 1, 1, 797 }, 798 [C_SELECT_X] = { 799 0, 0, 0, 0, 800 0, 0, 0, 0, 801 0, 0, 0, 0, 802 0, 0, 0, 0, 803 0, 0, 804 }, 805 [C_SETSOCKOPT_BC] = { 806 0, 0, 0, 0, 807 0, 0, 0, 0, 808 0, 0, 0, 0, 809 0, 0, 0, 0, 810 0, 0, 811 }, 812 [C_SETSOCKOPT_KA] = { 813 0, 0, 0, 0, 814 0, 0, 0, 0, 815 0, 0, 0, 0, 816 0, 0, 0, 0, 817 0, 0, 818 }, 819 [C_SETSOCKOPT_L] = { 820 0, 0, 0, 0, 821 0, 0, 0, 0, 822 0, 0, 0, 0, 823 0, 0, 0, 0, 824 0, 0, 825 }, 826 [C_SETSOCKOPT_RA] = { 827 0, 0, 0, 0, 828 0, 0, 0, 0, 829 0, 0, 0, 0, 830 0, 0, 0, 0, 831 0, 0, 832 }, 833 [C_SHUTDOWN_R] = { 834 0, 0, 0, 0, 835 0, 0, 0, 0, 836 0, 0, 0, 0, 837 0, 0, 0, 0, 838 0, 0, 839 }, 840 [C_SHUTDOWN_RW] = { 841 0, 0, 0, 0, 842 0, 0, 0, 0, 843 0, 0, 0, 0, 844 0, 0, 0, 0, 845 0, 0, 846 }, 847 [C_SHUTDOWN_W] = { 848 0, 0, 0, 0, 849 0, 0, 0, 0, 850 0, 0, 0, 0, 851 0, 0, 0, 0, 852 0, 0, 853 }, 854 }; 855 856 /* 857 * Set up a datagram socket file descriptor in the requested state and pass it 858 * to socklib_sweep_call() along with local and remote addresses and their 859 * length. 860 */ 861 static int 862 unix_dgram_sweep(int domain __unused, int type, int protocol __unused, 863 enum state state, enum call call) 864 { 865 struct sockaddr_un sunA, sunB; 866 char buf[1]; 867 int r, fd, fd2; 868 869 (void)unlink(SOCK_PATH_A); 870 (void)unlink(SOCK_PATH_B); 871 872 /* Create a bound remote socket. */ 873 fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B, &sunB); 874 875 switch (state) { 876 case S_NEW: 877 case S_N_SHUT_R: 878 case S_N_SHUT_W: 879 case S_N_SHUT_RW: 880 memset(&sunA, 0, sizeof(sunA)); 881 sunA.sun_family = AF_UNIX; 882 strlcpy(sunA.sun_path, SOCK_PATH_A, sizeof(sunA.sun_path)); 883 884 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) 885 e(0); 886 887 switch (state) { 888 case S_N_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break; 889 case S_N_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break; 890 case S_N_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 891 default: break; 892 } 893 894 break; 895 896 case S_BOUND: 897 case S_CONNECTED: 898 case S_SHUT_R: 899 case S_SHUT_W: 900 case S_SHUT_RW: 901 case S_RSHUT_R: 902 case S_RSHUT_W: 903 case S_RSHUT_RW: 904 case S_SHUT2_R: 905 case S_SHUT2_W: 906 case S_SHUT2_RW: 907 case S_PRE_RESET: 908 case S_AT_RESET: 909 case S_POST_RESET: 910 fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A, 911 &sunA); 912 913 if (state == S_BOUND) 914 break; 915 916 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) 917 e(0); 918 919 switch (state) { 920 case S_SHUT_R: 921 case S_SHUT2_R: if (shutdown(fd, SHUT_RD)) e(0); break; 922 case S_SHUT_W: 923 case S_SHUT2_W: if (shutdown(fd, SHUT_WR)) e(0); break; 924 case S_SHUT_RW: 925 case S_SHUT2_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break; 926 default: break; 927 } 928 929 switch (state) { 930 case S_RSHUT_R: 931 case S_SHUT2_R: if (shutdown(fd2, SHUT_RD)) e(0); break; 932 case S_RSHUT_W: 933 case S_SHUT2_W: if (shutdown(fd2, SHUT_WR)) e(0); break; 934 case S_RSHUT_RW: 935 case S_SHUT2_RW: if (shutdown(fd2, SHUT_RDWR)) e(0); break; 936 case S_PRE_RESET: 937 case S_AT_RESET: 938 case S_POST_RESET: 939 if (sendto(fd2, "", 1, 0, (struct sockaddr *)&sunA, 940 sizeof(sunA)) != 1) e(0); 941 942 if (close(fd2) != 0) e(0); 943 fd2 = -1; 944 945 if (state != S_PRE_RESET) { 946 if (recv(fd, buf, sizeof(buf), 0) != 1) e(0); 947 } 948 if (state == S_POST_RESET) { 949 (void)recv(fd, buf, sizeof(buf), 0); 950 } 951 default: 952 break; 953 } 954 955 break; 956 957 default: 958 fd = -1; 959 e(0); 960 } 961 962 r = socklib_sweep_call(call, fd, (struct sockaddr *)&sunA, 963 (struct sockaddr *)&sunB, sizeof(struct sockaddr_un)); 964 965 if (close(fd) != 0) e(0); 966 if (fd2 != -1 && close(fd2) != 0) e(0); 967 968 (void)unlink(SOCK_PATH_A); 969 (void)unlink(SOCK_PATH_B); 970 971 return r; 972 } 973 974 /* 975 * Sweep test for socket calls versus socket states of all socket types. 976 */ 977 static void 978 test90a(void) 979 { 980 981 subtest = 1; 982 983 socklib_sweep(AF_UNIX, SOCK_STREAM, 0, unix_connect_states, 984 __arraycount(unix_connect_states), 985 (const int *)unix_connect_results, unix_connect_sweep); 986 987 socklib_sweep(AF_UNIX, SOCK_SEQPACKET, 0, unix_connect_states, 988 __arraycount(unix_connect_states), 989 (const int *)unix_connect_results, unix_connect_sweep); 990 991 socklib_sweep(AF_UNIX, SOCK_DGRAM, 0, unix_dgram_states, 992 __arraycount(unix_dgram_states), (const int *)unix_dgram_results, 993 unix_dgram_sweep); 994 995 } 996 997 /* 998 * Test for large sends and receives with MSG_WAITALL. 999 */ 1000 static void 1001 test90b(void) 1002 { 1003 int fd[2]; 1004 1005 subtest = 2; 1006 1007 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0); 1008 1009 socklib_large_transfers(fd); 1010 } 1011 1012 /* 1013 * A randomized producer-consumer test for datagram sockets. 1014 */ 1015 static void 1016 sub90c(int type) 1017 { 1018 char *buf; 1019 time_t t; 1020 socklen_t len, size; 1021 ssize_t r; 1022 pid_t pid; 1023 unsigned int count; 1024 int i, fd[2], rcvlen, status, exp, flags, num, stat[2] = { 0, 0 }; 1025 1026 get_socket_pair(type, fd); 1027 1028 size = rcvlen = get_rcvbuf_len(fd[0]); 1029 1030 if ((buf = malloc(size)) == NULL) e(0); 1031 1032 t = time(NULL); 1033 1034 /* 1035 * We vary small versus large (random) send and receive sizes, 1036 * splitting the entire transfer in four phases along those lines. 1037 * 1038 * In theory, the use of an extra system call and the use of MSG_PEEK 1039 * both contribute to the expectation that the consumer side will fall 1040 * behind the producer. In this case, we cannot vary receive sizes to 1041 * compensate. This not appear to be a major problem here, though. 1042 */ 1043 #define NR_PACKETS (256 * 1024) 1044 1045 pid = fork(); 1046 switch (pid) { 1047 case 0: 1048 errct = 0; 1049 1050 if (close(fd[0]) != 0) e(0); 1051 1052 srand48(t + 1); 1053 1054 for (count = 0; count < NR_PACKETS; ) { 1055 if (count < NR_PACKETS / 2) 1056 len = lrand48() % 64; 1057 else 1058 len = lrand48() % size; 1059 1060 num = lrand48() % 16; 1061 flags = 0; 1062 if (num & 1) flags |= MSG_PEEK; 1063 if (num & 2) flags |= MSG_WAITALL; 1064 if (num & 4) flags |= MSG_DONTWAIT; 1065 if (num & 8) { 1066 /* 1067 * Obviously there are race conditions here but 1068 * the returned number should be accurate if 1069 * not zero. Hopefully it's not always zero. 1070 */ 1071 if (ioctl(fd[1], FIONREAD, &exp) != 0) e(0); 1072 if (exp < 0 || exp > rcvlen) e(0); 1073 } else 1074 exp = 0; 1075 1076 stat[0]++; 1077 1078 /* 1079 * A lame approach to preventing unbounded spinning on 1080 * ENOBUFS on the producer side. 1081 */ 1082 if (type == SOCK_DGRAM) 1083 (void)send(fd[1], "", 1, MSG_DONTWAIT); 1084 1085 if ((r = recv(fd[1], buf, len, flags)) == -1) { 1086 if (errno != EWOULDBLOCK) e(0); 1087 if (exp > 0) e(0); 1088 1089 stat[1]++; 1090 1091 continue; 1092 } 1093 1094 if (exp != 0) { 1095 if (r == len && exp < r) e(0); 1096 else if (r < len && exp != r) e(0); 1097 } 1098 1099 if (r >= 2 && 1100 r > ((size_t)(unsigned char)buf[0] << 8) + 1101 (size_t)(unsigned char)buf[1]) e(0); 1102 1103 for (i = 2; i < r; i++) 1104 if (buf[i] != (char)i) e(0); 1105 1106 if (!(flags & MSG_PEEK)) 1107 count++; 1108 } 1109 1110 #if PRINT_STATS 1111 /* 1112 * The second and third numbers should ideally be a large but 1113 * non-dominating fraction of the first one. 1114 */ 1115 printf("RECV: total %d again %d\n", stat[0], stat[1]); 1116 #endif 1117 1118 if (close(fd[1]) != 0) e(0); 1119 exit(errct); 1120 case -1: 1121 e(0); 1122 } 1123 1124 if (close(fd[1]) != 0) e(0); 1125 1126 srand48(t); 1127 1128 for (count = 0; count < NR_PACKETS; ) { 1129 if (count < NR_PACKETS / 4 || 1130 (count >= NR_PACKETS / 2 && count < NR_PACKETS * 3 / 4)) 1131 len = lrand48() % 64; 1132 else 1133 len = lrand48() % size; 1134 1135 buf[0] = (len >> 8) & 0xff; 1136 buf[1] = len & 0xff; 1137 for (i = 2; i < len; i++) 1138 buf[i] = i; 1139 1140 flags = (lrand48() % 2) ? MSG_DONTWAIT : 0; 1141 1142 r = send(fd[0], buf, len, flags); 1143 1144 if (r != len) { 1145 if (r != -1) e(0); 1146 1147 if (errno != EMSGSIZE && errno != EWOULDBLOCK && 1148 errno != ENOBUFS) e(0); 1149 1150 if (errno == ENOBUFS || errno == EWOULDBLOCK) { 1151 /* 1152 * As stated above: lame. Ideally we would 1153 * continue only when the receiver side drains 1154 * the queue, but it may block once it has done 1155 * so. Instead, by going through consumer 1156 * "tokens" we will ultimately block here and 1157 * let the receiver catch up. 1158 */ 1159 if (type == SOCK_DGRAM && errno == ENOBUFS) 1160 (void)recv(fd[0], buf, 1, 0); 1161 1162 stat[0]++; 1163 stat[1]++; 1164 } 1165 continue; 1166 } else 1167 stat[0]++; 1168 1169 if (count % (NR_PACKETS / 4) == 0) 1170 sleep(1); 1171 1172 count++; 1173 } 1174 1175 #if PRINT_STATS 1176 /* 1177 * The second number should ideally be a large but non-dominating 1178 * fraction of the first one. 1179 */ 1180 printf("SEND: total %d again %d\n", stat[0], stat[1]); 1181 #endif 1182 1183 free(buf); 1184 1185 if (close(fd[0]) != 0) e(0); 1186 1187 if (waitpid(pid, &status, 0) != pid) e(0); 1188 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1189 } 1190 1191 /* 1192 * A randomized producer-consumer test. As part of this, we also perform very 1193 * basic bulk functionality tests of FIONREAD, MSG_PEEK, MSG_DONTWAIT, and 1194 * MSG_WAITALL. 1195 */ 1196 static void 1197 test90c(void) 1198 { 1199 int fd[2]; 1200 1201 subtest = 4; 1202 1203 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0); 1204 1205 socklib_producer_consumer(fd); 1206 1207 sub90c(SOCK_SEQPACKET); 1208 1209 sub90c(SOCK_DGRAM); 1210 } 1211 1212 /* 1213 * Test that immediately accepted non-blocking connect requests to a listening 1214 * socket with LOCAL_CONNWAIT turned on, return OK rather than EINPROGRESS. 1215 * This requires a hack in libsockevent. 1216 */ 1217 static void 1218 test90d(void) 1219 { 1220 struct sockaddr_un sunA, sunB; 1221 socklen_t len; 1222 pid_t pid; 1223 int fd, fd2, fd3, val, status; 1224 1225 subtest = 4; 1226 1227 /* 1228 * First ensure that a non-blocking connect to a listening socket that 1229 * does not have a accept call blocked on it, fails with EINPROGRESS. 1230 */ 1231 fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA); 1232 1233 val = 1; 1234 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 1235 1236 if (listen(fd, 1) != 0) e(0); 1237 1238 if ((fd2 = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) < 0) e(0); 1239 1240 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0); 1241 if (errno != EINPROGRESS) e(0); 1242 1243 len = sizeof(sunB); 1244 if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0); 1245 check_addr(&sunB, len, NULL); 1246 1247 if (close(fd) != 0) e(0); 1248 if (close(fd2) != 0) e(0); 1249 if (close(fd3) != 0) e(0); 1250 1251 if (unlink(SOCK_PATH_A) != 0) e(0); 1252 1253 /* 1254 * Second, ensure that a blocking connect eventually does return 1255 * success if an accept call is made later on. 1256 */ 1257 fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA); 1258 1259 val = 1; 1260 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 1261 1262 if (listen(fd, 1) != 0) e(0); 1263 1264 pid = fork(); 1265 switch (pid) { 1266 case 0: 1267 errct = 0; 1268 1269 sleep(1); 1270 1271 len = sizeof(sunB); 1272 if ((fd2 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) 1273 e(0); 1274 check_addr(&sunB, len, NULL); 1275 1276 exit(errct); 1277 case -1: 1278 e(0); 1279 } 1280 1281 if (close(fd) != 0) e(0); 1282 1283 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0); 1284 1285 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 1286 1287 if (close(fd) != 0) e(0); 1288 1289 if (unlink(SOCK_PATH_A) != 0) e(0); 1290 1291 if (waitpid(pid, &status, 0) != pid) e(0); 1292 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1293 1294 /* 1295 * Finally, test the most implementation-complex case: a non-blocking 1296 * connect should succeed (i.e., yield return code 0) immediately if 1297 * there is a accept call blocked on it. 1298 */ 1299 fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA); 1300 1301 val = 1; 1302 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 1303 1304 if (listen(fd, 1) != 0) e(0); 1305 1306 pid = fork(); 1307 switch (pid) { 1308 case 0: 1309 errct = 0; 1310 1311 len = sizeof(sunB); 1312 if ((fd2 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) 1313 e(0); 1314 check_addr(&sunB, len, SOCK_PATH_B); 1315 1316 exit(errct); 1317 case -1: 1318 e(0); 1319 } 1320 1321 if (close(fd) != 0) e(0); 1322 1323 sleep(1); 1324 1325 fd = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_B, &sunB); 1326 1327 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 1328 1329 if (close(fd) != 0) e(0); 1330 1331 if (waitpid(pid, &status, 0) != pid) e(0); 1332 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1333 1334 if (unlink(SOCK_PATH_A) != 0) e(0); 1335 if (unlink(SOCK_PATH_B) != 0) e(0); 1336 } 1337 1338 /* 1339 * Test self-connecting datagram sockets. 1340 */ 1341 static void 1342 test90e(void) 1343 { 1344 struct sockaddr_un sunA, sunB, sunC; 1345 socklen_t len; 1346 char buf[3]; 1347 pid_t pid; 1348 int fdA, fdB, val, status; 1349 1350 subtest = 5; 1351 1352 fdA = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA); 1353 fdB = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB); 1354 1355 /* Connect the socket to itself, and attempt to communicate. */ 1356 if (connect(fdA, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 1357 1358 if (send(fdA, "abc", 3, 0) != 3) e(0); 1359 1360 if (recv(fdA, buf, sizeof(buf), 0) != 3) e(0); 1361 if (strncmp(buf, "abc", 3)) e(0); 1362 1363 /* Reconnect the socket to another target. */ 1364 if (connect(fdA, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0); 1365 1366 len = sizeof(val); 1367 if (getsockopt(fdA, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 1368 if (val != 0) e(0); 1369 1370 if (send(fdA, "def", 3, 0) != 3) e(0); 1371 1372 memset(&sunC, 0, sizeof(sunC)); 1373 len = sizeof(sunC); 1374 if (recvfrom(fdB, buf, sizeof(buf), 0, (struct sockaddr *)&sunC, 1375 &len) != 3) e(0); 1376 check_addr(&sunC, len, SOCK_PATH_A); 1377 if (strncmp(buf, "def", 3)) e(0); 1378 1379 /* Reconnect the socket to itself again. */ 1380 if (connect(fdA, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 1381 1382 len = sizeof(val); 1383 if (getsockopt(fdA, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 1384 if (val != 0) e(0); 1385 1386 pid = fork(); 1387 switch (pid) { 1388 case 0: 1389 errct = 0; 1390 1391 if (recv(fdA, buf, sizeof(buf), 0) != 3) e(0); 1392 if (strncmp(buf, "ghi", 3)) e(0); 1393 1394 exit(errct); 1395 case -1: 1396 e(0); 1397 } 1398 1399 sleep(1); 1400 1401 if (send(fdA, "ghi", 3, 0) != 3) e(0); 1402 1403 if (waitpid(pid, &status, 0) != pid) e(0); 1404 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1405 1406 if (close(fdA) != 0) e(0); 1407 if (close(fdB) != 0) e(0); 1408 1409 if (unlink(SOCK_PATH_A) != 0) e(0); 1410 if (unlink(SOCK_PATH_B) != 0) e(0); 1411 } 1412 1413 /* 1414 * Test multiple blocked calls getting resumed (or not) upon connect(2) success 1415 * or failure. This test uses LOCAL_CONNWAIT. TODO: rewrite this to use 1416 * interprocess communication rather than the current carefully arranged and 1417 * rather brittle timing approach. 1418 */ 1419 static void 1420 sub90f(unsigned int test) 1421 { 1422 struct sockaddr_un sun; 1423 pid_t pid[4], apid; 1424 char buf[1]; 1425 unsigned int i; 1426 socklen_t len; 1427 int r, fd, fd2, fl, val, status; 1428 1429 fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sun); 1430 1431 val = 1; 1432 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 1433 1434 if (listen(fd, 1) != 0) e(0); 1435 1436 apid = fork(); 1437 switch (apid) { 1438 case 0: 1439 errct = 0; 1440 1441 sleep(3); 1442 1443 if (test < 2) { 1444 len = sizeof(sun); 1445 if ((fd2 = accept(fd, (struct sockaddr *)&sun, 1446 &len)) < 0) e(0); 1447 1448 sleep(2); 1449 1450 if (close(fd2) != 0) e(0); 1451 } 1452 1453 if (close(fd) != 0) e(0); 1454 1455 exit(errct); 1456 case -1: 1457 e(0); 1458 } 1459 1460 if (close(fd) != 0) e(0); 1461 1462 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0); 1463 1464 for (i = 0; i < __arraycount(pid); i++) { 1465 pid[i] = fork(); 1466 switch (pid[i]) { 1467 case 0: 1468 errct = 0; 1469 1470 sleep((i == 0) ? 1 : 2); 1471 1472 if ((i & 1) == 0) { 1473 r = send(fd, "", 1, 0); 1474 1475 switch (test) { 1476 case 0: 1477 case 1: 1478 if (r != 1) e(0); 1479 break; 1480 case 3: 1481 if (i == 0) { 1482 if (r != -1) e(0); 1483 if (errno != ECONNRESET) e(0); 1484 break; 1485 } 1486 /* FALLTHROUGH */ 1487 case 2: 1488 if (r != -1) e(0); 1489 if (errno != ENOTCONN) e(0); 1490 } 1491 } else { 1492 r = recv(fd, buf, sizeof(buf), 0); 1493 1494 if (test >= 2) { 1495 if (r != -1) e(0); 1496 if (errno != ENOTCONN) e(0); 1497 } else 1498 if (r != 0) e(0); 1499 } 1500 1501 exit(errct); 1502 case -1: 1503 e(0); 1504 } 1505 } 1506 1507 if (test & 1) { 1508 if ((fl = fcntl(fd, F_GETFL)) == -1) e(0); 1509 if (fcntl(fd, F_SETFL, fl | O_NONBLOCK) != 0) e(0); 1510 } 1511 1512 r = connect(fd, (struct sockaddr *)&sun, sizeof(sun)); 1513 1514 if (test & 1) { 1515 if (r != -1) e(0); 1516 if (errno != EINPROGRESS) e(0); 1517 1518 if (fcntl(fd, F_SETFL, fl) != 0) e(0); 1519 1520 sleep(4); 1521 } else { 1522 if (test >= 2) { 1523 if (r != -1) e(0); 1524 if (errno != ECONNRESET) e(0); 1525 } else 1526 if (r != 0) e(0); 1527 1528 sleep(1); 1529 } 1530 1531 /* 1532 * If the connect failed, collect the senders and receivers. 1533 * Otherwise, collect just the senders. 1534 */ 1535 for (i = 0; i < __arraycount(pid); i++) { 1536 r = waitpid(pid[i], &status, WNOHANG); 1537 if (r == pid[i]) { 1538 if (test < 2 && (i & 1)) e(0); 1539 if (!WIFEXITED(status)) e(0); 1540 if (WEXITSTATUS(status) != 0) e(0); 1541 } else if (r == 0) { 1542 if (test >= 2 || !(i & 1)) e(0); 1543 } else 1544 e(0); 1545 } 1546 1547 if (close(fd) != 0) e(0); 1548 1549 /* Wait for, and collect the accepting child. */ 1550 if (waitpid(apid, &status, 0) != apid) e(0); 1551 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1552 1553 /* 1554 * If the connect succeeded, collect the receivers, which will 1555 * terminate once the accepting child closes the accepted socket. 1556 */ 1557 if (test < 2) { 1558 if (waitpid(pid[1], &status, 0) != pid[1]) e(0); 1559 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1560 if (waitpid(pid[3], &status, 0) != pid[3]) e(0); 1561 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 1562 } 1563 1564 if (unlink(SOCK_PATH_A) != 0) e(0); 1565 } 1566 1567 /* 1568 * Test multiple blocked calls getting resumed (or not) upon connect(2) success 1569 * or failure. In particular, ensure that the error code ends up with the 1570 * right call. 1571 */ 1572 static void 1573 test90f(void) 1574 { 1575 1576 subtest = 6; 1577 1578 /* If a connect succeeds, sends continue but reads block until EOF. */ 1579 sub90f(0); /* blocking connect */ 1580 sub90f(1); /* non-blocking connect */ 1581 1582 /* If a blocking connect fails, the connect call gets the error. */ 1583 sub90f(2); 1584 1585 /* If a non-blocking connect fails, the first blocked call gets it. */ 1586 sub90f(3); 1587 } 1588 1589 /* 1590 * Test whether various calls all return the same expected error code. 1591 */ 1592 static void 1593 sub90g(struct sockaddr_un * sun, int err) 1594 { 1595 int fd; 1596 1597 if ((fd = socket(AF_UNIX, SOCK_SEQPACKET, 0)) < 0) e(0); 1598 1599 if (connect(fd, (struct sockaddr *)sun, sizeof(*sun)) != -1) e(0); 1600 if (errno != err) e(0); 1601 1602 if (close(fd) != 0) e(0); 1603 1604 if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0); 1605 1606 if (sendto(fd, "", 1, 0, (struct sockaddr *)sun, sizeof(*sun)) != -1) 1607 e(0); 1608 if (errno != err) e(0); 1609 1610 if (connect(fd, (struct sockaddr *)sun, sizeof(*sun)) != -1) e(0); 1611 if (errno != err) e(0); 1612 1613 if (close(fd) != 0) e(0); 1614 } 1615 1616 /* 1617 * Test for error codes thrown by connect(2) and sendto(2) with problematic 1618 * destinations. In particular, we verify that the errors for sendto(2) are 1619 * the same as for connect(2), just like on NetBSD and Linux, even though 1620 * POSIX does not document all of these under sendto(2). 1621 */ 1622 static void 1623 test90g(void) 1624 { 1625 struct sockaddr_un sun; 1626 int fd; 1627 1628 subtest = 7; 1629 1630 fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sun); 1631 1632 sub90g(&sun, EPROTOTYPE); 1633 1634 if (listen(fd, 1) != 0) e(0); 1635 1636 sub90g(&sun, EPROTOTYPE); 1637 1638 if (close(fd) != 0) e(0); 1639 1640 sub90g(&sun, ECONNREFUSED); 1641 1642 if (unlink(SOCK_PATH_A) != 0) e(0); 1643 1644 sub90g(&sun, ENOENT); 1645 } 1646 1647 /* 1648 * Test addresses returned for unbound connection-type sockets by various 1649 * calls. 1650 */ 1651 static void 1652 sub90h(int type) 1653 { 1654 struct sockaddr_un sun; 1655 socklen_t len; 1656 char buf[1]; 1657 int fd, fd2, fd3; 1658 1659 fd = get_bound_socket(type, SOCK_PATH_A, &sun); 1660 1661 if (listen(fd, 5) != 0) e(0); 1662 1663 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 1664 1665 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 1666 1667 /* Test for accept(2), which returns an empty address. */ 1668 memset(&sun, 0, sizeof(sun)); 1669 len = sizeof(sun); 1670 if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 1671 check_addr(&sun, len, NULL); 1672 1673 /* Test for recvfrom(2), which ignores the address pointer. */ 1674 if (send(fd2, "", 1, 0) != 1) e(0); 1675 1676 memset(&sun, 0, sizeof(sun)); 1677 len = sizeof(sun); 1678 if (recvfrom(fd3, buf, sizeof(buf), 0, (struct sockaddr *)&sun, 1679 &len) != 1) e(0); 1680 if (len != 0) e(0); 1681 if (sun.sun_family != 0) e(0); 1682 if (sun.sun_len != 0) e(0); 1683 1684 /* Test for getsockname(2), which returns an empty address. */ 1685 memset(&sun, 0, sizeof(sun)); 1686 len = sizeof(sun); 1687 if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0); 1688 check_addr(&sun, len, NULL); 1689 1690 /* Test for getpeername(2), which returns an empty address. */ 1691 memset(&sun, 0, sizeof(sun)); 1692 len = sizeof(sun); 1693 if (getpeername(fd3, (struct sockaddr *)&sun, &len) != 0) e(0); 1694 check_addr(&sun, len, NULL); 1695 1696 if (close(fd) != 0) e(0); 1697 if (close(fd2) != 0) e(0); 1698 if (close(fd3) != 0) e(0); 1699 1700 if (unlink(SOCK_PATH_A) != 0) e(0); 1701 } 1702 1703 /* 1704 * Test addresses returned for unbound sockets by various calls. 1705 */ 1706 static void 1707 test90h(void) 1708 { 1709 struct sockaddr_un sun; 1710 socklen_t len; 1711 char buf[1]; 1712 int fd, fd2; 1713 1714 subtest = 8; 1715 1716 /* Connection-type socket tests. */ 1717 sub90h(SOCK_STREAM); 1718 1719 sub90h(SOCK_SEQPACKET); 1720 1721 /* Datagram socket tests. */ 1722 fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sun); 1723 1724 if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0); 1725 1726 if (sendto(fd2, "", 1, 0, (struct sockaddr *)&sun, sizeof(sun)) != 1) 1727 e(0); 1728 1729 /* 1730 * Datagram test for recvfrom(2), which returns no address. This is 1731 * the one result in this subtest that is not specified by POSIX and 1732 * (not so coincidentally) is different between NetBSD and Linux. 1733 * MINIX3 happens to follow Linux behavior for now, but this may be 1734 * changed in the future. 1735 */ 1736 memset(&sun, 0, sizeof(sun)); 1737 len = sizeof(sun); 1738 if (recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&sun, 1739 &len) != 1) e(0); 1740 if (len != 0) e(0); 1741 if (sun.sun_family != 0) e(0); 1742 if (sun.sun_len != 0) e(0); 1743 1744 /* Datagram test for getsockname(2), which returns an empty address. */ 1745 memset(&sun, 0, sizeof(sun)); 1746 len = sizeof(sun); 1747 if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0); 1748 check_addr(&sun, len, NULL); 1749 1750 if (close(fd) != 0) e(0); 1751 if (close(fd2) != 0) e(0); 1752 1753 if (unlink(SOCK_PATH_A) != 0) e(0); 1754 } 1755 1756 #define MAX_FDS 7 1757 1758 /* 1759 * Send anywhere from zero to MAX_FDS file descriptors onto a socket, possibly 1760 * along with regular data. Return the result of the sendmsg(2) call, with 1761 * errno preserved. Written to be reusable outside this test set. 1762 */ 1763 static int 1764 send_fds(int fd, const char * data, size_t len, int flags, 1765 struct sockaddr * addr, socklen_t addr_len, int * fds, int nfds) 1766 { 1767 union { 1768 char buf[CMSG_SPACE(MAX_FDS * sizeof(int))]; 1769 struct cmsghdr cmsg; 1770 } control; 1771 struct msghdr msg; 1772 struct iovec iov; 1773 1774 assert(nfds >= 0 && nfds <= MAX_FDS); 1775 1776 iov.iov_base = __UNCONST(data); 1777 iov.iov_len = len; 1778 1779 memset(&control.cmsg, 0, sizeof(control.cmsg)); 1780 control.cmsg.cmsg_len = CMSG_LEN(nfds * sizeof(int)); 1781 control.cmsg.cmsg_level = SOL_SOCKET; 1782 control.cmsg.cmsg_type = SCM_RIGHTS; 1783 memcpy(CMSG_DATA(&control.cmsg), fds, nfds * sizeof(int)); 1784 1785 memset(&msg, 0, sizeof(msg)); 1786 msg.msg_iov = &iov; 1787 msg.msg_iovlen = 1; 1788 msg.msg_control = &control; 1789 msg.msg_controllen = control.cmsg.cmsg_len; 1790 msg.msg_name = addr; 1791 msg.msg_namelen = addr_len; 1792 1793 return sendmsg(fd, &msg, flags); 1794 } 1795 1796 /* 1797 * Receive anywhere from zero to up to MAX_FDS file descriptors from a socket, 1798 * possibly along with regular data. The 'nfds' parameter must point to the 1799 * maximum number of file descriptors to be received. Return the result of the 1800 * recvmsg(2) call, with errno preserved. On success, return the received 1801 * flags in 'rflags', the received file descriptors stored in 'fds' and their 1802 * number stored in 'nfds'. Written to be (somewhat) reusable. 1803 */ 1804 static int 1805 recv_fds(int fd, char * buf, size_t size, int flags, int * rflags, int * fds, 1806 int * nfds) 1807 { 1808 union { 1809 char buf[CMSG_SPACE(MAX_FDS * sizeof(int))]; 1810 struct cmsghdr cmsg; 1811 } control; 1812 struct msghdr msg; 1813 struct iovec iov; 1814 size_t len; 1815 int r, rnfds; 1816 1817 assert(*nfds >= 0 && *nfds <= MAX_FDS); 1818 1819 iov.iov_base = buf; 1820 iov.iov_len = size; 1821 1822 memset(&control.cmsg, 0, sizeof(control.cmsg)); 1823 control.cmsg.cmsg_len = CMSG_LEN(*nfds * sizeof(int)); 1824 control.cmsg.cmsg_level = SOL_SOCKET; 1825 control.cmsg.cmsg_type = SCM_RIGHTS; 1826 1827 memset(&msg, 0, sizeof(msg)); 1828 msg.msg_iov = &iov; 1829 msg.msg_iovlen = 1; 1830 msg.msg_control = &control; 1831 msg.msg_controllen = control.cmsg.cmsg_len; 1832 1833 if ((r = recvmsg(fd, &msg, flags)) < 0) 1834 return r; 1835 1836 if (msg.msg_controllen > 0) { 1837 assert(msg.msg_controllen <= sizeof(control)); 1838 assert(msg.msg_controllen >= sizeof(control.cmsg)); 1839 len = control.cmsg.cmsg_len - CMSG_LEN(0); 1840 assert(len % sizeof(int) == 0); 1841 rnfds = len / sizeof(int); 1842 assert(rnfds <= *nfds); 1843 1844 memcpy(fds, CMSG_DATA(&control.cmsg), rnfds * sizeof(int)); 1845 } else 1846 rnfds = 0; 1847 1848 *rflags = msg.msg_flags; 1849 *nfds = rnfds; 1850 return r; 1851 } 1852 1853 /* 1854 * Generate and send zero or more file descriptors onto a socket, possibly 1855 * along with regular data. Return the result of the sendmsg(2) call, with 1856 * errno preserved. Also return a set of peer FDs for each of the sent file 1857 * descriptors, which should later be used in a call to close_test_fds(). 1858 */ 1859 static int 1860 send_test_fds(int fd, const char * data, size_t len, int flags, int * peers, 1861 int nfds) 1862 { 1863 int i, r, saved_errno, fds[MAX_FDS], pfd[2]; 1864 1865 if (nfds > MAX_FDS) e(0); 1866 1867 for (i = 0; i < nfds; i++) { 1868 if (pipe2(pfd, O_NONBLOCK) != 0) e(0); 1869 1870 peers[i] = pfd[0]; 1871 fds[i] = pfd[1]; 1872 } 1873 1874 r = send_fds(fd, data, len, flags, NULL, 0, fds, nfds); 1875 saved_errno = errno; 1876 1877 for (i = 0; i < nfds; i++) 1878 if (close(fds[i]) != 0) e(0); 1879 1880 errno = saved_errno; 1881 return r; 1882 } 1883 1884 /* 1885 * Given an array of peer file descriptors as returned from a call to 1886 * send_test_fds(), test if the original file descriptors have correctly been 1887 * closed, and close all peer file descriptors. The ultimate goal here is to 1888 * detect any possible file descriptor leaks in the UDS service. 1889 */ 1890 static void 1891 close_test_fds(int * peers, int nfds) 1892 { 1893 char buf[1]; 1894 unsigned int i; 1895 int fd; 1896 1897 for (i = 0; i < nfds; i++) { 1898 fd = peers[i]; 1899 1900 /* If the other side is still open, we would get EAGAIN. */ 1901 if (read(fd, buf, sizeof(buf)) != 0) e(0); 1902 1903 if (close(peers[i]) != 0) e(0); 1904 } 1905 } 1906 1907 /* 1908 * Receive and close zero or more file descriptors from a socket, possibly 1909 * along with regular data. Return the result of the recvmsg(2) call, with 1910 * errno preserved. 1911 */ 1912 static int 1913 recv_test_fds(int fd, char * buf, size_t size, int flags, int * rflags, 1914 int * nfds) 1915 { 1916 int i, r, saved_errno, fds[MAX_FDS]; 1917 1918 if (*nfds > MAX_FDS) e(0); 1919 1920 if ((r = recv_fds(fd, buf, size, flags, rflags, fds, nfds)) < 0) 1921 return r; 1922 saved_errno = errno; 1923 1924 for (i = 0; i < *nfds; i++) 1925 if (close(fds[i]) != 0) e(0); 1926 1927 errno = saved_errno; 1928 return r; 1929 } 1930 1931 /* 1932 * Test receive requests on various socket states and in various forms. 1933 * Following this function requires a very close look at what is in the 1934 * receive queue versus what is being received. 1935 */ 1936 static void 1937 sub90i_recv(int fd, int type, int state, int test, int sub, int sentfds) 1938 { 1939 struct msghdr msg; 1940 struct iovec iov; 1941 char data[4]; 1942 unsigned int i; 1943 int res, err, nfds, rflags; 1944 1945 memset(data, 0, sizeof(data)); 1946 1947 if (sub & 2) { 1948 rflags = 0; 1949 nfds = sentfds; 1950 res = recv_test_fds(fd, data, (sub & 1) ? 0 : sizeof(data), 0, 1951 &rflags, &nfds); 1952 if (rflags & MSG_CTRUNC) e(0); 1953 if (nfds != 0 && nfds != sentfds) e(0); 1954 if ((type == SOCK_STREAM) && (rflags & MSG_TRUNC)) e(0); 1955 } else { 1956 iov.iov_base = data; 1957 iov.iov_len = (sub & 1) ? 0 : sizeof(data); 1958 memset(&msg, 0, sizeof(msg)); 1959 msg.msg_iov = &iov; 1960 msg.msg_iovlen = 1; 1961 res = recvmsg(fd, &msg, 0); 1962 if (res >= 0) 1963 rflags = msg.msg_flags; 1964 else 1965 rflags = 0; 1966 nfds = 0; 1967 } 1968 err = errno; 1969 1970 if (res < -1 || res > (int)sizeof(data)) e(0); 1971 1972 if (type == SOCK_STREAM) { 1973 if (sub & 1) { 1974 /* 1975 * Zero-size requests should receive no regular data 1976 * and no control data, even if the tail segment is 1977 * zero-sized and terminated. This policy is in place 1978 * for simplicity reasons. 1979 */ 1980 if (res != 0) e(0); 1981 if (nfds != 0) e(0); 1982 if (rflags & MSG_CTRUNC) e(0); 1983 1984 /* 1985 * Since nothing happened yet, do another, now non- 1986 * zero receive call immediately, and continue as if 1987 * that was the first call. 1988 */ 1989 sub = (sub & ~1) | 2; 1990 nfds = sentfds; 1991 rflags = 0; 1992 res = recv_test_fds(fd, data, sizeof(data), 0, &rflags, 1993 &nfds); 1994 if (rflags & (MSG_TRUNC | MSG_CTRUNC)) e(0); 1995 if (nfds != 0 && nfds != sentfds) e(0); 1996 err = errno; 1997 if (res < -1 || res > (int)sizeof(data)) e(0); 1998 } 1999 2000 if (state == 0 && !(test & 1) && !(sub & 13)) { 2001 /* 2002 * There are no regular data bytes to be received, and 2003 * the current segment may still be extended (i.e., 2004 * there is no EOF condition), and we are trying to 2005 * receive at least one data byte. This is the 2006 * SO_RCVLOWAT test. 2007 */ 2008 if (res != -1) e(0); 2009 if (err != EWOULDBLOCK) e(0); 2010 if (test == 4) { 2011 /* 2012 * There are still pending file descriptors but 2013 * we cannot get them, due to the SO_RCVLOWAT 2014 * test. This is proper behavior but somewhat 2015 * annoying, because we want to see if UDS 2016 * forgot to close any file descriptors. So, 2017 * we let it force-close them here. 2018 */ 2019 if (shutdown(fd, SHUT_RD) != 0) e(0); 2020 sub |= 8; 2021 } 2022 } else { 2023 i = 0; 2024 if (state == 1) { 2025 if (res < 1) e(0); 2026 if (data[i] != 'A') e(0); 2027 i++; 2028 } 2029 if ((state == 0 && (test & 1)) || 2030 (state == 1 && (test == 1 || test == 3))) { 2031 if (res < i + 1) e(0); 2032 if (data[i] != 'B') e(0); 2033 i++; 2034 } 2035 if ((sub & 4) && (state != 1 || test < 4)) { 2036 if (res < i + 1) e(0); 2037 if (data[i] != 'C') e(0); 2038 i++; 2039 } 2040 if (i != res) e(0); 2041 if (state == 0 && test >= 4) { 2042 if (sub & 2) { 2043 if (nfds != sentfds) e(0); 2044 } else 2045 if (!(rflags & MSG_CTRUNC)) e(0); 2046 } 2047 } 2048 2049 if (state == 1 && test >= 4) { 2050 /* 2051 * We just read the first segment, but there is a 2052 * second segment with ancillary data. Read it too. 2053 */ 2054 nfds = sentfds; 2055 rflags = 0; 2056 res = recv_test_fds(fd, data, sizeof(data), 0, &rflags, 2057 &nfds); 2058 if (rflags & (MSG_TRUNC | MSG_CTRUNC)) e(0); 2059 if (nfds != sentfds) e(0); /* untouched on failure */ 2060 if (res < -1 || res > (int)sizeof(data)) e(0); 2061 if (test != 5 && !(sub & 12)) { 2062 if (res != -1) e(0); 2063 if (errno != EWOULDBLOCK) e(0); 2064 /* As above. */ 2065 if (shutdown(fd, SHUT_RD) != 0) e(0); 2066 sub |= 8; 2067 } else { 2068 if (res != (test == 5) + !!(sub & 4)) e(0); 2069 if (test == 5 && data[0] != 'B') e(0); 2070 if ((sub & 4) && data[res - 1] != 'C') e(0); 2071 } 2072 } 2073 } else { 2074 if (res != ((state == 1 || (test & 1)) && !(sub & 1))) e(0); 2075 if (state == 0 && test >= 4) { 2076 if (sub & 2) { 2077 if (nfds != sentfds) e(0); 2078 } else 2079 if (!(rflags & MSG_CTRUNC)) e(0); 2080 } 2081 if (res > 0 && data[0] != ((state == 1) ? 'A' : 'B')) e(0); 2082 2083 if (state == 1) { 2084 nfds = sentfds; 2085 rflags = 0; 2086 res = recv_test_fds(fd, data, sizeof(data), 0, &rflags, 2087 &nfds); 2088 if (res != (test & 1)) e(0); 2089 if (res > 0 && data[0] != 'B') e(0); 2090 if (nfds != ((test >= 4) ? sentfds : 0)) e(0); 2091 } 2092 2093 if (sub & 4) { 2094 nfds = sentfds; 2095 rflags = 0; 2096 res = recv_test_fds(fd, data, sizeof(data), 0, &rflags, 2097 &nfds); 2098 if (res != 1) e(0); 2099 if (data[0] != 'C') e(0); 2100 if (nfds != 0) e(0); 2101 } 2102 } 2103 2104 /* 2105 * At this point, there is nothing to receive. Depending on 2106 * whether we closed the socket, we expect EOF or EWOULDBLOCK. 2107 */ 2108 res = recv(fd, data, sizeof(data), 0); 2109 if (type == SOCK_DGRAM || !(sub & 8)) { 2110 if (res != -1) e(0); 2111 if (errno != EWOULDBLOCK) e(0); 2112 } else 2113 if (res != 0) e(0); 2114 } 2115 2116 /* 2117 * Test send requests on various socket states and in various forms. 2118 */ 2119 static void 2120 sub90i_send(int type, int state, int test, int sub) 2121 { 2122 char *buf; 2123 int r, res, err, fd[2], peers[2], rcvlen; 2124 2125 get_socket_pair(type | SOCK_NONBLOCK, fd); 2126 2127 /* 2128 * State 0: an empty buffer. 2129 * State 1: a non-empty, non-full buffer. 2130 * State 2: a full buffer. 2131 */ 2132 if (state == 2) { 2133 if (type == SOCK_STREAM) { 2134 rcvlen = get_rcvbuf_len(fd[0]); 2135 2136 if ((buf = malloc(rcvlen)) == NULL) e(0); 2137 2138 memset(buf, 'A', rcvlen); 2139 2140 if (send(fd[0], buf, rcvlen, 0) != rcvlen) e(0); 2141 2142 free(buf); 2143 } else { 2144 while ((r = send(fd[0], "A", 1, 0)) == 1); 2145 if (r != -1) e(0); 2146 if (errno != 2147 ((type == SOCK_SEQPACKET) ? EAGAIN : ENOBUFS)) 2148 e(0); 2149 } 2150 } else if (state == 1) 2151 if (send(fd[0], "A", 1, 0) != 1) e(0); 2152 2153 /* 2154 * Test 0: no data, no control data. 2155 * Test 1: data, no control data. 2156 * Test 2: no data, empty control data. 2157 * Test 3: data, empty control data. 2158 * Test 4: no data, control data with a file descriptor. 2159 * Test 5: data, control data with a file descriptor. 2160 */ 2161 switch (test) { 2162 case 0: 2163 case 1: 2164 res = send(fd[0], "B", test % 2, 0); 2165 err = errno; 2166 break; 2167 case 2: 2168 case 3: 2169 res = send_test_fds(fd[0], "B", test % 2, 0, NULL, 0); 2170 err = errno; 2171 break; 2172 case 4: 2173 case 5: 2174 res = send_test_fds(fd[0], "B", test % 2, 0, peers, 2175 __arraycount(peers)); 2176 err = errno; 2177 break; 2178 default: 2179 res = -1; 2180 err = EINVAL; 2181 e(0); 2182 } 2183 2184 if (res < -1 || res > 1) e(0); 2185 2186 switch (state) { 2187 case 0: 2188 case 1: 2189 if (res != (test % 2)) e(0); 2190 2191 /* 2192 * Subtest bit 0x1: try a zero-size receive first. 2193 * Subtest bit 0x2: try receiving control data. 2194 * Subtest bit 0x4: send an extra segment with no control data. 2195 * Subtest bit 0x8: after completing receives, expect EOF. 2196 */ 2197 if (sub & 4) 2198 if (send(fd[0], "C", 1, 0) != 1) e(0); 2199 if (sub & 8) 2200 if (shutdown(fd[0], SHUT_WR) != 0) e(0); 2201 2202 /* 2203 * Assuming (sub&4), which means there is an extra "C".. 2204 * 2205 * For stream sockets, we should now receive: 2206 * - state 0: 2207 * - test 0, 2: "C" 2208 * - test 1, 3: "BC" 2209 * - test 4: "C" (w/fds) 2210 * - test 5: "BC" (w/fds) 2211 * - state 1: 2212 * - test 0, 2: "AC" 2213 * - test 1, 3: "ABC" 2214 * - test 4: "A", "C" (w/fds) 2215 * - test 5: "A", "BC" (w/fds) 2216 * 2217 * For packet sockets, we should now receive: 2218 * - state 1: 2219 * - all tests: "A", followed by.. 2220 * - state 0, 1: 2221 * - test 0, 2: "" (no fds), "C" 2222 * - test 1, 3: "B" (no fds), "C" 2223 * - test 4: "" (w/fds), "C" 2224 * - test 5: "B" (w/fds), "C" 2225 */ 2226 sub90i_recv(fd[1], type, state, test, sub, 2227 __arraycount(peers)); 2228 2229 break; 2230 case 2: 2231 /* 2232 * Alright, the results are a bit tricky to interpret here, 2233 * because UDS's current strict send admission control prevents 2234 * the receive buffer from being fully utilized. We therefore 2235 * only test the following aspects: 2236 * 2237 * - if we sent no regular or control data to a stream socket, 2238 * the call should have succeeded (note that the presence of 2239 * empty control data may cause the call to fail); 2240 * - if we sent either regular or control data to a stream 2241 * socket, the call should have failed with EWOULDBLOCK; 2242 * - if the call failed, the error should have been EWOULDBLOCK 2243 * for connection-type sockets and ENOBUFS for connectionless 2244 * sockets. 2245 * 2246 * Everything else gets a pass; we can't even be sure that for 2247 * packet-oriented sockets we completely filled up the buffer. 2248 */ 2249 if (res == -1) { 2250 if (type == SOCK_STREAM && test == 0) e(0); 2251 2252 if (type != SOCK_DGRAM && err != EWOULDBLOCK) e(0); 2253 if (type == SOCK_DGRAM && err != ENOBUFS) e(0); 2254 } else 2255 if (type == SOCK_STREAM && test != 0) e(0); 2256 break; 2257 } 2258 2259 /* 2260 * Make sure there are no more in-flight file descriptors now, even 2261 * before closing the socket. 2262 */ 2263 if (res >= 0 && test >= 4) 2264 close_test_fds(peers, __arraycount(peers)); 2265 2266 close(fd[0]); 2267 close(fd[1]); 2268 } 2269 2270 /* 2271 * Test send and receive requests with regular data, control data, both, or 2272 * neither, and test segment boundaries. 2273 */ 2274 static void 2275 test90i(void) 2276 { 2277 int state, test, sub; 2278 2279 subtest = 9; 2280 2281 for (state = 0; state < 3; state++) { 2282 for (test = 0; test < 6; test++) { 2283 for (sub = 0; sub < ((state < 2) ? 16 : 1); sub++) { 2284 sub90i_send(SOCK_STREAM, state, test, sub); 2285 2286 sub90i_send(SOCK_SEQPACKET, state, test, sub); 2287 2288 sub90i_send(SOCK_DGRAM, state, test, sub); 2289 } 2290 } 2291 } 2292 } 2293 2294 /* 2295 * Test segmentation of file descriptor transfer on a particular socket type. 2296 */ 2297 static void 2298 sub90j(int type) 2299 { 2300 char path[PATH_MAX], buf[2]; 2301 int i, fd[2], out[7], in[7], rflags, nfds; 2302 ssize_t len; 2303 2304 get_socket_pair(type, fd); 2305 2306 for (i = 0; i < __arraycount(out); i++) { 2307 snprintf(path, sizeof(path), "file%d", i); 2308 out[i] = open(path, O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0644); 2309 if (out[i] < 0) e(0); 2310 if (write(out[i], path, strlen(path)) != strlen(path)) e(0); 2311 if (lseek(out[i], 0, SEEK_SET) != 0) e(0); 2312 } 2313 2314 if (send_fds(fd[1], "A", 1, 0, NULL, 0, &out[0], 1) != 1) e(0); 2315 if (send_fds(fd[1], "B", 1, 0, NULL, 0, &out[1], 3) != 1) e(0); 2316 if (send_fds(fd[1], "C", 1, 0, NULL, 0, &out[4], 2) != 1) e(0); 2317 2318 nfds = 2; 2319 if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[0], &nfds) != 1) 2320 e(0); 2321 if (buf[0] != 'A') e(0); 2322 if (rflags != 0) e(0); 2323 if (nfds != 1) e(0); 2324 2325 nfds = 5; 2326 if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[1], &nfds) != 1) 2327 e(0); 2328 if (buf[0] != 'B') e(0); 2329 if (rflags != 0) e(0); 2330 if (nfds != 3) e(0); 2331 2332 if (send_fds(fd[1], "D", 1, 0, NULL, 0, &out[6], 1) != 1) e(0); 2333 2334 nfds = 2; 2335 if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[4], &nfds) != 1) 2336 e(0); 2337 if (buf[0] != 'C') e(0); 2338 if (rflags != 0) e(0); 2339 if (nfds != 2) e(0); 2340 2341 nfds = 2; 2342 if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[6], &nfds) != 1) 2343 e(0); 2344 if (buf[0] != 'D') e(0); 2345 if (rflags != 0) e(0); 2346 if (nfds != 1) e(0); 2347 2348 for (i = 0; i < __arraycount(in); i++) { 2349 len = read(in[i], path, sizeof(path)); 2350 if (len < 5 || len > 7) e(0); 2351 path[len] = '\0'; 2352 if (strncmp(path, "file", 4) != 0) e(0); 2353 if (atoi(&path[4]) != i) e(0); 2354 if (unlink(path) != 0) e(0); 2355 if (close(in[i]) != 0) e(0); 2356 } 2357 2358 for (i = 0; i < __arraycount(out); i++) 2359 if (close(out[i]) != 0) e(0); 2360 2361 /* 2362 * While we're here, see if UDS properly closes any remaining in-flight 2363 * file descriptors when the socket is closed. 2364 */ 2365 if (send_test_fds(fd[1], "E", 1, 0, out, 7) != 1) e(0); 2366 2367 close(fd[0]); 2368 close(fd[1]); 2369 2370 close_test_fds(out, 7); 2371 } 2372 2373 /* 2374 * Test segmentation of file descriptor transfer. That is, there are multiple 2375 * in-flight file descriptors, they must each be associated with their 2376 * respective segments. 2377 */ 2378 static void 2379 test90j(void) 2380 { 2381 2382 subtest = 10; 2383 2384 sub90j(SOCK_STREAM); 2385 2386 sub90j(SOCK_SEQPACKET); 2387 2388 sub90j(SOCK_DGRAM); 2389 } 2390 2391 /* 2392 * Test whether we can deadlock UDS by making it close the last reference to 2393 * an in-flight file descriptor for a UDS socket. Currently we allow VFS/UDS 2394 * to get away with throwing EDEADLK as a sledgehammer approach to preventing 2395 * problems with in-flight UDS sockets. 2396 */ 2397 static void 2398 test90k(void) 2399 { 2400 int r, fd[2], fd2; 2401 2402 subtest = 11; 2403 2404 get_socket_pair(SOCK_STREAM, fd); 2405 2406 if ((fd2 = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0); 2407 2408 if ((r = send_fds(fd[0], "X", 1, 0, NULL, 0, &fd2, 1)) != 1) { 2409 if (r != -1) e(0); 2410 if (errno != EDEADLK) e(0); /* whew */ 2411 } 2412 2413 if (close(fd2) != 0) e(0); 2414 if (close(fd[0]) != 0) e(0); 2415 if (close(fd[1]) != 0) e(0); /* boom */ 2416 } 2417 2418 /* 2419 * Test whether we can make UDS run out of file descriptors by transferring a 2420 * UDS socket over itself and then closing all other references while it is 2421 * in-flight. Currently we allow VFS/UDS to get away with throwing EDEADLK as 2422 * a sledgehammer approach to preventing problems with in-flight UDS sockets. 2423 */ 2424 static void 2425 test90l(void) 2426 { 2427 struct sockaddr_un sun; 2428 int i, r, fd, fd2; 2429 2430 subtest = 12; 2431 2432 fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sun); 2433 2434 for (i = 0; i < OPEN_MAX + 1; i++) { 2435 if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0); 2436 2437 if ((r = send_fds(fd2, "X", 1, 0, (struct sockaddr *)&sun, 2438 sizeof(sun), &fd2, 1)) != 1) { 2439 if (r != -1) e(0); 2440 if (errno != EDEADLK) e(0); /* whew */ 2441 } 2442 2443 if (close(fd2) != 0) e(0); /* have fun in limbo.. */ 2444 } 2445 2446 if (close(fd) != 0) e(0); 2447 if (unlink(SOCK_PATH_A) != 0) e(0); 2448 } 2449 2450 /* 2451 * Receive with credentials. 2452 */ 2453 static int 2454 recv_creds(int fd, char * buf, size_t size, int flags, int * rflags, 2455 struct sockcred * sc, socklen_t * sc_len) 2456 { 2457 union { 2458 char buf[CMSG_SPACE(SOCKCREDSIZE(NGROUPS_MAX))]; 2459 struct cmsghdr cmsg; 2460 } control; 2461 struct msghdr msg; 2462 struct iovec iov; 2463 size_t len; 2464 int r; 2465 2466 iov.iov_base = buf; 2467 iov.iov_len = size; 2468 2469 memset(&control.cmsg, 0, sizeof(control.cmsg)); 2470 control.cmsg.cmsg_len = CMSG_LEN(SOCKCREDSIZE(NGROUPS_MAX)); 2471 control.cmsg.cmsg_level = SOL_SOCKET; 2472 control.cmsg.cmsg_type = SCM_RIGHTS; 2473 2474 memset(&msg, 0, sizeof(msg)); 2475 msg.msg_iov = &iov; 2476 msg.msg_iovlen = 1; 2477 msg.msg_control = &control; 2478 msg.msg_controllen = control.cmsg.cmsg_len; 2479 2480 if ((r = recvmsg(fd, &msg, flags)) < 0) 2481 return r; 2482 2483 if (msg.msg_controllen > 0) { 2484 assert(msg.msg_controllen <= sizeof(control)); 2485 assert(msg.msg_controllen >= sizeof(control.cmsg)); 2486 assert(control.cmsg.cmsg_len <= msg.msg_controllen); 2487 len = control.cmsg.cmsg_len - CMSG_LEN(0); 2488 assert(len >= sizeof(struct sockcred)); 2489 assert(len <= SOCKCREDSIZE(NGROUPS_MAX)); 2490 if (*sc_len > len) 2491 *sc_len = len; 2492 memcpy(sc, CMSG_DATA(&control.cmsg), *sc_len); 2493 } else 2494 *sc_len = 0; 2495 2496 *rflags = msg.msg_flags; 2497 return r; 2498 } 2499 2500 /* 2501 * Test basic credentials passing on connection-oriented sockets. 2502 */ 2503 static void 2504 sub90m(int type) 2505 { 2506 struct sockaddr_un sun; 2507 struct sockcred sc; 2508 struct msghdr msg; 2509 struct iovec iov; 2510 socklen_t len; 2511 char buf[1]; 2512 int fd, fd2, fd3, val, rflags; 2513 2514 fd = get_bound_socket(type, SOCK_PATH_A, &sun); 2515 2516 val = 1; 2517 if (setsockopt(fd, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0); 2518 2519 if (listen(fd, 1) != 0) e(0); 2520 2521 if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 2522 2523 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 2524 2525 len = sizeof(sun); 2526 if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 2527 2528 if (send(fd2, "A", 1, 0) != 1) e(0); 2529 if (send(fd2, "B", 1, 0) != 1) e(0); 2530 2531 len = sizeof(sc); 2532 if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2533 e(0); 2534 if (buf[0] != 'A') e(0); 2535 if (rflags != 0) e(0); 2536 if (len != sizeof(sc)) e(0); 2537 if (sc.sc_uid != getuid()) e(0); 2538 if (sc.sc_euid != geteuid()) e(0); 2539 2540 len = sizeof(sc); 2541 if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2542 e(0); 2543 if (buf[0] != 'B') e(0); 2544 if (rflags != 0) e(0); 2545 if (len != 0) e(0); 2546 2547 if (send(fd3, "C", 1, 0) != 1) e(0); 2548 2549 val = 1; 2550 if (setsockopt(fd2, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0); 2551 2552 if (send(fd3, "D", 1, 0) != 1) e(0); 2553 2554 val = 1; 2555 if (setsockopt(fd2, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0); 2556 2557 if (send(fd3, "E", 1, 0) != 1) e(0); 2558 2559 len = sizeof(sc); 2560 if (recv_creds(fd2, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2561 e(0); 2562 if (buf[0] != 'C') e(0); 2563 if (rflags != 0) e(0); 2564 if (len != 0) e(0); 2565 2566 len = sizeof(sc); 2567 if (recv_creds(fd2, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2568 e(0); 2569 if (buf[0] != 'D') e(0); 2570 if (rflags != 0) e(0); 2571 if (len != sizeof(sc)) e(0); 2572 if (sc.sc_uid != getuid()) e(0); 2573 if (sc.sc_euid != geteuid()) e(0); 2574 2575 memset(&msg, 0, sizeof(msg)); 2576 iov.iov_base = buf; 2577 iov.iov_len = sizeof(buf); 2578 msg.msg_iov = &iov; 2579 msg.msg_iovlen = 1; 2580 if (recvmsg(fd2, &msg, 0) != 1) e(0); 2581 if (buf[0] != 'E') e(0); 2582 if (msg.msg_flags != MSG_CTRUNC) e(0); 2583 2584 if (close(fd2) != 0) e(0); 2585 if (close(fd3) != 0) e(0); 2586 2587 val = 0; 2588 if (setsockopt(fd, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0); 2589 2590 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 2591 2592 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 2593 2594 len = sizeof(sun); 2595 if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 2596 2597 if (send(fd2, "F", 1, 0) != 1) e(0); 2598 2599 len = sizeof(sc); 2600 if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2601 e(0); 2602 if (buf[0] != 'F') e(0); 2603 if (rflags != 0) e(0); 2604 if (len != 0) e(0); 2605 2606 if (close(fd) != 0) e(0); 2607 if (close(fd2) != 0) e(0); 2608 if (close(fd3) != 0) e(0); 2609 2610 if (unlink(SOCK_PATH_A) != 0) e(0); 2611 } 2612 2613 /* 2614 * A few tests for credentials passing that matter to some applications: 2615 * the credentials passing setting is inherited by accepted connections from 2616 * their listening socket, and, credentials are passed only once on a 2617 * connection-oriented socket. 2618 */ 2619 static void 2620 test90m(void) 2621 { 2622 struct sockcred sc; 2623 socklen_t len; 2624 char buf[1]; 2625 int fd[2], val, rflags; 2626 2627 subtest = 13; 2628 2629 sub90m(SOCK_STREAM); 2630 2631 sub90m(SOCK_SEQPACKET); 2632 2633 get_socket_pair(SOCK_DGRAM, fd); 2634 2635 val = 1; 2636 if (setsockopt(fd[0], 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0); 2637 2638 if (send(fd[1], "A", 1, 0) != 1) e(0); 2639 if (send(fd[0], "B", 1, 0) != 1) e(0); 2640 if (send(fd[1], "C", 1, 0) != 1) e(0); 2641 2642 len = sizeof(sc); 2643 if (recv_creds(fd[0], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2644 e(0); 2645 if (buf[0] != 'A') e(0); 2646 if (rflags != 0) e(0); 2647 if (len != sizeof(sc)) e(0); 2648 if (sc.sc_uid != getuid()) e(0); 2649 if (sc.sc_euid != geteuid()) e(0); 2650 2651 len = sizeof(sc); 2652 if (recv_creds(fd[1], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2653 e(0); 2654 if (buf[0] != 'B') e(0); 2655 if (rflags != 0) e(0); 2656 if (len != 0) e(0); 2657 2658 len = sizeof(sc); 2659 if (recv_creds(fd[0], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1) 2660 e(0); 2661 if (buf[0] != 'C') e(0); 2662 if (rflags != 0) e(0); 2663 if (len != sizeof(sc)) e(0); 2664 if (sc.sc_uid != getuid()) e(0); 2665 if (sc.sc_euid != geteuid()) e(0); 2666 2667 if (close(fd[0]) != 0) e(0); 2668 if (close(fd[1]) != 0) e(0); 2669 } 2670 2671 /* 2672 * Test whether MSG_CMSG_CLOEXEC is honored when copying in file descriptors. 2673 * We do not bother to test with execve(2w); obtaining the FD flags suffices. 2674 */ 2675 static void 2676 test90n(void) 2677 { 2678 char buf[1]; 2679 int i, fd[2], sfd, rfd, fl, rflags, nfds; 2680 2681 subtest = 14; 2682 2683 get_socket_pair(SOCK_STREAM, fd); 2684 2685 if ((sfd = open("/dev/null", O_RDONLY)) < 0) e(0); 2686 2687 if (send_fds(fd[0], "A", 1, 0, NULL, 0, &sfd, 1) != 1) e(0); 2688 if (send_fds(fd[0], "B", 1, 0, NULL, 0, &sfd, 1) != 1) e(0); 2689 2690 if ((fl = fcntl(sfd, F_GETFD, 0)) < 0) e(0); 2691 if (fcntl(sfd, F_SETFD, fl | FD_CLOEXEC) != 0) e(0); 2692 2693 if (send_fds(fd[0], "C", 1, 0, NULL, 0, &sfd, 1) != 1) e(0); 2694 if (send_fds(fd[0], "D", 1, 0, NULL, 0, &sfd, 1) != 1) e(0); 2695 2696 for (i = 0; i < 4; i++) { 2697 fl = (i & 1) ? MSG_CMSG_CLOEXEC : 0; 2698 nfds = 1; 2699 if (recv_fds(fd[1], buf, sizeof(buf), fl, &rflags, &rfd, 2700 &nfds) != 1) e(0); 2701 if (buf[0] != 'A' + i) e(0); 2702 if (rflags != 0) e(0); 2703 if (nfds != 1) e(0); 2704 2705 if ((fl = fcntl(rfd, F_GETFD, 0)) < 0) e(0); 2706 if (!!(fl & FD_CLOEXEC) != (i & 1)) e(0); 2707 2708 if (close(rfd) != 0) e(0); 2709 } 2710 2711 if (close(sfd) != 0) e(0); 2712 if (close(fd[0]) != 0) e(0); 2713 if (close(fd[1]) != 0) e(0); 2714 } 2715 2716 /* 2717 * Test failures sending and receiving sets of file descriptors. 2718 */ 2719 static void 2720 sub90o(int type) 2721 { 2722 static int ofd[OPEN_MAX]; 2723 char buf[1]; 2724 int i, fd[2], sfd[2], rfd[2], rflags, nfds; 2725 2726 get_socket_pair(type, fd); 2727 2728 if ((sfd[0] = open("/dev/null", O_RDONLY)) < 0) e(0); 2729 sfd[1] = -1; 2730 2731 if (send_fds(fd[0], "A", 1, 0, NULL, 0, &sfd[1], 1) != -1) e(0); 2732 if (errno != EBADF) e(0); 2733 if (send_fds(fd[0], "B", 1, 0, NULL, 0, &sfd[0], 2) != -1) e(0); 2734 if (errno != EBADF) e(0); 2735 if ((sfd[1] = dup(sfd[0])) < 0) e(0); 2736 if (send_fds(fd[0], "C", 1, 0, NULL, 0, &sfd[0], 2) != 1) e(0); 2737 2738 for (i = 0; i < __arraycount(ofd); i++) { 2739 if ((ofd[i] = dup(sfd[0])) < 0) { 2740 /* Either will do. */ 2741 if (errno != EMFILE && errno != ENFILE) e(0); 2742 break; 2743 } 2744 } 2745 2746 nfds = 2; 2747 if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != -1) 2748 e(0); 2749 if (errno != ENFILE && errno != EMFILE) e(0); 2750 2751 if (close(sfd[1]) != 0) e(0); 2752 2753 nfds = 2; 2754 if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != -1) 2755 e(0); 2756 if (errno != ENFILE && errno != EMFILE) e(0); 2757 2758 if (close(sfd[0]) != 0) e(0); 2759 2760 nfds = 2; 2761 if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != 1) 2762 e(0); 2763 if (buf[0] != 'C') e(0); 2764 if (rflags != 0) e(0); 2765 if (nfds != 2) e(0); 2766 2767 if (close(rfd[1]) != 0) e(0); 2768 if (close(rfd[0]) != 0) e(0); 2769 while (i-- > 0) 2770 if (close(ofd[i]) != 0) e(0); 2771 if (close(fd[1]) != 0) e(0); 2772 if (close(fd[0]) != 0) e(0); 2773 } 2774 2775 /* 2776 * Test failures sending and receiving sets of file descriptors. 2777 */ 2778 static void 2779 test90o(void) 2780 { 2781 const int types[] = { SOCK_STREAM, SOCK_SEQPACKET, SOCK_DGRAM }; 2782 int i; 2783 2784 subtest = 15; 2785 2786 for (i = 0; i < OPEN_MAX + 1; i++) 2787 sub90o(types[i % __arraycount(types)]); 2788 } 2789 2790 /* 2791 * Test socket reuse for a particular socket type. 2792 */ 2793 static void 2794 sub90p(int type) 2795 { 2796 struct sockaddr_un sunA, sunB, sunC; 2797 socklen_t len; 2798 char buf[1]; 2799 uid_t euid; 2800 gid_t egid; 2801 int fd, fd2, fd3, val; 2802 2803 if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 2804 /* Unconnected. */ 2805 2806 if (getpeereid(fd, &euid, &egid) != -1) e(0); 2807 if (errno != ENOTCONN) e(0); 2808 2809 fd2 = get_bound_socket(type, SOCK_PATH_A, &sunA); 2810 2811 val = 1; 2812 if (setsockopt(fd2, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 2813 2814 if (listen(fd2, 5) != 0) e(0); 2815 2816 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0); 2817 if (errno != EINPROGRESS) e(0); 2818 /* Connecting. */ 2819 2820 if (getpeereid(fd, &euid, &egid) != -1) e(0); 2821 if (errno != ENOTCONN) e(0); 2822 2823 len = sizeof(sunB); 2824 if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0); 2825 /* Connected. */ 2826 2827 len = sizeof(sunC); 2828 if (getpeername(fd, (struct sockaddr *)&sunC, &len) != 0) e(0); 2829 check_addr(&sunC, len, SOCK_PATH_A); 2830 2831 if (getpeereid(fd, &euid, &egid) != 0) e(0); 2832 if (euid == -1 || egid == -1) e(0); 2833 2834 if (getpeereid(fd3, &euid, &egid) != 0) e(0); 2835 if (euid == -1 || egid == -1) e(0); 2836 2837 if (send(fd3, "A", 1, 0) != 1) e(0); 2838 if (send(fd3, "B", 1, 0) != 1) e(0); 2839 if (send(fd3, "C", 1, 0) != 1) e(0); 2840 2841 if (close(fd3) != 0) e(0); 2842 /* Disconnected. */ 2843 2844 if (getpeereid(fd, &euid, &egid) != -1) e(0); 2845 if (errno != ENOTCONN) e(0); 2846 2847 if (close(fd2) != 0) e(0); 2848 fd2 = get_bound_socket(type, SOCK_PATH_B, &sunA); 2849 2850 if (listen(fd2, 5) != 0) e(0); 2851 2852 val = 1; 2853 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 2854 2855 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0); 2856 if (errno != EINPROGRESS) e(0); 2857 /* Connecting. */ 2858 2859 if (getpeereid(fd, &euid, &egid) != -1) e(0); 2860 if (errno != ENOTCONN) e(0); 2861 2862 if (recv(fd, buf, 1, 0) != 1) e(0); 2863 if (buf[0] != 'A') e(0); 2864 2865 len = sizeof(sunB); 2866 if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0); 2867 /* Connected. */ 2868 2869 if (send(fd3, "D", 1, 0) != 1) e(0); 2870 if (send(fd3, "E", 1, 0) != 1) e(0); 2871 2872 len = sizeof(sunC); 2873 if (getpeername(fd, (struct sockaddr *)&sunC, &len) != 0) e(0); 2874 check_addr(&sunC, len, SOCK_PATH_B); 2875 2876 if (getpeereid(fd, &euid, &egid) != 0) e(0); 2877 if (euid == -1 || egid == -1) e(0); 2878 2879 if (close(fd2) != 0) e(0); 2880 if (unlink(SOCK_PATH_B) != 0) e(0); 2881 2882 if (close(fd3) != 0) e(0); 2883 /* Disconnected. */ 2884 2885 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0); 2886 if (errno != ENOENT) e(0); 2887 /* Unconnected. */ 2888 2889 if (getpeereid(fd, &euid, &egid) != -1) e(0); 2890 if (errno != ENOTCONN) e(0); 2891 2892 if (recv(fd, buf, 1, 0) != 1) e(0); 2893 if (buf[0] != 'B') e(0); 2894 2895 if (unlink(SOCK_PATH_A) != 0) e(0); 2896 2897 if (bind(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 2898 2899 if (recv(fd, buf, 1, 0) != 1) e(0); 2900 if (buf[0] != 'C') e(0); 2901 2902 val = 0; 2903 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0); 2904 2905 if (listen(fd, 1) != 0) e(0); 2906 /* Listening. */ 2907 2908 if (recv(fd, buf, 1, 0) != 1) e(0); 2909 if (buf[0] != 'D') e(0); 2910 2911 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 2912 2913 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 2914 2915 len = sizeof(sunC); 2916 if ((fd3 = accept(fd, (struct sockaddr *)&sunC, &len)) < 0) e(0); 2917 2918 if (send(fd2, "F", 1, 0) != 1) e(0); 2919 2920 if (recv(fd3, buf, 1, 0) != 1) e(0); 2921 if (buf[0] != 'F') e(0); 2922 2923 if (recv(fd, buf, 1, 0) != 1) e(0); 2924 if (buf[0] != 'E') e(0); 2925 2926 if (recv(fd, buf, 1, 0) != -1) e(0); 2927 if (errno != ENOTCONN) e(0); 2928 2929 /* It should be possible to obtain peer credentials now. */ 2930 if (getpeereid(fd2, &euid, &egid) != 0) e(0); 2931 if (euid == -1 || egid == -1) e(0); 2932 2933 if (getpeereid(fd3, &euid, &egid) != 0) e(0); 2934 if (euid == -1 || egid == -1) e(0); 2935 2936 if (close(fd3) != 0) e(0); 2937 if (close(fd2) != 0) e(0); 2938 2939 if (close(fd) != 0) e(0); 2940 /* Closed. */ 2941 2942 if (unlink(SOCK_PATH_B) != 0) e(0); 2943 2944 if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0); 2945 /* Unconnected. */ 2946 2947 fd2 = get_bound_socket(type, SOCK_PATH_A, &sunA); 2948 2949 if (listen(fd2, 5) != 0) e(0); 2950 2951 if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 2952 /* Connected. */ 2953 2954 len = sizeof(sunB); 2955 if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0); 2956 2957 if (close(fd2) != 0) e(0); 2958 2959 memset(&sunB, 0, sizeof(sunB)); 2960 sunB.sun_family = AF_UNIX; 2961 strlcpy(sunB.sun_path, SOCK_PATH_B, sizeof(sunB.sun_path)); 2962 2963 if (bind(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0); 2964 2965 if (close(fd3) != 0) e(0); 2966 /* Disconnected. */ 2967 2968 if (listen(fd, 1) != 0) e(0); 2969 /* Listening. */ 2970 2971 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 2972 2973 if (connect(fd2, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0); 2974 2975 len = sizeof(sunC); 2976 if ((fd3 = accept(fd, (struct sockaddr *)&sunC, &len)) < 0) e(0); 2977 2978 /* It should NOT be possible to obtain peer credentials now. */ 2979 if (getpeereid(fd2, &euid, &egid) != -1) e(0); 2980 if (errno != EINVAL) e(0); 2981 2982 if (getpeereid(fd3, &euid, &egid) != 0) e(0); 2983 if (euid == -1 || egid == -1) e(0); 2984 2985 if (close(fd3) != 0) e(0); 2986 if (close(fd2) != 0) e(0); 2987 2988 if (close(fd) != 0) e(0); 2989 /* Closed. */ 2990 2991 if (unlink(SOCK_PATH_A) != 0) e(0); 2992 if (unlink(SOCK_PATH_B) != 0) e(0); 2993 } 2994 2995 /* 2996 * Test socket reuse, receiving left-overs in the receive buffer, and the 2997 * (in)ability to obtain peer credentials. 2998 */ 2999 static void 3000 test90p(void) 3001 { 3002 3003 subtest = 16; 3004 3005 sub90p(SOCK_STREAM); 3006 3007 sub90p(SOCK_SEQPACKET); 3008 } 3009 3010 /* 3011 * Test state changes and errors related to connected datagram sockets. 3012 */ 3013 static void 3014 test90q(void) 3015 { 3016 struct sockaddr_un sunA, sunB, sunC, sunD; 3017 socklen_t len; 3018 char buf[1]; 3019 int fd, fd2, fd3, val; 3020 3021 subtest = 17; 3022 3023 /* 3024 * Sending a datagram to a datagram socket connected elsewhere should 3025 * fail explicitly (specifically, EPERM). 3026 */ 3027 fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA); 3028 fd2 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB); 3029 fd3 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_C, &sunC); 3030 3031 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3032 3033 if (sendto(fd3, "A", 1, 0, (struct sockaddr *)&sunB, 3034 sizeof(sunB)) != -1) e(0); 3035 if (errno != EPERM) e(0); 3036 3037 /* Similarly, connecting to such a socket should fail. */ 3038 if (connect(fd3, (struct sockaddr *)&sunB, sizeof(sunB)) != -1) e(0); 3039 if (errno != EPERM) e(0); 3040 3041 if (send(fd2, "B", 1, 0) != 1) e(0); 3042 3043 if (recv(fd, buf, 1, 0) != 1) e(0); 3044 if (buf[0] != 'B') e(0); 3045 3046 /* Reconnection of a socket's target should result in ECONNRESET. */ 3047 if (connect(fd, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0); 3048 3049 len = sizeof(val); 3050 if (getsockopt(fd2, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 3051 if (val != ECONNRESET) e(0); 3052 3053 if (send(fd2, "C", 1, 0) != -1) e(0); 3054 if (errno != EDESTADDRREQ) e(0); 3055 3056 if (send(fd, "D", 1, 0) != 1) e(0); 3057 3058 len = sizeof(sunD); 3059 if (recvfrom(fd3, buf, 1, 0, (struct sockaddr *)&sunD, &len) != 1) 3060 e(0); 3061 if (buf[0] != 'D') e(0); 3062 check_addr(&sunD, len, SOCK_PATH_A); 3063 3064 if (connect(fd2, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0); 3065 3066 if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3067 3068 memset(&sunD, 0, sizeof(sunD)); 3069 sunD.sun_family = AF_UNIX; 3070 strlcpy(sunD.sun_path, SOCK_PATH_D, sizeof(sunD.sun_path)); 3071 3072 /* A failed reconnection attempt should not break the previous one. */ 3073 if (connect(fd3, (struct sockaddr *)&sunD, sizeof(sunD)) != -1) e(0); 3074 if (errno != ENOENT) e(0); 3075 3076 /* The destination address should be ignored here. */ 3077 if (sendto(fd3, "E", 1, 0, (struct sockaddr *)&sunB, 3078 sizeof(sunB)) != 1) e(0); 3079 3080 if (recv(fd2, buf, 1, 0) != -1) e(0); 3081 if (errno != ECONNRESET) e(0); 3082 3083 if (recv(fd, buf, 1, 0) != 1) e(0); 3084 if (buf[0] != 'E') e(0); 3085 3086 if (close(fd3) != 0) e(0); 3087 3088 len = sizeof(val); 3089 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 3090 if (val != ECONNRESET) e(0); 3091 3092 if (close(fd2) != 0) e(0); 3093 3094 len = sizeof(val); 3095 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 3096 if (val != 0) e(0); 3097 3098 if (close(fd) != 0) e(0); 3099 3100 if (unlink(SOCK_PATH_A) != 0) e(0); 3101 if (unlink(SOCK_PATH_B) != 0) e(0); 3102 if (unlink(SOCK_PATH_C) != 0) e(0); 3103 3104 /* 3105 * Finally, test unconnecting sockets. 3106 */ 3107 fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA); 3108 fd2 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB); 3109 3110 if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0); 3111 3112 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3113 3114 if (sendto(fd2, "F", 1, 0, NULL, 0) != 1) e(0); 3115 3116 if (recv(fd, buf, 1, 0) != 1) e(0); 3117 if (buf[0] != 'F') e(0); 3118 3119 memset(&sunC, 0, sizeof(sunC)); 3120 sunC.sun_family = AF_UNSPEC; 3121 if (connect(fd2, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0); 3122 3123 len = sizeof(val); 3124 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0); 3125 if (val != 0) e(0); 3126 3127 if (send(fd, "G", 1, 0) != 1) e(0); 3128 3129 if (sendto(fd2, "H", 1, 0, NULL, 0) != -1) e(0); 3130 if (errno != EDESTADDRREQ) e(0); 3131 3132 if (sendto(fd2, "I", 1, 0, (struct sockaddr *)&sunA, sizeof(sunA)) != 1) 3133 e(0); 3134 3135 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3136 3137 if (sendto(fd2, "J", 1, 0, NULL, 0) != 1) e(0); 3138 3139 if (recv(fd, buf, 1, 0) != 1) e(0); 3140 if (buf[0] != 'I') e(0); 3141 3142 if (recv(fd, buf, 1, 0) != 1) e(0); 3143 if (buf[0] != 'J') e(0); 3144 3145 if (recv(fd2, buf, 1, 0) != 1) e(0); 3146 if (buf[0] != 'G') e(0); 3147 3148 if (close(fd) != 0) e(0); 3149 if (close(fd2) != 0) e(0); 3150 3151 if (unlink(SOCK_PATH_A) != 0) e(0); 3152 if (unlink(SOCK_PATH_B) != 0) e(0); 3153 } 3154 3155 /* 3156 * Test socket file name reuse. 3157 */ 3158 static void 3159 test90r(void) 3160 { 3161 struct sockaddr_un sun; 3162 socklen_t len; 3163 int fd, fd2, fd3, fd4; 3164 3165 subtest = 18; 3166 3167 fd = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_A, &sun); 3168 3169 if (rename(SOCK_PATH_A, SOCK_PATH_B) != 0) e(0); 3170 3171 if ((fd3 = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0); 3172 3173 if (connect(fd3, (struct sockaddr *)&sun, sizeof(sun)) != -1) e(0); 3174 if (errno != ENOENT) e(0); 3175 3176 if (listen(fd, 1) != 0) e(0); 3177 3178 len = sizeof(sun); 3179 if (getsockname(fd, (struct sockaddr *)&sun, &len) != 0) e(0); 3180 check_addr(&sun, len, SOCK_PATH_A); 3181 3182 fd2 = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_A, &sun); 3183 3184 if (listen(fd2, 1) != 0) e(0); 3185 3186 len = sizeof(sun); 3187 if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0); 3188 check_addr(&sun, len, SOCK_PATH_A); 3189 3190 len = sizeof(sun); 3191 if (getsockname(fd, (struct sockaddr *)&sun, &len) != 0) e(0); 3192 check_addr(&sun, len, SOCK_PATH_A); 3193 3194 memset(&sun, 0, sizeof(sun)); 3195 sun.sun_family = AF_UNIX; 3196 strlcpy(sun.sun_path, SOCK_PATH_B, sizeof(sun.sun_path)); 3197 if (connect(fd3, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 3198 3199 len = sizeof(sun); 3200 if ((fd4 = accept(fd2, (struct sockaddr *)&sun, &len)) >= 0) e(0); 3201 if (errno != EWOULDBLOCK) e(0); 3202 if ((fd4 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 3203 3204 len = sizeof(sun); 3205 if (getpeername(fd3, (struct sockaddr *)&sun, &len) != 0) e(0); 3206 check_addr(&sun, len, SOCK_PATH_A); 3207 3208 if (close(fd) != 0) e(0); 3209 if (close(fd2) != 0) e(0); 3210 if (close(fd3) != 0) e(0); 3211 if (close(fd4) != 0) e(0); 3212 3213 if (unlink(SOCK_PATH_A) != 0) e(0); 3214 if (unlink(SOCK_PATH_B) != 0) e(0); 3215 } 3216 3217 /* 3218 * Test that non-canonized path names are accepted and returned. 3219 * Also test datagram send errors on disconnect. 3220 */ 3221 static void 3222 test90s(void) 3223 { 3224 struct sockaddr_un sun; 3225 socklen_t len; 3226 int fd, fd2; 3227 3228 subtest = 19; 3229 3230 fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A_X, &sun); 3231 3232 if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0); 3233 3234 memset(&sun, 0, sizeof(sun)); 3235 sun.sun_family = AF_UNIX; 3236 strlcpy(sun.sun_path, SOCK_PATH_A_Y, sizeof(sun.sun_path)); 3237 3238 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 3239 3240 len = sizeof(sun); 3241 if (getpeername(fd2, (struct sockaddr *)&sun, &len) != 0) e(0); 3242 check_addr(&sun, len, SOCK_PATH_A_X); 3243 3244 if (send(fd2, "A", 1, 0) != 1) e(0); 3245 3246 if (close(fd) != 0) e(0); 3247 3248 if (send(fd2, "B", 1, 0) != -1) e(0); 3249 if (errno != ECONNRESET) e(0); 3250 3251 if (send(fd2, "B", 1, 0) != -1) e(0); 3252 if (errno != EDESTADDRREQ) e(0); 3253 3254 if (close(fd2) != 0) e(0); 3255 3256 if (unlink(SOCK_PATH_A) != 0) e(0); 3257 } 3258 3259 /* 3260 * Test basic sysctl(2) socket enumeration for a specific socket type. 3261 */ 3262 static void 3263 sub90t(int type, const char * path) 3264 { 3265 struct kinfo_pcb *ki; 3266 size_t i, len, oldlen; 3267 int fd, mib[8]; 3268 3269 if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0); 3270 3271 memset(mib, 0, sizeof(mib)); 3272 3273 len = __arraycount(mib); 3274 if (sysctlnametomib(path, mib, &len) != 0) e(0); 3275 if (len != 4) e(0); 3276 3277 if (sysctl(mib, __arraycount(mib), NULL, &oldlen, NULL, 0) != 0) e(0); 3278 if (oldlen == 0) e(0); 3279 if (oldlen % sizeof(*ki)) e(0); 3280 3281 if ((ki = (struct kinfo_pcb *)malloc(oldlen)) == NULL) e(0); 3282 3283 if (sysctl(mib, __arraycount(mib), ki, &oldlen, NULL, 0) != 0) e(0); 3284 if (oldlen == 0) e(0); 3285 if (oldlen % sizeof(*ki)) e(0); 3286 3287 /* 3288 * We cannot check a whole lot of things, because we have no way of 3289 * knowing which is the socket we created. Check some basics and leave 3290 * it at that. This subtest is mostly trying to guarantee that 3291 * netstat(1) will not show nothing, anyway. 3292 */ 3293 for (i = 0; i < oldlen / sizeof(*ki); i++) { 3294 if (ki[i].ki_pcbaddr == 0) e(0); 3295 if (ki[i].ki_sockaddr == 0) e(0); 3296 if (ki[i].ki_family != AF_UNIX) e(0); 3297 if (ki[i].ki_type != type) e(0); 3298 if (ki[i].ki_protocol != 0) e(0); 3299 } 3300 3301 free(ki); 3302 3303 if (close(fd) != 0) e(0); 3304 } 3305 3306 /* 3307 * Test basic sysctl(2) socket enumeration support. 3308 */ 3309 static void 3310 test90t(void) 3311 { 3312 3313 subtest = 20; 3314 3315 /* 3316 * We test that for each of the socket types, when we create a socket, 3317 * we can find at least one socket of that type in the respective 3318 * sysctl(2) out. 3319 */ 3320 sub90t(SOCK_STREAM, "net.local.stream.pcblist"); 3321 3322 sub90t(SOCK_SEQPACKET, "net.local.seqpacket.pcblist"); 3323 3324 sub90t(SOCK_DGRAM, "net.local.dgram.pcblist"); 3325 } 3326 3327 /* 3328 * Cause a pending recv() call to return. Here 'fd' is the file descriptor 3329 * identifying the other end of the socket pair. If breaking the recv() 3330 * requires sending data, 'data' and 'len' identify the data that should be 3331 * sent. Return 'fd' if it is still open, or -1 if it is closed. 3332 */ 3333 static int 3334 break_uds_recv(int fd, const char * data, size_t len) 3335 { 3336 int fd2; 3337 3338 /* 3339 * This UDS-specific routine makes the recv() in one of two ways 3340 * depending on whether the recv() call already made partial progress: 3341 * if it did, this send call creates a segment boundary which should 3342 * cut short the current receive call. If it did not, the send call 3343 * will simply satisfy the receive call with regular data. 3344 */ 3345 if ((fd2 = open("/dev/null", O_RDONLY)) < 0) e(0); 3346 3347 if (send_fds(fd, data, len, 0, NULL, 0, &fd2, 1) != len) e(0); 3348 3349 if (close(fd2) != 0) e(0); 3350 3351 return fd; 3352 } 3353 3354 /* 3355 * Test for receiving on stream sockets. In particular, test SO_RCVLOWAT, 3356 * MSG_PEEK, MSG_DONTWAIT, and MSG_WAITALL. 3357 */ 3358 static void 3359 test90u(void) 3360 { 3361 3362 subtest = 21; 3363 3364 socklib_stream_recv(socketpair, AF_UNIX, SOCK_STREAM, break_uds_recv); 3365 } 3366 3367 #define MAX_BYTES 2 /* set to 3 for slightly better(?) testing */ 3368 #define USLEEP_TIME 250000 /* increase on wimpy platforms if needed */ 3369 3370 /* 3371 * Signal handler which just needs to exist, so that invoking it will interrupt 3372 * an ongoing system call. 3373 */ 3374 static void 3375 test90_got_signal(int sig __unused) 3376 { 3377 3378 /* Nothing. */ 3379 } 3380 3381 /* 3382 * Test for sending on stream sockets. The quick summary here is that send() 3383 * should basically act as the mirror of recv(MSG_WAITALL), i.e., it should 3384 * keep suspending until all data is sent (or the call is interrupted or no 3385 * more can possibly be sent), and, SO_SNDLOWAT, mirroring SO_RCVLOWAT, acts as 3386 * an admission test for the send: nothing is sent until there is room in the 3387 * send buffer (i.e., the peer's receive buffer) for at least the low send 3388 * watermark, or the whole send request length, whichever is smaller. In 3389 * addition, select(2) should use the same threshold. 3390 */ 3391 static void 3392 sub90v(int iroom, int istate, int slowat, int len, int bits, int act) 3393 { 3394 const char *data = "ABC"; /* this limits MAX_BYTES to 3 */ 3395 struct sigaction sa; 3396 struct timeval tv; 3397 fd_set fds; 3398 char buf[2], *sndbuf; 3399 pid_t pid; 3400 int fd[2], rcvlen, min, flags, res, err; 3401 int pfd[2], eroom, tstate, fl, status; 3402 3403 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0); 3404 3405 /* 3406 * Set up the initial condition on the sockets. 3407 */ 3408 rcvlen = get_rcvbuf_len(fd[1]); 3409 if (rcvlen <= iroom) e(0); 3410 rcvlen -= iroom; 3411 3412 if ((sndbuf = malloc(rcvlen)) == NULL) e(0); 3413 3414 memset(sndbuf, 'X', rcvlen); 3415 if (send(fd[0], sndbuf, rcvlen, 0) != rcvlen) e(0); 3416 3417 free(sndbuf); 3418 3419 switch (istate) { 3420 case 0: break; 3421 case 1: if (shutdown(fd[0], SHUT_WR) != 0) e(0); break; 3422 case 2: if (shutdown(fd[1], SHUT_RD) != 0) e(0); break; 3423 case 3: if (close(fd[1]) != 0) e(0); break; 3424 } 3425 3426 if (setsockopt(fd[0], SOL_SOCKET, SO_SNDLOWAT, &slowat, 3427 sizeof(slowat)) != 0) e(0); 3428 3429 /* SO_SNDLOWAT is always bounded by the actual send length. */ 3430 min = MIN(len, slowat); 3431 3432 flags = MSG_NOSIGNAL; 3433 if (bits & 1) flags |= MSG_DONTWAIT; 3434 3435 /* 3436 * Do a quick select test to see if its result indeed matches whether 3437 * the available space in the "send" buffer meets the threshold. 3438 */ 3439 FD_ZERO(&fds); 3440 FD_SET(fd[0], &fds); 3441 tv.tv_sec = 0; 3442 tv.tv_usec = 0; 3443 res = select(fd[0] + 1, NULL, &fds, NULL, &tv); 3444 if (res < 0 || res > 1) e(0); 3445 if (res != (iroom >= slowat || istate > 0)) e(0); 3446 if (res == 1 && !FD_ISSET(fd[0], &fds)) e(0); 3447 3448 /* 3449 * Cut short a whole lot of cases, to avoid the overhead of forking, 3450 * namely when we know the call should return immediately. This is the 3451 * case when the socket state disallows further sending, or when all 3452 * data could be sent, or when the call was non-blocking. The low 3453 * send watermark only helps determine whether anything was sent here. 3454 */ 3455 if (istate > 0 || iroom >= len || (flags & MSG_DONTWAIT)) { 3456 res = send(fd[0], data, len, flags); 3457 3458 if (istate > 0) { 3459 if (res != -1) e(0); 3460 if (errno != EPIPE) e(0); 3461 } else if (iroom >= len) { 3462 if (res != len) e(0); 3463 } else if (iroom >= min) { 3464 if (res != iroom) e(0); 3465 } else { 3466 if (res != -1) e(0); 3467 if (errno != EWOULDBLOCK) e(0); 3468 } 3469 3470 /* Early cleanup and return to avoid even more code clutter. */ 3471 if (istate != 3 && close(fd[1]) != 0) e(0); 3472 if (close(fd[0]) != 0) e(0); 3473 3474 return; 3475 } 3476 3477 /* 3478 * Now starts the interesting stuff: the send call should now block, 3479 * even though if we add MSG_DONTWAIT it may not return EWOULDBLOCK, 3480 * because MSG_DONTWAIT prevents the send from blocking after partial 3481 * completion. As such, we can only test our expectations by letting 3482 * the call block, in a child process, and waiting. We do test as much 3483 * of the above assumption as we can for safety right here, but this is 3484 * not a substitute for actually blocking even in these cases! 3485 */ 3486 if (iroom < min) { 3487 if (send(fd[0], data, len, flags | MSG_DONTWAIT) != -1) e(0); 3488 if (errno != EWOULDBLOCK) e(0); 3489 } 3490 3491 /* 3492 * If (act < 9), we receive 0, 1, or 2 bytes from the receive queue 3493 * before forcing the send call to terminate in one of three ways. 3494 * 3495 * If (act == 9), we use a signal to interrupt the send call. 3496 */ 3497 if (act < 9) { 3498 eroom = act % 3; 3499 tstate = act / 3; 3500 } else 3501 eroom = tstate = 0; 3502 3503 if (pipe2(pfd, O_NONBLOCK) != 0) e(0); 3504 3505 pid = fork(); 3506 switch (pid) { 3507 case 0: 3508 errct = 0; 3509 3510 if (close(fd[1]) != 0) e(0); 3511 if (close(pfd[0]) != 0) e(0); 3512 3513 if (act == 9) { 3514 memset(&sa, 0, sizeof(sa)); 3515 sa.sa_handler = test90_got_signal; 3516 if (sigaction(SIGUSR1, &sa, NULL) != 0) e(0); 3517 } 3518 3519 res = send(fd[0], data, len, flags); 3520 err = errno; 3521 3522 if (write(pfd[1], &res, sizeof(res)) != sizeof(res)) e(0); 3523 if (write(pfd[1], &err, sizeof(err)) != sizeof(err)) e(0); 3524 3525 exit(errct); 3526 case -1: 3527 e(0); 3528 } 3529 3530 if (close(pfd[1]) != 0) e(0); 3531 3532 /* 3533 * Allow the child to enter the blocking send(2), and check the pipe 3534 * to see if it is really blocked. 3535 */ 3536 if (usleep(USLEEP_TIME) != 0) e(0); 3537 3538 if (read(pfd[0], &res, sizeof(res)) != -1) e(0); 3539 if (errno != EAGAIN) e(0); 3540 3541 if (eroom > 0) { 3542 if (recv(fd[1], buf, eroom, 0) != eroom) e(0); 3543 3544 /* 3545 * The threshold for the send is now met if the entire request 3546 * has been satisfied. 3547 */ 3548 if (iroom + eroom >= len) { 3549 if ((fl = fcntl(pfd[0], F_GETFL)) == -1) e(0); 3550 if (fcntl(pfd[0], F_SETFL, fl & ~O_NONBLOCK) != 0) 3551 e(0); 3552 3553 if (read(pfd[0], &res, sizeof(res)) != sizeof(res)) 3554 e(0); 3555 if (read(pfd[0], &err, sizeof(err)) != sizeof(err)) 3556 e(0); 3557 3558 if (res != len) e(0); 3559 3560 /* Bail out. */ 3561 goto cleanup; 3562 } 3563 } 3564 3565 if (act < 9) { 3566 /* 3567 * Now test various ways to terminate the send call. Ideally 3568 * we would also like to have a case that raises a socket error 3569 * here, but with UDS there is currently no way to do that. 3570 */ 3571 switch (tstate) { 3572 case 0: if (shutdown(fd[0], SHUT_WR) != 0) e(0); break; 3573 case 1: if (shutdown(fd[1], SHUT_RD) != 0) e(0); break; 3574 case 2: if (close(fd[1]) != 0) e(0); fd[1] = -1; break; 3575 } 3576 } else 3577 if (kill(pid, SIGUSR1) != 0) e(0); 3578 3579 if ((fl = fcntl(pfd[0], F_GETFL)) == -1) e(0); 3580 if (fcntl(pfd[0], F_SETFL, fl & ~O_NONBLOCK) != 0) e(0); 3581 3582 if (read(pfd[0], &res, sizeof(res)) != sizeof(res)) e(0); 3583 if (read(pfd[0], &err, sizeof(err)) != sizeof(err)) e(0); 3584 3585 /* 3586 * If the send met the threshold before being terminate or interrupted, 3587 * we should at least have sent something. Otherwise, the send was 3588 * never admitted and should return EPIPE (if the send was terminated) 3589 * or EINTR (if the child was killed). 3590 */ 3591 if (iroom + eroom >= min) { 3592 if (res != MIN(iroom + eroom, len)) e(0); 3593 } else { 3594 if (res != -1) e(0); 3595 if (act < 9) { 3596 if (err != EPIPE) e(0); 3597 } else 3598 if (err != EINTR) e(0); 3599 } 3600 3601 cleanup: 3602 if (close(pfd[0]) != 0) e(0); 3603 3604 if (wait(&status) != pid) e(0); 3605 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0); 3606 3607 if (fd[1] != -1 && close(fd[1]) != 0) e(0); 3608 if (close(fd[0]) != 0) e(0); 3609 } 3610 3611 /* 3612 * Test for sending on stream sockets. In particular, test SO_SNDLOWAT and 3613 * MSG_DONTWAIT. 3614 */ 3615 static void 3616 test90v(void) 3617 { 3618 int iroom, istate, slowat, len, bits, act; 3619 3620 subtest = 22; 3621 3622 /* Insanity. */ 3623 for (iroom = 0; iroom <= MAX_BYTES; iroom++) 3624 for (istate = 0; istate <= 3; istate++) 3625 for (slowat = 1; slowat <= MAX_BYTES; slowat++) 3626 for (len = 1; len <= MAX_BYTES; len++) 3627 for (bits = 0; bits < 2; bits++) 3628 for (act = 0; act <= 9; act++) 3629 sub90v(iroom, istate, 3630 slowat, len, bits, 3631 act); 3632 } 3633 3634 /* 3635 * Test that SO_RCVLOWAT is limited to the size of the receive buffer. 3636 */ 3637 static void 3638 sub90w_recv(int fill_delta, int rlowat_delta, int exp_delta) 3639 { 3640 char *buf; 3641 int fd[2], rcvlen, fill, rlowat, res; 3642 3643 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0); 3644 3645 rcvlen = get_rcvbuf_len(fd[0]); 3646 3647 if ((buf = malloc(rcvlen + 1)) == NULL) e(0); 3648 3649 fill = rcvlen + fill_delta; 3650 rlowat = rcvlen + rlowat_delta; 3651 3652 memset(buf, 0, fill); 3653 3654 if (send(fd[1], buf, fill, 0) != fill) e(0); 3655 3656 if (setsockopt(fd[0], SOL_SOCKET, SO_RCVLOWAT, &rlowat, 3657 sizeof(rlowat)) != 0) e(0); 3658 3659 res = recv(fd[0], buf, rcvlen + 1, MSG_DONTWAIT); 3660 if (exp_delta < 0) { 3661 if (res != -1) e(0); 3662 if (errno != EWOULDBLOCK) e(0); 3663 } else 3664 if (res != rcvlen - exp_delta) e(0); 3665 3666 free(buf); 3667 3668 if (close(fd[0]) != 0) e(0); 3669 if (close(fd[1]) != 0) e(0); 3670 } 3671 3672 /* 3673 * Test that SO_SNDLOWAT is limited to the size of the "send" buffer. 3674 */ 3675 static void 3676 sub90w_send(int fill, int slowat_delta, int exp_delta) 3677 { 3678 char *buf; 3679 socklen_t len; 3680 int fd[2], sndlen, slowat, res; 3681 3682 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0); 3683 3684 len = sizeof(sndlen); 3685 if (getsockopt(fd[0], SOL_SOCKET, SO_SNDBUF, &sndlen, &len) != 0) e(0); 3686 if (len != sizeof(sndlen)) e(0); 3687 3688 if ((buf = malloc(sndlen + 1)) == NULL) e(0); 3689 3690 slowat = sndlen + slowat_delta; 3691 3692 if (fill > 0) { 3693 memset(buf, 0, fill); 3694 3695 if (send(fd[0], buf, fill, 0) != fill) e(0); 3696 } 3697 3698 if (setsockopt(fd[0], SOL_SOCKET, SO_SNDLOWAT, &slowat, 3699 sizeof(slowat)) != 0) e(0); 3700 3701 res = send(fd[0], buf, sndlen + 1, MSG_DONTWAIT); 3702 if (exp_delta < 0) { 3703 if (res != -1) e(0); 3704 if (errno != EWOULDBLOCK) e(0); 3705 } else 3706 if (res != sndlen - exp_delta) e(0); 3707 3708 free(buf); 3709 3710 if (close(fd[0]) != 0) e(0); 3711 if (close(fd[1]) != 0) e(0); 3712 } 3713 3714 /* 3715 * Test that on stream sockets, SO_RCVLOWAT and SO_SNDLOWAT are limited to 3716 * their respective buffer sizes. 3717 */ 3718 static void 3719 test90w(void) 3720 { 3721 3722 subtest = 23; 3723 3724 /* 3725 * With the receive buffer filled except for one byte, all data should 3726 * be retrieved unless the threshold is not met. 3727 */ 3728 sub90w_recv(-1, -1, 1); 3729 sub90w_recv(-1, 0, -1); 3730 sub90w_recv(-1, 1, -1); 3731 3732 /* 3733 * With the receive buffer filled completely, all data should be 3734 * retrieved in all cases. 3735 */ 3736 sub90w_recv(0, -1, 0); 3737 sub90w_recv(0, 0, 0); 3738 sub90w_recv(0, 1, 0); 3739 3740 /* 3741 * With a "send" buffer that contains one byte, all data should be sent 3742 * unless the threshold is not met. 3743 */ 3744 sub90w_send(1, -1, 1); 3745 sub90w_send(1, 0, -1); 3746 sub90w_send(1, 1, -1); 3747 3748 /* 3749 * With the "send" buffer filled completely, all data should be sent 3750 * in all cases. 3751 */ 3752 sub90w_send(0, -1, 0); 3753 sub90w_send(0, 0, 0); 3754 sub90w_send(0, 1, 0); 3755 } 3756 3757 /* 3758 * Test shutdown on listening sockets. 3759 */ 3760 static void 3761 sub90x(int type, int how, int connwait) 3762 { 3763 struct sockaddr_un sun; 3764 socklen_t len; 3765 char buf[1]; 3766 int fd, fd2, fd3, val, fl; 3767 3768 subtest = 24; 3769 3770 fd = get_bound_socket(type, SOCK_PATH_A, &sun); 3771 3772 if (listen(fd, 5) != 0) e(0); 3773 3774 if (!connwait) { 3775 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 3776 3777 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) 3778 e(0); 3779 } else { 3780 val = 1; 3781 if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) 3782 e(0); 3783 3784 if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 3785 3786 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != -1) 3787 e(0); 3788 if (errno != EINPROGRESS) e(0); 3789 } 3790 3791 if (shutdown(fd, how) != 0) e(0); 3792 3793 len = sizeof(sun); 3794 if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 3795 3796 if (write(fd2, "A", 1) != 1) e(0); 3797 if (read(fd3, buf, 1) != 1) e(0); 3798 if (buf[0] != 'A') e(0); 3799 3800 if (write(fd3, "B", 1) != 1) e(0); 3801 if (read(fd2, buf, 1) != 1) e(0); 3802 if (buf[0] != 'B') e(0); 3803 3804 len = sizeof(sun); 3805 if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0); 3806 if (errno != ECONNABORTED) e(0); 3807 3808 /* 3809 * Strangely, both NetBSD and Linux (yes, my two reference platforms) 3810 * return EWOULDBLOCK from non-blocking accept(2) calls even though 3811 * they always return ECONNABORTED when blocking. For consistency and 3812 * select(2), we always return ECONNABORTED. 3813 */ 3814 if ((fl = fcntl(fd, F_GETFL)) == -1) e(0); 3815 if (fcntl(fd, F_SETFL, fl | O_NONBLOCK) != 0) e(0); 3816 3817 len = sizeof(sun); 3818 if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0); 3819 if (errno != ECONNABORTED) e(0); 3820 3821 if (fcntl(fd, F_SETFL, fl) != 0) e(0); 3822 3823 if (close(fd3) != 0) e(0); 3824 if (close(fd2) != 0) e(0); 3825 3826 if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0); 3827 3828 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != -1) e(0); 3829 if (errno != ECONNREFUSED) e(0); 3830 3831 len = sizeof(sun); 3832 if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0); 3833 if (errno != ECONNABORTED) e(0); 3834 3835 if (close(fd2) != 0) e(0); 3836 if (close(fd) != 0) e(0); 3837 3838 if (unlink(SOCK_PATH_A) != 0) e(0); 3839 } 3840 3841 /* 3842 * Test shutdown on listening sockets. Pending connections should still be 3843 * acceptable (and not inherit the shutdown flags), but new connections must be 3844 * refused, and the accept call must no longer ever block. 3845 */ 3846 static void 3847 test90x(void) 3848 { 3849 const int types[] = { SOCK_STREAM, SOCK_SEQPACKET }; 3850 const int hows[] = { SHUT_RD, SHUT_WR, SHUT_RDWR }; 3851 unsigned int i, j, k; 3852 3853 for (i = 0; i < __arraycount(types); i++) 3854 for (j = 0; j < __arraycount(hows); j++) 3855 for (k = 0; k <= 1; k++) 3856 sub90x(types[i], hows[j], k); 3857 } 3858 3859 /* 3860 * Test accepting connections without LOCAL_CONNWAIT for the given socket type. 3861 */ 3862 static void 3863 sub90y(int type) 3864 { 3865 struct sockaddr_un sunA, sunB, sunC; 3866 socklen_t len; 3867 struct timeval tv; 3868 fd_set fds; 3869 char buf[7]; 3870 uid_t uid; 3871 gid_t gid; 3872 int fd, fd2, fd3, fd4, val; 3873 3874 fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A, &sunA); 3875 3876 len = sizeof(val); 3877 if (getsockopt(fd, 0, LOCAL_CONNWAIT, &val, &len) != 0) e(0); 3878 if (len != sizeof(val)) e(0); 3879 if (val != 0) e(0); 3880 3881 if (listen(fd, 5) != 0) e(0); 3882 3883 /* 3884 * Any socket options should be inherited from the listening socket at 3885 * connect time, and not be re-inherited at accept time. It does not 3886 * really matter what socket option we set here, as long as it is 3887 * supposed to be inherited. 3888 */ 3889 val = 123; 3890 if (setsockopt(fd, SOL_SOCKET, SO_SNDLOWAT, &val, sizeof(val)) != 0) 3891 e(0); 3892 3893 fd2 = get_bound_socket(type, SOCK_PATH_B, &sunB); 3894 3895 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3896 3897 val = 456; 3898 if (setsockopt(fd, SOL_SOCKET, SO_SNDLOWAT, &val, sizeof(val)) != 0) 3899 e(0); 3900 3901 /* 3902 * Obtaining the peer name should work. As always, the name should be 3903 * inherited from the listening socket. 3904 */ 3905 len = sizeof(sunC); 3906 if (getpeername(fd2, (struct sockaddr *)&sunC, &len) != 0) e(0); 3907 check_addr(&sunC, len, SOCK_PATH_A); 3908 3909 /* 3910 * Obtaining peer credentials should work. This is why NetBSD obtains 3911 * the peer credentials at bind time, not at accept time. 3912 */ 3913 if (getpeereid(fd2, &uid, &gid) != 0) e(0); 3914 if (uid != geteuid()) e(0); 3915 if (gid != getegid()) e(0); 3916 3917 /* 3918 * Sending to the socket should work, and it should be possible to 3919 * receive the data from the other side once accepted. 3920 */ 3921 if (send(fd2, "Hello, ", 7, 0) != 7) e(0); 3922 if (send(fd2, "world!", 6, 0) != 6) e(0); 3923 3924 /* Shutdown settings should be visible after accepting, too. */ 3925 if (shutdown(fd2, SHUT_RDWR) != 0) e(0); 3926 3927 len = sizeof(sunB); 3928 if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0); 3929 check_addr(&sunB, len, SOCK_PATH_B); 3930 3931 len = sizeof(val); 3932 if (getsockopt(fd3, SOL_SOCKET, SO_SNDLOWAT, &val, &len) != 0) e(0); 3933 if (len != sizeof(val)) e(0); 3934 if (val != 123) e(0); 3935 3936 if (recv(fd3, buf, 7, 0) != 7) e(0); 3937 if (memcmp(buf, "Hello, ", 7) != 0) e(0); 3938 if (recv(fd3, buf, 7, 0) != 6) e(0); 3939 if (memcmp(buf, "world!", 6) != 0) e(0); 3940 3941 if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0); 3942 3943 if (send(fd3, "X", 1, MSG_NOSIGNAL) != -1) e(0); 3944 if (errno != EPIPE) e(0); 3945 3946 if (close(fd2) != 0) e(0); 3947 if (close(fd3) != 0) e(0); 3948 3949 if (unlink(SOCK_PATH_B) != 0) e(0); 3950 3951 /* 3952 * If the socket pending acceptance is closed, the listening socket 3953 * should pretend as though the connection was never there. 3954 */ 3955 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 3956 3957 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3958 3959 FD_ZERO(&fds); 3960 FD_SET(fd, &fds); 3961 tv.tv_sec = 0; 3962 tv.tv_usec = 0; 3963 if (select(fd + 1, &fds, NULL, NULL, &tv) != 1) e(0); 3964 if (!FD_ISSET(fd, &fds)) e(0); 3965 3966 if (close(fd2) != 0) e(0); 3967 3968 if (select(fd + 1, &fds, NULL, NULL, &tv) != 0) e(0); 3969 if (FD_ISSET(fd, &fds)) e(0); 3970 3971 len = sizeof(sunB); 3972 if (accept(fd, (struct sockaddr *)&sunB, &len) != -1) e(0); 3973 if (errno != EWOULDBLOCK) e(0); 3974 3975 /* 3976 * Try the same thing, but now with the connection sandwiched between 3977 * two different pending connections, which should be left intact. 3978 */ 3979 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 3980 3981 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3982 3983 if (send(fd2, "A", 1, 0) != 1) e(0); 3984 3985 if ((fd3 = socket(AF_UNIX, type, 0)) < 0) e(0); 3986 3987 if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3988 3989 if (send(fd3, "B", 1, 0) != 1) e(0); 3990 3991 if ((fd4 = socket(AF_UNIX, type, 0)) < 0) e(0); 3992 3993 if (connect(fd4, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 3994 3995 if (send(fd4, "C", 1, 0) != 1) e(0); 3996 3997 if (close(fd3) != 0) e(0); 3998 3999 len = sizeof(sunB); 4000 if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0); 4001 4002 if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0); 4003 if (buf[0] != 'A') e(0); 4004 4005 if (close(fd3) != 0) e(0); 4006 if (close(fd2) != 0) e(0); 4007 4008 FD_ZERO(&fds); 4009 FD_SET(fd, &fds); 4010 tv.tv_sec = 0; 4011 tv.tv_usec = 0; 4012 if (select(fd + 1, &fds, NULL, NULL, &tv) != 1) e(0); 4013 if (!FD_ISSET(fd, &fds)) e(0); 4014 4015 len = sizeof(sunB); 4016 if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0); 4017 4018 if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0); 4019 if (buf[0] != 'C') e(0); 4020 4021 if (close(fd3) != 0) e(0); 4022 if (close(fd4) != 0) e(0); 4023 4024 if (select(fd + 1, &fds, NULL, NULL, &tv) != 0) e(0); 4025 if (FD_ISSET(fd, &fds)) e(0); 4026 4027 len = sizeof(sunB); 4028 if (accept(fd, (struct sockaddr *)&sunB, &len) != -1) e(0); 4029 if (errno != EWOULDBLOCK) e(0); 4030 4031 /* 4032 * If the listening socket is closed, the socket pending acceptance 4033 * should be reset. We actually rely on this behavior in the sweep 4034 * test, but we test this with more than one socket this time. 4035 */ 4036 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 4037 4038 if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 4039 4040 if ((fd3 = socket(AF_UNIX, type, 0)) < 0) e(0); 4041 4042 if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0); 4043 4044 if (close(fd) != 0) e(0); 4045 4046 if (recv(fd2, buf, sizeof(buf), 0) != -1) e(0); 4047 if (errno != ECONNRESET) e(0); 4048 4049 if (recv(fd2, buf, sizeof(buf), 0) != 0) e(0); 4050 4051 if (recv(fd3, buf, sizeof(buf), 0) != -1) e(0); 4052 if (errno != ECONNRESET) e(0); 4053 4054 if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0); 4055 4056 if (close(fd3) != 0) e(0); 4057 4058 if (close(fd2) != 0) e(0); 4059 4060 if (unlink(SOCK_PATH_A) != 0) e(0); 4061 } 4062 4063 /* 4064 * Test accepting connections without LOCAL_CONNWAIT. Since both the old UDS 4065 * service and the initial version of the new UDS service supported only the 4066 * LOCAL_CONNWAIT behavior, the alternative (which is now the default, as it is 4067 * on other platforms) has been a bit under-tested so far. 4068 */ 4069 static void 4070 test90y(void) 4071 { 4072 4073 subtest = 25; 4074 4075 sub90y(SOCK_STREAM); 4076 4077 sub90y(SOCK_SEQPACKET); 4078 } 4079 4080 /* 4081 * Test that SO_LINGER has no effect on sockets of the given type. 4082 */ 4083 static void 4084 sub90z(int type) 4085 { 4086 struct sockaddr_un sun; 4087 socklen_t len; 4088 struct linger l; 4089 char buf[1]; 4090 int fd, fd2, fd3; 4091 4092 fd = get_bound_socket(type, SOCK_PATH_A, &sun); 4093 4094 if (listen(fd, 1) != 0) e(0); 4095 4096 if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0); 4097 4098 if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0); 4099 4100 len = sizeof(sun); 4101 if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0); 4102 4103 if (close(fd) != 0) e(0); 4104 4105 if (send(fd2, "A", 1, 0) != 1) e(0); 4106 4107 l.l_onoff = 1; 4108 l.l_linger = 0; 4109 if (setsockopt(fd2, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) != 0) e(0); 4110 4111 if (close(fd2) != 0) e(0); 4112 4113 if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0); 4114 if (buf[0] != 'A') e(0); 4115 4116 /* We should not get ECONNRESET now. */ 4117 if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0); 4118 4119 if (close(fd3) != 0) e(0); 4120 4121 if (unlink(SOCK_PATH_A) != 0) e(0); 4122 } 4123 4124 /* 4125 * Test that SO_LINGER has no effect on UNIX domain sockets. In particular, a 4126 * timeout of zero does not cause the connection to be reset forcefully. 4127 */ 4128 static void 4129 test90z(void) 4130 { 4131 4132 subtest = 26; 4133 4134 sub90z(SOCK_STREAM); 4135 4136 sub90z(SOCK_SEQPACKET); 4137 } 4138 4139 /* 4140 * Test program for UDS. 4141 */ 4142 int 4143 main(int argc, char ** argv) 4144 { 4145 int i, m; 4146 4147 start(90); 4148 4149 if (argc == 2) 4150 m = atoi(argv[1]); 4151 else 4152 m = 0xFFFFFFF; 4153 4154 for (i = 0; i < ITERATIONS; i++) { 4155 if (m & 0x0000001) test90a(); 4156 if (m & 0x0000002) test90b(); 4157 if (m & 0x0000004) test90c(); 4158 if (m & 0x0000008) test90d(); 4159 if (m & 0x0000010) test90e(); 4160 if (m & 0x0000020) test90f(); 4161 if (m & 0x0000040) test90g(); 4162 if (m & 0x0000080) test90h(); 4163 if (m & 0x0000100) test90i(); 4164 if (m & 0x0000200) test90j(); 4165 if (m & 0x0000400) test90k(); 4166 if (m & 0x0000800) test90l(); 4167 if (m & 0x0001000) test90m(); 4168 if (m & 0x0002000) test90n(); 4169 if (m & 0x0004000) test90o(); 4170 if (m & 0x0008000) test90p(); 4171 if (m & 0x0010000) test90q(); 4172 if (m & 0x0020000) test90r(); 4173 if (m & 0x0040000) test90s(); 4174 if (m & 0x0080000) test90t(); 4175 if (m & 0x0100000) test90u(); 4176 if (m & 0x0200000) test90v(); 4177 if (m & 0x0400000) test90w(); 4178 if (m & 0x0800000) test90x(); 4179 if (m & 0x1000000) test90y(); 4180 if (m & 0x2000000) test90z(); 4181 } 4182 4183 quit(); 4184 /* NOTREACHED */ 4185 } 4186