src/lwp/test/selclient.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /* selclient.c tests the IOMGR_Select interface. Specifically it verifies
  11  * that the read/write/exception lists work correctly with file descriptors
  12  * larger than 31. Generally, the calls to IOMGR_Select pass in all the
  13  * read, write and exception fd_sets. When handling is complete, the file
  14  * descriptor is cleared from the set. Then if fd_set is checked to make sure
  15  * there are no other bits set. The fd_sets which should have had nothing set
  16  * are also checked.
  17  *
  18  * The client can send one of the following:
  19  * -end - shoots the selserver.
  20  * -delay n - The selserver thread handling this request should sleep for
  21  *            n seconds before accepting data. Used in conjuction with -write
  22  *            so that the write STREAM can fill. This tests the IOMGR_Select
  23  *            write fd_sets.
  24  * -write n - writes n bytes to the selserver. If -delay is not set, a default
  25  *            of 5 seconds is used.
  26  * -soob - Send an out-of-band message to selserver. Tests the exception
  27  *            fd_set.
  28  */
  29
  30 /* Typical test scanario:
  31  * selclient -soob : used to test exception fd's on selserver.
  32  * selclient -delay 20 -write 150000 : used to test read/write fd's.
  33  * Adjust delay to 40 seconds if running loopback. Times and sizes derived
  34  * on IRIX 6.2 and 6.4.
  35  */
  36
  37 #include <afsconfig.h>
  38 #include <afs/param.h>
  39
  40
  41 #include <unistd.h>
  42 #include <stdio.h>
  43 #include <stdarg.h>
  44 #include <errno.h>
  45 #include <sys/select.h>
  46 #include <sys/types.h>
  47 #include <sys/socket.h>
  48 #include <string.h>
  49 #include <sys/time.h>
  50 #include <netinet/in.h>
  51 #include <netdb.h>
  52 #include <signal.h>
  53 #include <sys/ioctl.h>
  54 #include <assert.h>
  55 #include <time.h>
  56
  57
  58 #include "lwp.h"
  59 #include "seltest.h"
  60
  61 /* Put this in lwp.h? */
  62 extern int IOMGR_Select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
  63
  64
  65 void sendTest(int, int, int, int);
  66 void sendEnd(int);
  67
  68 int nSigIO = 0;
  69 void
  70 sigIO()
  71 {
  72     nSigIO++;
  73 }
  74
  75 char *program;
  76
  77
  78 Usage()
  79 {
  80     printf
  81         ("Usage: selclient [-fd n] [-oob] [-soob] [-delay n] [-end] [-write n] host port\n");
  82     printf("\t-fd n\tUse file descriptor n for socket.\n");
  83     printf("\t-oob\tRequest a MSG_OOB from server.\n");
  84     printf("\t-soob\tSend a MSG_OOB to server.\n");
  85     printf("\t-delay n\tAsk server to delay n seconds for my writes.\n");
  86     printf("\t-end\tAsk server to terminate.\n");
  87     printf("\t-write\tWrite n bytes to server, verify reply.\n");
  88     exit(1);
  89 }
  90
  91 main(int ac, char **av)
  92 {
  93     int i;
  94     int on = 1;
  95     char *hostname = 0;
  96     struct hostent *hostent;
  97     int host;                   /* net order. */
  98     short port = -1;            /* host order. */
  99     int setFD = 0;
 100     int sockFD;
 101     struct sockaddr_in saddr;
 102     int reqOOB = 0;
 103     int putOOB = 0;
 104     int delay = 5;
 105     int doEnd = 0;
 106     int doWrite = 0;
 107     int writeSize = 0;
 108
 109     program = av[0];
 110
 111     signal(SIGIO, sigIO);
 112
 113
 114     for (i = 1; i < ac; i++) {
 115         if (!strcmp("-fd", av[i])) {
 116             if (++i >= ac) {
 117                 printf("Missing number for -fd option.\n");
 118                 Usage();
 119             }
 120             setFD = atoi(av[i]);
 121             if (setFD <= 2) {
 122                 printf("%s: %d: file descriptor must be at least 3.\n",
 123                        program, setFD);
 124                 Usage();
 125             }
 126         } else if (!strcmp("-end", av[i])) {
 127             doEnd = 1;
 128         } else if (!strcmp("-delay", av[i])) {
 129             if (++i >= ac) {
 130                 printf("%s: Missing time for -delay option.\n", program);
 131                 Usage();
 132             }
 133             delay = atoi(av[i]);
 134             if (delay < 0) {
 135                 printf("%s: %s: delay must be at least 0 seconds.\n", program,
 136                        av[i]);
 137                 Usage();
 138             }
 139         } else if (!strcmp("-write", av[i])) {
 140             doWrite = 1;
 141             if (++i >= ac) {
 142                 printf("%s: Missing size for -write option.\n", program);
 143                 Usage();
 144             }
 145             writeSize = atoi(av[i]);
 146             if (writeSize < 1) {
 147                 printf("%s: %s: Write size must be at least 1 byte.\n",
 148                        program, av[i]);
 149                 Usage();
 150             }
 151         } else if (!strcmp("-oob", av[i])) {
 152             reqOOB = 1;
 153         } else if (!strcmp("-soob", av[i])) {
 154             putOOB = 1;
 155         } else {
 156             if (!hostname) {
 157                 hostname = av[i];
 158             } else if (port == -1) {
 159                 port = atoi(av[i]);
 160                 if (port <= 0) {
 161                     printf("%s: %s: port must be at least 1\n", program,
 162                            av[i]);
 163                     Usage();
 164                 }
 165             } else {
 166                 printf("%s: %s: Unknown argument.\n", program, av[i]);
 167             }
 168         }
 169     }
 170
 171     if (!hostname) {
 172         printf("%s: Missing hostname and port.\n", program);
 173         Usage();
 174     }
 175     if (port == -1) {
 176         printf("%s: Missing port.\n", program);
 177         Usage();
 178     }
 179
 180     if (writeSize == 0 && doEnd == 0 && putOOB == 0) {
 181         printf("%s: Missing action.\n", program);
 182         Usage();
 183     }
 184
 185     if (!setFD) {
 186         setFD = 31;
 187         printf("%s: Using default socket of %d.\n", program, setFD);
 188     }
 189
 190     if (!(hostent = gethostbyname(hostname))) {
 191         printf("%s: Failed to find host entry for %s.\n", program, hostname);
 192         exit(1);
 193     }
 194
 195     memcpy((void *)&host, (const void *)hostent->h_addr, sizeof(host));
 196
 197     OpenFDs(setFD);
 198
 199     /* Connect to server. */
 200     sockFD = socket(AF_INET, SOCK_STREAM, 0);
 201     if (sockFD < 0) {
 202         Die(0, "socket");
 203     }
 204     printf("%s: Using socket at file descriptor %d.\n", program, sockFD);
 205
 206     memset((void *)&saddr, 0, sizeof(saddr));
 207     saddr.sin_family = AF_INET;
 208     saddr.sin_addr.s_addr = host;       /* already in network byte order. */
 209     saddr.sin_port = htons(port);
 210
 211     if (connect(sockFD, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
 212         assert(0);
 213     }
 214
 215
 216     if (doEnd) {
 217         sendEnd(sockFD);
 218     } else if (putOOB) {
 219         Log("Will send OOB in 2 seconds.\n");
 220         sleep(2);
 221         sendOOB(sockFD);
 222         Log("Sent OOB, sleeping for 5 seconds.\n");
 223         sleep(5);
 224         Log("Sent OOB, exiting.\n");
 225     } else {
 226         IOMGR_Initialize();
 227         sendTest(sockFD, delay, reqOOB, writeSize);
 228     }
 229     close(sockFD);
 230 }
 231
 232 /* sendTest
 233  */
 234 int writeIndex;
 235 void
 236 sendTest(int sockFD, int delay, int reqOOB, int size)
 237 {
 238     char *buf, *bufTest;
 239     fd_set *rfds, *wfds, *efds;
 240     int i, j;
 241     int nbytes, code;
 242     selcmd_t selCmd;
 243     time_t stime, etime;
 244
 245     buf = malloc(size);
 246     assert(buf);
 247     bufTest = malloc(size);
 248     assert(bufTest);
 249
 250     for (j = i = 0; i < size; i++, j++) {
 251         if (j == END_DATA)
 252             j++;
 253         if (j > 255)
 254             j = 0;
 255         buf[i] = (char)j;
 256     }
 257
 258     selCmd.sc_cmd = SC_WRITE;
 259     selCmd.sc_info = size;
 260     selCmd.sc_delay = delay;
 261     selCmd.sc_flags = SC_WAIT_ONLY;
 262
 263     nbytes = write(sockFD, (char *)&selCmd, sizeof(selCmd));
 264     assert(nbytes == sizeof(selCmd));
 265
 266     Log("Starting to write %d bytes.\n", size);
 267     if (!delay) {
 268         nbytes = write(sockFD, buf, size);
 269         assert(nbytes == size);
 270     } else {
 271         rfds = IOMGR_AllocFDSet();
 272         wfds = IOMGR_AllocFDSet();
 273         efds = IOMGR_AllocFDSet();
 274         if (!rfds || !wfds || !efds) {
 275             printf("%s: Could not allocate all fd_sets.\n", program);
 276             exit(1);
 277         }
 278
 279         for (writeIndex = i = 0; i < size; writeIndex++, i++) {
 280             FD_ZERO(rfds);
 281             FD_ZERO(wfds);
 282             FD_ZERO(efds);
 283             FD_SET(sockFD, wfds);
 284             FD_SET(sockFD, efds);
 285             (void)time(&stime);
 286             code =
 287                 IOMGR_Select(sockFD + 1, rfds, wfds, efds,
 288                              NULL);
 289             assert(code > 0);
 290
 291             if (FD_ISSET(sockFD, wfds)) {
 292                 (void)time(&etime);
 293                 if (etime - stime > 1) {
 294                     Log("Waited %d seconds to write at offset %d.\n",
 295                         etime - stime, i);
 296                 }
 297                 stime = etime;
 298                 nbytes = write(sockFD, &buf[i], 1);
 299                 (void)time(&etime);
 300                 if (etime - stime > 1) {
 301                     Log("Waited %d seconds IN write.\n", etime - stime);
 302                 }
 303                 assert(nbytes == 1);
 304                 FD_CLR(sockFD, wfds);
 305             }
 306             assertNullFDSet(0, rfds);
 307             assertNullFDSet(0, wfds);
 308             assertNullFDSet(0, efds);
 309         }
 310     }
 311
 312     Log("Wrote %d bytes.\n", size);
 313     i = 0;
 314     while (i < size) {
 315         nbytes = read(sockFD, &bufTest[i], size);
 316         i += nbytes;
 317     }
 318     Log("Read %d bytes.\n", size);
 319
 320     assert(memcmp(buf, bufTest, size) == 0);
 321     Log("Compared %d bytes.\n", size);
 322 }
 323
 324 void
 325 sendEnd(int fd)
 326 {
 327     selcmd_t sc;
 328
 329     sc.sc_cmd = SC_END;
 330
 331     if (write(fd, (char *)&sc, sizeof(sc)) != sizeof(sc)) {
 332         Die(1, "(sendEnd) write failed: ");
 333     }
 334 }