tests/sys/kern/unix_seqpacket_test.c

   1 /*-
   2  * Copyright (c) 2014 Spectra Logic Corporation. All rights reserved.
   3  * Redistribution and use in source and binary forms, with or without
   4  * modification, are permitted provided that the following conditions
   5  * are met:
   6  * 1. Redistributions of source code must retain the above copyright
   7  *    notice, this list of conditions and the following disclaimer.
   8  * 2. Redistributions in binary form must reproduce the above copyright
   9  *    notice, this list of conditions and the following disclaimer in the
  10  *    documentation and/or other materials provided with the distribution.
  11  *
  12  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  13  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  14  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  15  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  16  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  17  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  18  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  19  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  20  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  21  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  22  * SUCH DAMAGE.
  23  */
  24
  25 #include <sys/cdefs.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <pthread.h>
  29 #include <signal.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32
  33 #include <stdio.h>
  34
  35 #include <atf-c.h>
  36
  37 /*
  38  * Helper functions
  39  */
  40
  41 #define MIN(x, y)       ((x) < (y) ? (x) : (y))
  42 #define MAX(x, y)       ((x) > (y) ? (x) : (y))
  43
  44 static void
  45 do_socketpair(int *sv)
  46 {
  47         int s;
  48
  49         s = socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sv);
  50         ATF_REQUIRE_EQ(0, s);
  51         ATF_REQUIRE(sv[0] >= 0);
  52         ATF_REQUIRE(sv[1] >= 0);
  53         ATF_REQUIRE(sv[0] != sv[1]);
  54 }
  55
  56 static void
  57 do_socketpair_nonblocking(int *sv)
  58 {
  59         int s;
  60
  61         s = socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sv);
  62         ATF_REQUIRE_EQ(0, s);
  63         ATF_REQUIRE(sv[0] >= 0);
  64         ATF_REQUIRE(sv[1] >= 0);
  65         ATF_REQUIRE(sv[0] != sv[1]);
  66         ATF_REQUIRE(-1 != fcntl(sv[0], F_SETFL, O_NONBLOCK));
  67         ATF_REQUIRE(-1 != fcntl(sv[1], F_SETFL, O_NONBLOCK));
  68 }
  69
  70 /*
  71  * Returns a pair of sockets made the hard way: bind, listen, connect & accept
  72  * @return      const char* The path to the socket
  73  */
  74 static const char*
  75 mk_pair_of_sockets(int *sv)
  76 {
  77         struct sockaddr_un sun;
  78         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
  79         const char *path = "sock";
  80         int s, err, s2, s1;
  81
  82         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
  83         ATF_REQUIRE(s >= 0);
  84
  85         bzero(&sun, sizeof(sun));
  86         sun.sun_family = AF_LOCAL;
  87         sun.sun_len = sizeof(sun);
  88         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
  89         err = bind(s, (struct sockaddr *)&sun, sizeof(sun));
  90         err = listen(s, -1);
  91         ATF_CHECK_EQ(0, err);
  92
  93         /* Create the other socket */
  94         s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
  95         ATF_REQUIRE(s2 >= 0);
  96         err = connect(s2, (struct sockaddr*)&sun, sizeof(sun));
  97         if (err != 0) {
  98                 perror("connect");
  99                 atf_tc_fail("connect(2) failed");
 100         }
 101
 102         /* Accept it */
 103         s1 = accept(s, NULL, NULL);
 104         if (s1 == -1) {
 105                 perror("accept");
 106                 atf_tc_fail("accept(2) failed");
 107         }
 108
 109         sv[0] = s1;
 110         sv[1] = s2;
 111
 112         close(s);
 113
 114         return (path);
 115 }
 116
 117 static volatile sig_atomic_t got_sigpipe = 0;
 118 static void
 119 shutdown_send_sigpipe_handler(int __unused x)
 120 {
 121         got_sigpipe = 1;
 122 }
 123
 124 /*
 125  * Parameterized test function bodies
 126  */
 127 static void
 128 test_eagain(int sndbufsize, int rcvbufsize)
 129 {
 130         int i;
 131         int sv[2];
 132         const size_t totalsize = (sndbufsize + rcvbufsize) * 2;
 133         const size_t pktsize = MIN(sndbufsize, rcvbufsize) / 4;
 134         const int numpkts = totalsize / pktsize;
 135         char sndbuf[pktsize];
 136         ssize_t ssize;
 137
 138         /* setup the socket pair */
 139         do_socketpair_nonblocking(sv);
 140         /* Setup the buffers */
 141         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 142             sizeof(sndbufsize)));
 143         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 144             sizeof(rcvbufsize)));
 145
 146         bzero(sndbuf, pktsize);
 147         /* Send data until we get EAGAIN */
 148         for(i=0; i < numpkts; i++) {
 149                 ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 150                 if (ssize == -1) {
 151                         if (errno == EAGAIN) {
 152                                 close(sv[0]);
 153                                 close(sv[1]);
 154                                 atf_tc_pass();
 155                         }
 156                         else {
 157                                 perror("send");
 158                                 atf_tc_fail("send returned < 0 but not EAGAIN");
 159                         }
 160                 }
 161         }
 162         atf_tc_fail("Never got EAGAIN");
 163 }
 164
 165 static void
 166 test_sendrecv_symmetric_buffers(int bufsize, int blocking) {
 167         int s;
 168         int sv[2];
 169         const ssize_t pktsize = bufsize / 2;
 170         char sndbuf[pktsize];
 171         char recv_buf[pktsize];
 172         ssize_t ssize, rsize;
 173
 174         /* setup the socket pair */
 175         if (blocking)
 176                 do_socketpair(sv);
 177         else
 178                 do_socketpair_nonblocking(sv);
 179
 180         /* Setup the buffers */
 181         s = setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
 182         ATF_REQUIRE_EQ(0, s);
 183         s = setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
 184         ATF_REQUIRE_EQ(0, s);
 185
 186         /* Fill the send buffer */
 187         bzero(sndbuf, pktsize);
 188
 189         /* send and receive the packet */
 190         ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 191         if (ssize < 0) {
 192                 perror("send");
 193                 atf_tc_fail("send returned < 0");
 194         }
 195         ATF_CHECK_EQ_MSG(pktsize, ssize, "expected %zd=send(...) but got %zd",
 196             pktsize, ssize);
 197
 198         rsize = recv(sv[1], recv_buf, pktsize, MSG_WAITALL);
 199         if (rsize < 0) {
 200                 perror("recv");
 201                 atf_tc_fail("recv returned < 0");
 202         }
 203         ATF_CHECK_EQ_MSG(pktsize, rsize, "expected %zd=send(...) but got %zd",
 204             pktsize, rsize);
 205         close(sv[0]);
 206         close(sv[1]);
 207 }
 208
 209 static void
 210 test_pipe_simulator(int sndbufsize, int rcvbufsize)
 211 {
 212         int num_sent, num_received;
 213         int sv[2];
 214         const ssize_t pktsize = MIN(sndbufsize, rcvbufsize) / 4;
 215         int numpkts;
 216         char sndbuf[pktsize];
 217         char rcvbuf[pktsize];
 218         char comparebuf[pktsize];
 219         ssize_t ssize, rsize;
 220         bool currently_sending = true;
 221
 222         /* setup the socket pair */
 223         do_socketpair_nonblocking(sv);
 224         /* Setup the buffers */
 225         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 226             sizeof(sndbufsize)));
 227         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 228             sizeof(rcvbufsize)));
 229
 230         /* Send a total amount of data comfortably greater than the buffers */
 231         numpkts = MAX(sndbufsize, rcvbufsize) * 8 / pktsize;
 232         for (num_sent=0, num_received=0;
 233              num_sent < numpkts || num_received < numpkts; ) {
 234                 if (currently_sending && num_sent < numpkts) {
 235                         /* The simulated sending process */
 236                         /* fill the buffer */
 237                         memset(sndbuf, num_sent, pktsize);
 238                         ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 239                         if (ssize < 0) {
 240                                 /*
 241                                  * XXX: This is bug-compatible with the kernel.
 242                                  * The kernel returns EMSGSIZE when it should
 243                                  * return EAGAIN
 244                                  */
 245                                 if (errno == EAGAIN || errno == EMSGSIZE)
 246                                         currently_sending = false;
 247                                 else {
 248                                         perror("send");
 249                                         atf_tc_fail("send failed");
 250                                 }
 251                         } else  {
 252                                 ATF_CHECK_EQ_MSG(pktsize, ssize,
 253                                     "expected %zd=send(...) but got %zd",
 254                                     pktsize, ssize);
 255                                 num_sent++;
 256                         }
 257                 } else {
 258                         /* The simulated receiving process */
 259                         rsize = recv(sv[1], rcvbuf, pktsize, MSG_WAITALL);
 260                         if (rsize < 0) {
 261                                 if (errno == EAGAIN) {
 262                                         currently_sending = true;
 263                                         ATF_REQUIRE_MSG(num_sent < numpkts,
 264                                             "Packets were lost!");
 265                                 }
 266                                 else {
 267                                         perror("recv");
 268                                         atf_tc_fail("recv failed");
 269                                 }
 270                         } else  {
 271                                 ATF_CHECK_EQ_MSG(pktsize, rsize,
 272                                     "expected %zd=recv(...) but got %zd",
 273                                     pktsize, rsize);
 274                                 memset(comparebuf, num_received, pktsize);
 275                                 ATF_CHECK_EQ_MSG(0, memcmp(comparebuf, rcvbuf,
 276                                                            pktsize),
 277                                     "Received data miscompare");
 278                                 num_received++;
 279                         }
 280                 }
 281         }
 282         close(sv[0]);
 283         close(sv[1]);
 284 }
 285
 286 typedef struct {
 287         ssize_t pktsize;
 288         int     numpkts;
 289         int     so;
 290 } test_pipe_thread_data_t;
 291
 292 static void*
 293 test_pipe_writer(void* args)
 294 {
 295         test_pipe_thread_data_t* td = args;
 296         char sndbuf[td->pktsize];
 297         ssize_t ssize;
 298         int i;
 299
 300         for(i=0; i < td->numpkts; i++) {
 301                         memset(sndbuf, i, td->pktsize);
 302                         ssize = send(td->so, sndbuf, td->pktsize, MSG_EOR);
 303                         if (ssize < 0) {
 304                                 perror("send");
 305                                 atf_tc_fail("send returned < 0");
 306                         }
 307                         ATF_CHECK_EQ_MSG(td->pktsize, ssize,
 308                                          "expected %zd=send(...) but got %zd",
 309                                           td->pktsize, ssize);
 310         }
 311         return (0);
 312 }
 313
 314 static void*
 315 test_pipe_reader(void* args)
 316 {
 317         test_pipe_thread_data_t* td = args;
 318         char rcvbuf[td->pktsize];
 319         char comparebuf[td->pktsize];
 320         ssize_t rsize;
 321         int i, d;
 322
 323         for(i=0; i < td->numpkts; i++) {
 324                 memset(comparebuf, i, td->pktsize);
 325                 rsize = recv(td->so, rcvbuf, td->pktsize, MSG_WAITALL);
 326                 if (rsize < 0) {
 327                         perror("recv");
 328                         atf_tc_fail("recv returned < 0");
 329                 }
 330                 ATF_CHECK_EQ_MSG(td->pktsize, rsize,
 331                                  "expected %zd=send(...) but got %zd",
 332                                  td->pktsize, rsize);
 333                 d = memcmp(comparebuf, rcvbuf, td->pktsize);
 334                 ATF_CHECK_EQ_MSG(0, d,
 335                                  "Received data miscompare on packet %d", i);
 336         }
 337         return (0);
 338 }
 339
 340
 341 static void
 342 test_pipe(int sndbufsize, int rcvbufsize)
 343 {
 344         test_pipe_thread_data_t writer_data, reader_data;
 345         pthread_t writer, reader;
 346         int sv[2];
 347         const size_t pktsize = MIN(sndbufsize, rcvbufsize) / 4;
 348         int numpkts;
 349
 350         /* setup the socket pair */
 351         do_socketpair(sv);
 352         /* Setup the buffers */
 353         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 354             sizeof(sndbufsize)));
 355         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 356             sizeof(rcvbufsize)));
 357
 358         /* Send a total amount of data comfortably greater than the buffers */
 359         numpkts = MAX(sndbufsize, rcvbufsize) * 8 / pktsize;
 360
 361         /* Start the child threads */
 362         writer_data.pktsize = pktsize;
 363         writer_data.numpkts = numpkts;
 364         writer_data.so = sv[0];
 365         reader_data.pktsize = pktsize;
 366         reader_data.numpkts = numpkts;
 367         reader_data.so = sv[1];
 368         ATF_REQUIRE_EQ(0, pthread_create(&writer, NULL, test_pipe_writer,
 369                                          (void*)&writer_data));
 370         /*
 371          * Give the writer time to start writing, and hopefully block, before
 372          * starting the reader.  This increases the likelihood of the test case
 373          * failing due to PR kern/185812
 374          */
 375         usleep(1000);
 376         ATF_REQUIRE_EQ(0, pthread_create(&reader, NULL, test_pipe_reader,
 377                                          (void*)&reader_data));
 378
 379         /* Join the children */
 380         ATF_REQUIRE_EQ(0, pthread_join(writer, NULL));
 381         ATF_REQUIRE_EQ(0, pthread_join(reader, NULL));
 382         close(sv[0]);
 383         close(sv[1]);
 384 }
 385
 386
 387 /*
 388  * Test Cases
 389  */
 390
 391 /* Create a SEQPACKET socket */
 392 ATF_TC_WITHOUT_HEAD(create_socket);
 393 ATF_TC_BODY(create_socket, tc)
 394 {
 395         int s;
 396
 397         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 398         ATF_REQUIRE(s >= 0);
 399         close(s);
 400 }
 401
 402 /* Create SEQPACKET sockets using socketpair(2) */
 403 ATF_TC_WITHOUT_HEAD(create_socketpair);
 404 ATF_TC_BODY(create_socketpair, tc)
 405 {
 406         int sv[2];
 407         int s;
 408
 409         s = socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sv);
 410         ATF_CHECK_EQ(0, s);
 411         ATF_CHECK(sv[0] >= 0);
 412         ATF_CHECK(sv[1] >= 0);
 413         ATF_CHECK(sv[0] != sv[1]);
 414         close(sv[0]);
 415         close(sv[1]);
 416 }
 417
 418 /* Call listen(2) without first calling bind(2).  It should fail */
 419 ATF_TC_WITHOUT_HEAD(listen_unbound);
 420 ATF_TC_BODY(listen_unbound, tc)
 421 {
 422         int s, r;
 423
 424         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 425         ATF_REQUIRE(s > 0);
 426         r = listen(s, -1);
 427         /* expect listen to fail since we haven't called bind(2) */
 428         ATF_CHECK(r != 0);
 429         close(s);
 430 }
 431
 432 /* Bind the socket to a file */
 433 ATF_TC_WITHOUT_HEAD(bind);
 434 ATF_TC_BODY(bind, tc)
 435 {
 436         struct sockaddr_un sun;
 437         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
 438         const char *path = "sock";
 439         int s, r;
 440
 441         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 442         ATF_REQUIRE(s >= 0);
 443
 444         bzero(&sun, sizeof(sun));
 445         sun.sun_family = AF_LOCAL;
 446         sun.sun_len = sizeof(sun);
 447         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
 448         r = bind(s, (struct sockaddr *)&sun, sizeof(sun));
 449         ATF_CHECK_EQ(0, r);
 450         close(s);
 451 }
 452
 453 /* listen(2) a socket that is already bound(2) should succeed */
 454 ATF_TC_WITHOUT_HEAD(listen_bound);
 455 ATF_TC_BODY(listen_bound, tc)
 456 {
 457         struct sockaddr_un sun;
 458         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
 459         const char *path = "sock";
 460         int s, r, l;
 461
 462         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 463         ATF_REQUIRE(s >= 0);
 464
 465         bzero(&sun, sizeof(sun));
 466         sun.sun_family = AF_LOCAL;
 467         sun.sun_len = sizeof(sun);
 468         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
 469         r = bind(s, (struct sockaddr *)&sun, sizeof(sun));
 470         l = listen(s, -1);
 471         ATF_CHECK_EQ(0, r);
 472         ATF_CHECK_EQ(0, l);
 473         close(s);
 474 }
 475
 476 /* connect(2) can make a connection */
 477 ATF_TC_WITHOUT_HEAD(connect);
 478 ATF_TC_BODY(connect, tc)
 479 {
 480         struct sockaddr_un sun;
 481         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
 482         const char *path = "sock";
 483         int s, r, err, l, s2;
 484
 485         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 486         ATF_REQUIRE(s >= 0);
 487
 488         bzero(&sun, sizeof(sun));
 489         sun.sun_family = AF_LOCAL;
 490         sun.sun_len = sizeof(sun);
 491         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
 492         r = bind(s, (struct sockaddr *)&sun, sizeof(sun));
 493         l = listen(s, -1);
 494         ATF_CHECK_EQ(0, r);
 495         ATF_CHECK_EQ(0, l);
 496
 497         /* Create the other socket */
 498         s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 499         ATF_REQUIRE(s2 >= 0);
 500         err = connect(s2, (struct sockaddr*)&sun, sizeof(sun));
 501         if (err != 0) {
 502                 perror("connect");
 503                 atf_tc_fail("connect(2) failed");
 504         }
 505         close(s);
 506         close(s2);
 507 }
 508
 509 /* accept(2) can receive a connection */
 510 ATF_TC_WITHOUT_HEAD(accept);
 511 ATF_TC_BODY(accept, tc)
 512 {
 513         int sv[2];
 514
 515         mk_pair_of_sockets(sv);
 516         close(sv[0]);
 517         close(sv[1]);
 518 }
 519
 520
 521 /* Set O_NONBLOCK on the socket */
 522 ATF_TC_WITHOUT_HEAD(fcntl_nonblock);
 523 ATF_TC_BODY(fcntl_nonblock, tc)
 524 {
 525         int s;
 526
 527         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 528         ATF_REQUIRE(s >= 0);
 529         if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
 530                 perror("fcntl");
 531                 atf_tc_fail("fcntl failed");
 532         }
 533         close(s);
 534 }
 535
 536 /* Resize the send and receive buffers */
 537 ATF_TC_WITHOUT_HEAD(resize_buffers);
 538 ATF_TC_BODY(resize_buffers, tc)
 539 {
 540         int s;
 541         int sndbuf = 12345;
 542         int rcvbuf = 23456;
 543         int xs, xr;
 544         socklen_t sl = sizeof(xs);
 545
 546         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 547         ATF_REQUIRE(s >= 0);
 548
 549         printf("                       Socket Buffer Sizes\n");
 550         printf("                              | SNDBUF  | RCVBUF  |\n");
 551         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));
 552         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));
 553         printf("Default                       | %7d | %7d |\n", xs, xr);
 554
 555         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)) != 0){
 556                 perror("setsockopt");
 557                 atf_tc_fail("setsockopt(SO_SNDBUF) failed");
 558         }
 559         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));
 560         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));
 561         printf("After changing SNDBUF         | %7d | %7d |\n", xs, xr);
 562
 563         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)) != 0){
 564                 perror("setsockopt");
 565                 atf_tc_fail("setsockopt(SO_RCVBUF) failed");
 566         }
 567         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));
 568         ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));
 569         printf("After changing RCVBUF         | %7d | %7d |\n", xs, xr);
 570         close(s);
 571 }
 572
 573 /*
 574  * Resize the send and receive buffers of a connected socketpair
 575  * Print some useful debugging info too
 576  */
 577 ATF_TC_WITHOUT_HEAD(resize_connected_buffers);
 578 ATF_TC_BODY(resize_connected_buffers, tc)
 579 {
 580         int sv[2];
 581         int sndbuf = 12345;
 582         int rcvbuf = 23456;
 583         int err;
 584         int ls, lr, rs, rr;
 585         socklen_t sl = sizeof(ls);
 586
 587         /* setup the socket pair */
 588         do_socketpair(sv);
 589
 590         printf("                       Socket Buffer Sizes\n");
 591         printf("                              | Left Socket       | Right Socket      |\n");
 592         printf("                              | SNDBUF  | RCVBUF  | SNDBUF  | RCVBUF  |\n");
 593         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl));
 594         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl));
 595         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl));
 596         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl));
 597         printf("Default                       | %7d | %7d | %7d | %7d |\n",
 598             ls, lr, rs, rr);
 599
 600         /* Update one side's send buffer */
 601         err = setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
 602         if (err != 0){
 603                 perror("setsockopt");
 604                 atf_tc_fail("setsockopt(SO_SNDBUF) failed");
 605         }
 606
 607         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl));
 608         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl));
 609         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl));
 610         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl));
 611         printf("After changing Left's SNDBUF  | %7d | %7d | %7d | %7d |\n",
 612             ls, lr, rs, rr);
 613
 614         /* Update the same side's receive buffer */
 615         err = setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
 616         if (err != 0){
 617                 perror("setsockopt");
 618                 atf_tc_fail("setsockopt(SO_RCVBUF) failed");
 619         }
 620
 621         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &ls, &sl));
 622         ATF_CHECK_EQ(0, getsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &lr, &sl));
 623         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &rs, &sl));
 624         ATF_CHECK_EQ(0, getsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rr, &sl));
 625         printf("After changing Left's RCVBUF  | %7d | %7d | %7d | %7d |\n",
 626             ls, lr, rs, rr);
 627         close(sv[0]);
 628         close(sv[1]);
 629 }
 630
 631
 632 /* send(2) and recv(2) a single short record */
 633 ATF_TC_WITHOUT_HEAD(send_recv);
 634 ATF_TC_BODY(send_recv, tc)
 635 {
 636         int sv[2];
 637         const int bufsize = 64;
 638         const char *data = "data";
 639         char recv_buf[bufsize];
 640         ssize_t datalen;
 641         ssize_t ssize, rsize;
 642
 643         /* setup the socket pair */
 644         do_socketpair(sv);
 645
 646         /* send and receive a small packet */
 647         datalen = strlen(data) + 1;     /* +1 for the null */
 648         ssize = send(sv[0], data, datalen, MSG_EOR);
 649         if (ssize < 0) {
 650                 perror("send");
 651                 atf_tc_fail("send returned < 0");
 652         }
 653         ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd",
 654             datalen, ssize);
 655
 656         rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL);
 657         ATF_CHECK_EQ(datalen, rsize);
 658         close(sv[0]);
 659         close(sv[1]);
 660 }
 661
 662 /* sendto(2) and recvfrom(2) a single short record
 663  * According to The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004
 664  * Edition, sendto(2) is exactly the same as send(2) on a connection-mode socket
 665  *
 666  * According to the same spec, not all protocols are required to provide the
 667  * source addres in recvfrom(2).
 668  */
 669 ATF_TC_WITHOUT_HEAD(sendto_recvfrom);
 670 ATF_TC_BODY(sendto_recvfrom, tc)
 671 {
 672 #ifdef TEST_SEQ_PACKET_SOURCE_ADDRESS
 673         const char* path;
 674 #endif
 675         struct sockaddr_storage from;
 676         int sv[2];
 677         const int bufsize = 64;
 678         const char *data = "data";
 679         char recv_buf[bufsize];
 680         ssize_t datalen;
 681         ssize_t ssize, rsize;
 682         socklen_t fromlen;
 683
 684         /* setup the socket pair */
 685 #ifdef TEST_SEQ_PACKET_SOURCE_ADDRESS
 686         path =
 687 #endif
 688                 mk_pair_of_sockets(sv);
 689
 690         /* send and receive a small packet */
 691         datalen = strlen(data) + 1;     /* +1 for the null */
 692         ssize = sendto(sv[0], data, datalen, MSG_EOR, NULL, 0);
 693         if (ssize < 0) {
 694                 perror("send");
 695                 atf_tc_fail("send returned < 0");
 696         }
 697         ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd",
 698             datalen, ssize);
 699
 700         fromlen = sizeof(from);
 701         rsize = recvfrom(sv[1], recv_buf, bufsize, MSG_WAITALL,
 702             (struct sockaddr*)&from, &fromlen);
 703         if (ssize < 0) {
 704                 perror("recvfrom");
 705                 atf_tc_fail("recvfrom returned < 0");
 706         }
 707         ATF_CHECK_EQ(datalen, rsize);
 708
 709 #ifdef TEST_SEQ_PACKET_SOURCE_ADDRESS
 710         /*
 711          * FreeBSD does not currently provide the source address for SEQ_PACKET
 712          * AF_UNIX sockets, and POSIX does not require it, so these two checks
 713          * are disabled.  If FreeBSD gains that feature in the future, then
 714          * these checks may be reenabled
 715          */
 716         ATF_CHECK_EQ(PF_LOCAL, from.ss_family);
 717         ATF_CHECK_STREQ(path, ((struct sockaddr_un*)&from)->sun_path);
 718 #endif
 719         close(sv[0]);
 720         close(sv[1]);
 721 }
 722
 723 /*
 724  * send(2) and recv(2) a single short record with sockets created the
 725  * traditional way, involving bind, listen, connect, and accept
 726  */
 727 ATF_TC_WITHOUT_HEAD(send_recv_with_connect);
 728 ATF_TC_BODY(send_recv_with_connect, tc)
 729 {
 730         int sv[2];
 731         const int bufsize = 64;
 732         const char *data = "data";
 733         char recv_buf[bufsize];
 734         ssize_t datalen;
 735         ssize_t ssize, rsize;
 736
 737         mk_pair_of_sockets(sv);
 738
 739         /* send and receive a small packet */
 740         datalen = strlen(data) + 1;     /* +1 for the null */
 741         ssize = send(sv[0], data, datalen, MSG_EOR);
 742         if (ssize < 0) {
 743                 perror("send");
 744                 atf_tc_fail("send returned < 0");
 745         }
 746         ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd",
 747             datalen, ssize);
 748
 749         rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL);
 750         ATF_CHECK_EQ(datalen, rsize);
 751         close(sv[0]);
 752         close(sv[1]);
 753 }
 754
 755 /* send(2) should fail on a shutdown socket */
 756 ATF_TC_WITHOUT_HEAD(shutdown_send);
 757 ATF_TC_BODY(shutdown_send, tc)
 758 {
 759         struct sockaddr_un sun;
 760         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
 761         const char *path = "sock";
 762         const char *data = "data";
 763         ssize_t datalen, ssize;
 764         int s, err, s2;
 765
 766         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 767         ATF_REQUIRE(s >= 0);
 768
 769         bzero(&sun, sizeof(sun));
 770         sun.sun_family = AF_LOCAL;
 771         sun.sun_len = sizeof(sun);
 772         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
 773         err = bind(s, (struct sockaddr *)&sun, sizeof(sun));
 774         err = listen(s, -1);
 775         ATF_CHECK_EQ(0, err);
 776
 777         /* Create the other socket */
 778         s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 779         ATF_REQUIRE(s2 >= 0);
 780         err = connect(s2, (struct sockaddr*)&sun, sizeof(sun));
 781         if (err != 0) {
 782                 perror("connect");
 783                 atf_tc_fail("connect(2) failed");
 784         }
 785
 786         ATF_CHECK_EQ(0, shutdown(s2, SHUT_RDWR));
 787         datalen = strlen(data) + 1;     /* +1 for the null */
 788         /* USE MSG_NOSIGNAL so we don't get SIGPIPE */
 789         ssize = send(s2, data, datalen, MSG_EOR | MSG_NOSIGNAL);
 790         ATF_CHECK_EQ(EPIPE, errno);
 791         ATF_CHECK_EQ(-1, ssize);
 792         close(s);
 793         close(s2);
 794 }
 795
 796 /* send(2) should cause SIGPIPE on a shutdown socket */
 797 ATF_TC_WITHOUT_HEAD(shutdown_send_sigpipe);
 798 ATF_TC_BODY(shutdown_send_sigpipe, tc)
 799 {
 800         struct sockaddr_un sun;
 801         /* ATF's isolation mechanisms will guarantee uniqueness of this file */
 802         const char *path = "sock";
 803         const char *data = "data";
 804         ssize_t datalen;
 805         int s, err, s2;
 806
 807         s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 808         ATF_REQUIRE(s >= 0);
 809
 810         bzero(&sun, sizeof(sun));
 811         sun.sun_family = AF_LOCAL;
 812         sun.sun_len = sizeof(sun);
 813         strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
 814         err = bind(s, (struct sockaddr *)&sun, sizeof(sun));
 815         err = listen(s, -1);
 816         ATF_CHECK_EQ(0, err);
 817
 818         /* Create the other socket */
 819         s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
 820         ATF_REQUIRE(s2 >= 0);
 821         err = connect(s2, (struct sockaddr*)&sun, sizeof(sun));
 822         if (err != 0) {
 823                 perror("connect");
 824                 atf_tc_fail("connect(2) failed");
 825         }
 826
 827         ATF_CHECK_EQ(0, shutdown(s2, SHUT_RDWR));
 828         ATF_REQUIRE(SIG_ERR != signal(SIGPIPE, shutdown_send_sigpipe_handler));
 829         datalen = strlen(data) + 1;     /* +1 for the null */
 830         (void)send(s2, data, datalen, MSG_EOR);
 831         ATF_CHECK_EQ(1, got_sigpipe);
 832         close(s);
 833         close(s2);
 834 }
 835
 836 /* nonblocking send(2) and recv(2) a single short record */
 837 ATF_TC_WITHOUT_HEAD(send_recv_nonblocking);
 838 ATF_TC_BODY(send_recv_nonblocking, tc)
 839 {
 840         int sv[2];
 841         const int bufsize = 64;
 842         const char *data = "data";
 843         char recv_buf[bufsize];
 844         ssize_t datalen;
 845         ssize_t ssize, rsize;
 846
 847         /* setup the socket pair */
 848         do_socketpair_nonblocking(sv);
 849
 850         /* Verify that there is nothing to receive */
 851         rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL);
 852         ATF_CHECK_EQ(EAGAIN, errno);
 853         ATF_CHECK_EQ(-1, rsize);
 854
 855         /* send and receive a small packet */
 856         datalen = strlen(data) + 1;     /* +1 for the null */
 857         ssize = send(sv[0], data, datalen, MSG_EOR);
 858         if (ssize < 0) {
 859                 perror("send");
 860                 atf_tc_fail("send returned < 0");
 861         }
 862         ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd",
 863             datalen, ssize);
 864
 865         rsize = recv(sv[1], recv_buf, bufsize, MSG_WAITALL);
 866         ATF_CHECK_EQ(datalen, rsize);
 867         close(sv[0]);
 868         close(sv[1]);
 869 }
 870
 871 /*
 872  * We should get EMSGSIZE if we try to send a message larger than the socket
 873  * buffer, with blocking sockets
 874  */
 875 ATF_TC_WITHOUT_HEAD(emsgsize);
 876 ATF_TC_BODY(emsgsize, tc)
 877 {
 878         int sv[2];
 879         const int sndbufsize = 8192;
 880         const int rcvbufsize = 8192;
 881         const size_t pktsize = (sndbufsize + rcvbufsize) * 2;
 882         char sndbuf[pktsize];
 883         ssize_t ssize;
 884
 885         /* setup the socket pair */
 886         do_socketpair(sv);
 887         /* Setup the buffers */
 888         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 889             sizeof(sndbufsize)));
 890         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 891             sizeof(rcvbufsize)));
 892
 893         ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 894         ATF_CHECK_EQ(EMSGSIZE, errno);
 895         ATF_CHECK_EQ(-1, ssize);
 896         close(sv[0]);
 897         close(sv[1]);
 898 }
 899
 900 /*
 901  * We should get EMSGSIZE if we try to send a message larger than the socket
 902  * buffer, with nonblocking sockets
 903  */
 904 ATF_TC_WITHOUT_HEAD(emsgsize_nonblocking);
 905 ATF_TC_BODY(emsgsize_nonblocking, tc)
 906 {
 907         int sv[2];
 908         const int sndbufsize = 8192;
 909         const int rcvbufsize = 8192;
 910         const size_t pktsize = (sndbufsize + rcvbufsize) * 2;
 911         char sndbuf[pktsize];
 912         ssize_t ssize;
 913
 914         /* setup the socket pair */
 915         do_socketpair_nonblocking(sv);
 916         /* Setup the buffers */
 917         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 918             sizeof(sndbufsize)));
 919         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 920             sizeof(rcvbufsize)));
 921
 922         ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 923         ATF_CHECK_EQ(EMSGSIZE, errno);
 924         ATF_CHECK_EQ(-1, ssize);
 925         close(sv[0]);
 926         close(sv[1]);
 927 }
 928
 929
 930 /*
 931  * We should get EAGAIN if we try to send a message larger than the socket
 932  * buffer, with nonblocking sockets.  Test with several different sockbuf sizes
 933  */
 934 ATF_TC_WITHOUT_HEAD(eagain_8k_8k);
 935 ATF_TC_BODY(eagain_8k_8k, tc)
 936 {
 937         test_eagain(8192, 8192);
 938 }
 939 ATF_TC_WITHOUT_HEAD(eagain_8k_128k);
 940 ATF_TC_BODY(eagain_8k_128k, tc)
 941 {
 942         test_eagain(8192, 131072);
 943 }
 944 ATF_TC_WITHOUT_HEAD(eagain_128k_8k);
 945 ATF_TC_BODY(eagain_128k_8k, tc)
 946 {
 947         test_eagain(131072, 8192);
 948 }
 949 ATF_TC_WITHOUT_HEAD(eagain_128k_128k);
 950 ATF_TC_BODY(eagain_128k_128k, tc)
 951 {
 952         test_eagain(131072, 131072);
 953 }
 954
 955
 956 /*
 957  * nonblocking send(2) and recv(2) of several records, which should collectively
 958  * fill up the send buffer but not the receive buffer
 959  */
 960 ATF_TC_WITHOUT_HEAD(rcvbuf_oversized);
 961 ATF_TC_BODY(rcvbuf_oversized, tc)
 962 {
 963         int i;
 964         int sv[2];
 965         const ssize_t pktsize = 1024;
 966         const int sndbufsize = 8192;
 967         const int rcvbufsize = 131072;
 968         const size_t geometric_mean_bufsize = 32768;
 969         const int numpkts = geometric_mean_bufsize / pktsize;
 970         char sndbuf[pktsize];
 971         char recv_buf[pktsize];
 972         ssize_t ssize, rsize;
 973
 974         /* setup the socket pair */
 975         do_socketpair_nonblocking(sv);
 976         ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,
 977             sizeof(sndbufsize)));
 978         ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
 979             sizeof(rcvbufsize)));
 980
 981         /*
 982          * Send and receive packets that are collectively greater than the send
 983          * buffer, but less than the receive buffer
 984          */
 985         for (i=0; i < numpkts; i++) {
 986                 /* Fill the buffer */
 987                 memset(sndbuf, i, pktsize);
 988
 989                 /* send the packet */
 990                 ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);
 991                 if (ssize < 0) {
 992                         perror("send");
 993                         atf_tc_fail("send returned < 0");
 994                 }
 995                 ATF_CHECK_EQ_MSG(pktsize, ssize,
 996                     "expected %zd=send(...) but got %zd", pktsize, ssize);
 997
 998                 /* Receive it */
 999
1000                 rsize = recv(sv[1], recv_buf, pktsize, MSG_WAITALL);
1001                 if (rsize < 0) {
1002                         perror("recv");
1003                         atf_tc_fail("recv returned < 0");
1004                 }
1005                 ATF_CHECK_EQ_MSG(pktsize, rsize,
1006                     "expected %zd=send(...) but got %zd", pktsize, rsize);
1007
1008                 /* Verify the contents */
1009                 ATF_CHECK_EQ_MSG(0, memcmp(sndbuf, recv_buf, pktsize),
1010                     "Received data miscompare");
1011         }
1012
1013         /* Trying to receive again should return EAGAIN */
1014         rsize = recv(sv[1], recv_buf, pktsize, MSG_WAITALL);
1015         ATF_CHECK_EQ(EAGAIN, errno);
1016         ATF_CHECK_EQ(-1, rsize);
1017         close(sv[0]);
1018         close(sv[1]);
1019 }
1020
1021 /*
1022  * Simulate the behavior of a blocking pipe.  The sender will send until his
1023  * buffer fills up, then we'll simulate a scheduler switch that will allow the
1024  * receiver to read until his buffer empties.  Repeat the process until the
1025  * transfer is complete.
1026  * Repeat the test with multiple send and receive buffer sizes
1027  */
1028 ATF_TC_WITHOUT_HEAD(pipe_simulator_8k_8k);
1029 ATF_TC_BODY(pipe_simulator_8k_8k, tc)
1030 {
1031         test_pipe_simulator(8192, 8192);
1032 }
1033
1034 ATF_TC_WITHOUT_HEAD(pipe_simulator_8k_128k);
1035 ATF_TC_BODY(pipe_simulator_8k_128k, tc)
1036 {
1037         test_pipe_simulator(8192, 131072);
1038 }
1039
1040 ATF_TC_WITHOUT_HEAD(pipe_simulator_128k_8k);
1041 ATF_TC_BODY(pipe_simulator_128k_8k, tc)
1042 {
1043         test_pipe_simulator(131072, 8192);
1044 }
1045
1046 ATF_TC_WITHOUT_HEAD(pipe_simulator_128k_128k);
1047 ATF_TC_BODY(pipe_simulator_128k_128k, tc)
1048 {
1049         test_pipe_simulator(131072, 131072);
1050 }
1051
1052 /*
1053  * Test blocking I/O by passing data between two threads.  The total amount of
1054  * data will be >> buffer size to force blocking.  Repeat the test with multiple
1055  * send and receive buffer sizes
1056  */
1057 ATF_TC_WITHOUT_HEAD(pipe_8k_8k);
1058 ATF_TC_BODY(pipe_8k_8k, tc)
1059 {
1060         test_pipe(8192, 8192);
1061 }
1062
1063 ATF_TC_WITHOUT_HEAD(pipe_8k_128k);
1064 ATF_TC_BODY(pipe_8k_128k, tc)
1065 {
1066         test_pipe(8192, 131072);
1067 }
1068
1069 ATF_TC_WITHOUT_HEAD(pipe_128k_8k);
1070 ATF_TC_BODY(pipe_128k_8k, tc)
1071 {
1072         test_pipe(131072, 8192);
1073 }
1074
1075 ATF_TC_WITHOUT_HEAD(pipe_128k_128k);
1076 ATF_TC_BODY(pipe_128k_128k, tc)
1077 {
1078         test_pipe(131072, 131072);
1079 }
1080
1081
1082 /*
1083  * Test single-packet I/O with and without blocking, with symmetric buffers of
1084  * various sizes
1085  */
1086 ATF_TC_WITHOUT_HEAD(sendrecv_8k);
1087 ATF_TC_BODY(sendrecv_8k, tc)
1088 {
1089         test_sendrecv_symmetric_buffers(8 * 1024, true);
1090 }
1091 ATF_TC_WITHOUT_HEAD(sendrecv_16k);
1092 ATF_TC_BODY(sendrecv_16k, tc)
1093 {
1094         test_sendrecv_symmetric_buffers(16 * 1024, true);
1095 }
1096 ATF_TC_WITHOUT_HEAD(sendrecv_32k);
1097 ATF_TC_BODY(sendrecv_32k, tc)
1098 {
1099         test_sendrecv_symmetric_buffers(32 * 1024, true);
1100 }
1101 ATF_TC_WITHOUT_HEAD(sendrecv_64k);
1102 ATF_TC_BODY(sendrecv_64k, tc)
1103 {
1104         test_sendrecv_symmetric_buffers(64 * 1024, true);
1105 }
1106 ATF_TC_WITHOUT_HEAD(sendrecv_128k);
1107 ATF_TC_BODY(sendrecv_128k, tc)
1108 {
1109         test_sendrecv_symmetric_buffers(128 * 1024, true);
1110 }
1111 ATF_TC_WITHOUT_HEAD(sendrecv_8k_nonblocking);
1112 ATF_TC_BODY(sendrecv_8k_nonblocking, tc)
1113 {
1114         test_sendrecv_symmetric_buffers(8 * 1024, false);
1115 }
1116 ATF_TC_WITHOUT_HEAD(sendrecv_16k_nonblocking);
1117 ATF_TC_BODY(sendrecv_16k_nonblocking, tc)
1118 {
1119         test_sendrecv_symmetric_buffers(16 * 1024, false);
1120 }
1121 ATF_TC_WITHOUT_HEAD(sendrecv_32k_nonblocking);
1122 ATF_TC_BODY(sendrecv_32k_nonblocking, tc)
1123 {
1124         test_sendrecv_symmetric_buffers(32 * 1024, false);
1125 }
1126 ATF_TC_WITHOUT_HEAD(sendrecv_64k_nonblocking);
1127 ATF_TC_BODY(sendrecv_64k_nonblocking, tc)
1128 {
1129         test_sendrecv_symmetric_buffers(64 * 1024, false);
1130 }
1131 ATF_TC_WITHOUT_HEAD(sendrecv_128k_nonblocking);
1132 ATF_TC_BODY(sendrecv_128k_nonblocking, tc)
1133 {
1134         test_sendrecv_symmetric_buffers(128 * 1024, false);
1135 }
1136
1137
1138 /*
1139  * Main.
1140  */
1141
1142 ATF_TP_ADD_TCS(tp)
1143 {
1144         /* Basic creation and connection tests */
1145         ATF_TP_ADD_TC(tp, create_socket);
1146         ATF_TP_ADD_TC(tp, create_socketpair);
1147         ATF_TP_ADD_TC(tp, listen_unbound);
1148         ATF_TP_ADD_TC(tp, bind);
1149         ATF_TP_ADD_TC(tp, listen_bound);
1150         ATF_TP_ADD_TC(tp, connect);
1151         ATF_TP_ADD_TC(tp, accept);
1152         ATF_TP_ADD_TC(tp, fcntl_nonblock);
1153         ATF_TP_ADD_TC(tp, resize_buffers);
1154         ATF_TP_ADD_TC(tp, resize_connected_buffers);
1155
1156         /* Unthreaded I/O tests */
1157         ATF_TP_ADD_TC(tp, send_recv);
1158         ATF_TP_ADD_TC(tp, send_recv_nonblocking);
1159         ATF_TP_ADD_TC(tp, send_recv_with_connect);
1160         ATF_TP_ADD_TC(tp, sendto_recvfrom);
1161         ATF_TP_ADD_TC(tp, shutdown_send);
1162         ATF_TP_ADD_TC(tp, shutdown_send_sigpipe);
1163         ATF_TP_ADD_TC(tp, emsgsize);
1164         ATF_TP_ADD_TC(tp, emsgsize_nonblocking);
1165         ATF_TP_ADD_TC(tp, eagain_8k_8k);
1166         ATF_TP_ADD_TC(tp, eagain_8k_128k);
1167         ATF_TP_ADD_TC(tp, eagain_128k_8k);
1168         ATF_TP_ADD_TC(tp, eagain_128k_128k);
1169         ATF_TP_ADD_TC(tp, sendrecv_8k);
1170         ATF_TP_ADD_TC(tp, sendrecv_16k);
1171         ATF_TP_ADD_TC(tp, sendrecv_32k);
1172         ATF_TP_ADD_TC(tp, sendrecv_64k);
1173         ATF_TP_ADD_TC(tp, sendrecv_128k);
1174         ATF_TP_ADD_TC(tp, sendrecv_8k_nonblocking);
1175         ATF_TP_ADD_TC(tp, sendrecv_16k_nonblocking);
1176         ATF_TP_ADD_TC(tp, sendrecv_32k_nonblocking);
1177         ATF_TP_ADD_TC(tp, sendrecv_64k_nonblocking);
1178         ATF_TP_ADD_TC(tp, sendrecv_128k_nonblocking);
1179         ATF_TP_ADD_TC(tp, rcvbuf_oversized);
1180         ATF_TP_ADD_TC(tp, pipe_simulator_8k_8k);
1181         ATF_TP_ADD_TC(tp, pipe_simulator_8k_128k);
1182         ATF_TP_ADD_TC(tp, pipe_simulator_128k_8k);
1183         ATF_TP_ADD_TC(tp, pipe_simulator_128k_128k);
1184
1185         /* Threaded I/O tests with blocking sockets */
1186         ATF_TP_ADD_TC(tp, pipe_8k_8k);
1187         ATF_TP_ADD_TC(tp, pipe_8k_128k);
1188         ATF_TP_ADD_TC(tp, pipe_128k_8k);
1189         ATF_TP_ADD_TC(tp, pipe_128k_128k);
1190
1191         return atf_no_error();
1192 }