The Tcpdump Group git mirrors - libpcap/blob - testprogs/selpolltest.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  */
  21
  22 #include "varattrs.h"
  23
  24 #ifndef lint
  25 static const char copyright[] _U_ =
  26     "@(#) Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000\n\
  27 The Regents of the University of California.  All rights reserved.\n";
  28 #endif
  29
  30 /*
  31  * Tests how select() and poll() behave on the selectable file descriptor
  32  * for a pcap_t.
  33  *
  34  * This would be significantly different on Windows, as it'd test
  35  * how WaitForMultipleObjects() would work on the event handle for a
  36  * pcap_t.
  37  */
  38 #include <pcap.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <stdarg.h>
  43 #include <unistd.h>
  44 #include <errno.h>
  45 #include <sys/types.h>
  46 #ifdef HAVE_SYS_SELECT_H
  47 #include <sys/select.h>
  48 #else
  49 #include <sys/time.h>   /* older UN*Xes */
  50 #endif
  51 #include <poll.h>
  52
  53 #include "pcap/funcattrs.h"
  54
  55 static char *program_name;
  56
  57 /* Forwards */
  58 static void countme(u_char *, const struct pcap_pkthdr *, const u_char *);
  59 static void PCAP_NORETURN usage(void);
  60 static void PCAP_NORETURN error(const char *, ...) PCAP_PRINTFLIKE(1, 2);
  61 static void warning(const char *, ...) PCAP_PRINTFLIKE(1, 2);
  62 static char *copy_argv(char **);
  63
  64 static pcap_t *pd;
  65
  66 int
  67 main(int argc, char **argv)
  68 {
  69         register int op;
  70         bpf_u_int32 localnet, netmask;
  71         register char *cp, *cmdbuf, *device;
  72         int doselect, dopoll, dotimeout, dononblock, quiet;
  73         const char *mechanism;
  74         struct bpf_program fcode;
  75         char ebuf[PCAP_ERRBUF_SIZE];
  76         pcap_if_t *devlist;
  77         int selectable_fd = -1;
  78         const struct timeval *required_timeout;
  79         int status;
  80         int packet_count;
  81
  82         device = NULL;
  83         doselect = 0;
  84         dopoll = 0;
  85         mechanism = NULL;
  86         dotimeout = 0;
  87         dononblock = 0;
  88         quiet = 0;
  89         if ((cp = strrchr(argv[0], '/')) != NULL)
  90                 program_name = cp + 1;
  91         else
  92                 program_name = argv[0];
  93
  94         opterr = 0;
  95         while ((op = getopt(argc, argv, "i:sptnq")) != -1) {
  96                 switch (op) {
  97
  98                 case 'i':
  99                         device = optarg;
 100                         break;
 101
 102                 case 's':
 103                         doselect = 1;
 104                         mechanism = "select() and pcap_dispatch()";
 105                         break;
 106
 107                 case 'p':
 108                         dopoll = 1;
 109                         mechanism = "poll() and pcap_dispatch()";
 110                         break;
 111
 112                 case 't':
 113                         dotimeout = 1;
 114                         break;
 115
 116                 case 'n':
 117                         dononblock = 1;
 118                         break;
 119
 120                 case 'q':
 121                         quiet = 1;
 122                         break;
 123
 124                 default:
 125                         usage();
 126                         /* NOTREACHED */
 127                 }
 128         }
 129
 130         if (doselect && dopoll) {
 131                 fprintf(stderr, "selpolltest: choose select (-s) or poll (-p), but not both\n");
 132                 return 1;
 133         }
 134         if (dotimeout && !doselect && !dopoll) {
 135                 fprintf(stderr, "selpolltest: timeout (-t) requires select (-s) or poll (-p)\n");
 136                 return 1;
 137         }
 138         if (device == NULL) {
 139                 if (pcap_findalldevs(&devlist, ebuf) == -1)
 140                         error("%s", ebuf);
 141                 if (devlist == NULL)
 142                         error("no interfaces available for capture");
 143                 device = strdup(devlist->name);
 144                 pcap_freealldevs(devlist);
 145         }
 146         *ebuf = '\0';
 147         pd = pcap_open_live(device, 65535, 0, 1000, ebuf);
 148         if (pd == NULL)
 149                 error("%s", ebuf);
 150         else if (*ebuf)
 151                 warning("%s", ebuf);
 152         if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {
 153                 localnet = 0;
 154                 netmask = 0;
 155                 warning("%s", ebuf);
 156         }
 157         cmdbuf = copy_argv(&argv[optind]);
 158
 159         if (pcap_compile(pd, &fcode, cmdbuf, 1, netmask) < 0)
 160                 error("%s", pcap_geterr(pd));
 161         if (pcap_setfilter(pd, &fcode) < 0)
 162                 error("%s", pcap_geterr(pd));
 163
 164         if (doselect || dopoll) {
 165                 /*
 166                  * We need either an FD on which to do select()/poll()
 167                  * or, if there isn't one, a timeout to use in select()/
 168                  * poll().
 169                  */
 170                 selectable_fd = pcap_get_selectable_fd(pd);
 171                 if (selectable_fd == -1) {
 172                         printf("Listening on %s, using %s, with a timeout\n",
 173                             device, mechanism);
 174                         required_timeout = pcap_get_required_select_timeout(pd);
 175                         if (required_timeout == NULL)
 176                                 error("select()/poll() isn't supported on %s, even with a timeout",
 177                                     device);
 178
 179                         /*
 180                          * As we won't be notified by select() or poll()
 181                          * that a read can be done, we'll have to periodically
 182                          * try reading from the device every time the required
 183                          * timeout expires, and we don't want those attempts
 184                          * to block if nothing has arrived in that interval,
 185                          * so we want to force non-blocking mode.
 186                          */
 187                         dononblock = 1;
 188                 } else {
 189                         printf("Listening on %s, using %s\n", device,
 190                             mechanism);
 191                         required_timeout = NULL;
 192                 }
 193         } else
 194                 printf("Listening on %s, using pcap_dispatch()\n", device);
 195
 196         if (dononblock) {
 197                 if (pcap_setnonblock(pd, 1, ebuf) == -1)
 198                         error("pcap_setnonblock failed: %s", ebuf);
 199         }
 200         if (doselect) {
 201                 for (;;) {
 202                         fd_set setread, setexcept;
 203                         struct timeval seltimeout;
 204                         struct timeval *timeoutp;
 205
 206                         FD_ZERO(&setread);
 207                         if (selectable_fd != -1) {
 208                                 FD_SET(selectable_fd, &setread);
 209                                 FD_ZERO(&setexcept);
 210                                 FD_SET(selectable_fd, &setexcept);
 211                         }
 212                         required_timeout = pcap_get_required_select_timeout(pd);
 213                         if (dotimeout) {
 214                                 seltimeout.tv_sec = 0;
 215                                 if (required_timeout != NULL &&
 216                                     required_timeout->tv_usec < 1000)
 217                                         seltimeout.tv_usec = required_timeout->tv_usec;
 218                                 else
 219                                         seltimeout.tv_usec = 1000;
 220                                 timeoutp = &seltimeout;
 221                         } else if (required_timeout != NULL) {
 222                                 seltimeout = *required_timeout;
 223                                 timeoutp = &seltimeout;
 224                         } else {
 225                                 timeoutp = NULL;
 226                         }
 227                         status = select((selectable_fd == -1) ?
 228                             0 : selectable_fd + 1, &setread, NULL, &setexcept,
 229                             timeoutp);
 230                         if (status == -1) {
 231                                 printf("Select returns error (%s)\n",
 232                                     strerror(errno));
 233                         } else {
 234                                 if (!quiet) {
 235                                         if (status == 0)
 236                                                 printf("Select timed out: ");
 237                                         else{
 238                                                 printf("Select returned a descriptor: ");
 239                                                 if (FD_ISSET(selectable_fd, &setread))
 240                                                         printf("readable, ");
 241                                                 else
 242                                                         printf("not readable, ");
 243                                                 if (FD_ISSET(selectable_fd, &setexcept))
 244                                                         printf("exceptional condition\n");
 245                                                 else
 246                                                         printf("no exceptional condition\n");
 247                                         }
 248                                 }
 249                                 packet_count = 0;
 250                                 status = pcap_dispatch(pd, -1, countme,
 251                                     (u_char *)&packet_count);
 252                                 if (status < 0)
 253                                         break;
 254                                 /*
 255                                  * Don't report this if we're using a
 256                                  * required timeout and we got no packets,
 257                                  * because that could be a very short timeout,
 258                                  * and we don't want to spam the user with
 259                                  * a ton of "no packets" reports.
 260                                  */
 261                                 if (status != 0 || packet_count != 0 ||
 262                                     required_timeout != NULL) {
 263                                         printf("%d packets seen, %d packets counted after select returns\n",
 264                                             status, packet_count);
 265                                 }
 266                         }
 267                 }
 268         } else if (dopoll) {
 269                 for (;;) {
 270                         struct pollfd fd;
 271                         int polltimeout;
 272
 273                         fd.fd = selectable_fd;
 274                         fd.events = POLLIN;
 275                         required_timeout = pcap_get_required_select_timeout(pd);
 276                         if (dotimeout)
 277                                 polltimeout = 1;
 278                         else if (required_timeout != NULL &&
 279                             required_timeout->tv_usec >= 1000)
 280                                 polltimeout = (int)(required_timeout->tv_usec/1000);
 281                         else
 282                                 polltimeout = -1;
 283                         status = poll(&fd, (selectable_fd == -1) ? 0 : 1, polltimeout);
 284                         if (status == -1) {
 285                                 printf("Poll returns error (%s)\n",
 286                                     strerror(errno));
 287                         } else {
 288                                 if (!quiet) {
 289                                         if (status == 0)
 290                                                 printf("Poll timed out\n");
 291                                         else {
 292                                                 printf("Poll returned a descriptor: ");
 293                                                 if (fd.revents & POLLIN)
 294                                                         printf("readable, ");
 295                                                 else
 296                                                         printf("not readable, ");
 297                                                 if (fd.revents & POLLERR)
 298                                                         printf("exceptional condition, ");
 299                                                 else
 300                                                         printf("no exceptional condition, ");
 301                                                 if (fd.revents & POLLHUP)
 302                                                         printf("disconnect, ");
 303                                                 else
 304                                                         printf("no disconnect, ");
 305                                                 if (fd.revents & POLLNVAL)
 306                                                         printf("invalid\n");
 307                                                 else
 308                                                         printf("not invalid\n");
 309                                         }
 310                                 }
 311                                 packet_count = 0;
 312                                 status = pcap_dispatch(pd, -1, countme,
 313                                     (u_char *)&packet_count);
 314                                 if (status < 0)
 315                                         break;
 316                                 /*
 317                                  * Don't report this if we're using a
 318                                  * required timeout and we got no packets,
 319                                  * because that could be a very short timeout,
 320                                  * and we don't want to spam the user with
 321                                  * a ton of "no packets" reports.
 322                                  */
 323                                 if (status != 0 || packet_count != 0 ||
 324                                     required_timeout != NULL) {
 325                                         printf("%d packets seen, %d packets counted after poll returns\n",
 326                                             status, packet_count);
 327                                 }
 328                         }
 329                 }
 330         } else {
 331                 for (;;) {
 332                         packet_count = 0;
 333                         status = pcap_dispatch(pd, -1, countme,
 334                             (u_char *)&packet_count);
 335                         if (status < 0)
 336                                 break;
 337                         printf("%d packets seen, %d packets counted after pcap_dispatch returns\n",
 338                             status, packet_count);
 339                 }
 340         }
 341         if (status == -2) {
 342                 /*
 343                  * We got interrupted, so perhaps we didn't
 344                  * manage to finish a line we were printing.
 345                  * Print an extra newline, just in case.
 346                  */
 347                 putchar('\n');
 348         }
 349         (void)fflush(stdout);
 350         if (status == -1) {
 351                 /*
 352                  * Error.  Report it.
 353                  */
 354                 (void)fprintf(stderr, "%s: pcap_dispatch: %s\n",
 355                     program_name, pcap_geterr(pd));
 356         }
 357         pcap_close(pd);
 358         exit(status == -1 ? 1 : 0);
 359 }
 360
 361 static void
 362 countme(u_char *user, const struct pcap_pkthdr *h _U_, const u_char *sp _U_)
 363 {
 364         int *counterp = (int *)user;
 365
 366         (*counterp)++;
 367 }
 368
 369 static void
 370 usage(void)
 371 {
 372         (void)fprintf(stderr, "Usage: %s [ -sptnq ] [ -i interface ] [expression]\n",
 373             program_name);
 374         exit(1);
 375 }
 376
 377 /* VARARGS */
 378 static void
 379 error(const char *fmt, ...)
 380 {
 381         va_list ap;
 382
 383         (void)fprintf(stderr, "%s: ", program_name);
 384         va_start(ap, fmt);
 385         (void)vfprintf(stderr, fmt, ap);
 386         va_end(ap);
 387         if (*fmt) {
 388                 fmt += strlen(fmt);
 389                 if (fmt[-1] != '\n')
 390                         (void)fputc('\n', stderr);
 391         }
 392         exit(1);
 393         /* NOTREACHED */
 394 }
 395
 396 /* VARARGS */
 397 static void
 398 warning(const char *fmt, ...)
 399 {
 400         va_list ap;
 401
 402         (void)fprintf(stderr, "%s: WARNING: ", program_name);
 403         va_start(ap, fmt);
 404         (void)vfprintf(stderr, fmt, ap);
 405         va_end(ap);
 406         if (*fmt) {
 407                 fmt += strlen(fmt);
 408                 if (fmt[-1] != '\n')
 409                         (void)fputc('\n', stderr);
 410         }
 411 }
 412
 413 /*
 414  * Copy arg vector into a new buffer, concatenating arguments with spaces.
 415  */
 416 static char *
 417 copy_argv(register char **argv)
 418 {
 419         register char **p;
 420         register size_t len = 0;
 421         char *buf;
 422         char *src, *dst;
 423
 424         p = argv;
 425         if (*p == 0)
 426                 return 0;
 427
 428         while (*p)
 429                 len += strlen(*p++) + 1;
 430
 431         buf = (char *)malloc(len);
 432         if (buf == NULL)
 433                 error("copy_argv: malloc");
 434
 435         p = argv;
 436         dst = buf;
 437         while ((src = *p++) != NULL) {
 438                 while ((*dst++ = *src++) != '\0')
 439                         ;
 440                 dst[-1] = ' ';
 441         }
 442         dst[-1] = '\0';
 443
 444         return buf;
 445 }