/*

 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that: (1) source code distributions

 * retain the above copyright notice and this paragraph in its entirety, (2)

 * distributions including binary code include the above copyright notice and

 * this paragraph in its entirety in the documentation or other materials

 * provided with the distribution, and (3) all advertising materials mentioning

 * features or use of this software display the following acknowledgement:

 * ``This product includes software developed by the University of California,

 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of

 * the University nor the names of its contributors may be used to endorse

 * or promote products derived from this software without specific prior

 * written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED

 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */

#include "varattrs.h"

#ifndef lint

static const char copyright[] _U_ =

    "@(#) Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000\n\

The Regents of the University of California.  All rights reserved.\n";

#endif

/*

 * Tests how select() and poll() behave on the selectable file descriptor

 * for a pcap_t.

 *

 * This would be significantly different on Windows, as it'd test

 * how WaitForMultipleObjects() would work on the event handle for a

 * pcap_t.

 */

#include <pcap.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <unistd.h>

#include <errno.h>

#include <sys/types.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#else

#include <sys/time.h>	/* older UN*Xes */

#endif

#include <poll.h>

#include "pcap/funcattrs.h"

static char *program_name;

/* Forwards */

static void countme(u_char *, const struct pcap_pkthdr *, const u_char *);

static void PCAP_NORETURN usage(void);

static void PCAP_NORETURN error(const char *, ...) PCAP_PRINTFLIKE(1, 2);

static void warning(const char *, ...) PCAP_PRINTFLIKE(1, 2);

static char *copy_argv(char **);

static pcap_t *pd;

int

main(int argc, char **argv)

{

	register int op;

	bpf_u_int32 localnet, netmask;

	register char *cp, *cmdbuf, *device;

	int doselect, dopoll, dotimeout, dononblock;

	const char *mechanism;

	struct bpf_program fcode;

	char ebuf[PCAP_ERRBUF_SIZE];

	pcap_if_t *devlist;

	int selectable_fd;

	struct timeval *required_timeout;

	int status;

	int packet_count;

	device = NULL;

	doselect = 0;

	dopoll = 0;

	mechanism = NULL;

	dotimeout = 0;

	dononblock = 0;

	if ((cp = strrchr(argv[0], '/')) != NULL)

		program_name = cp + 1;

	else

		program_name = argv[0];

	opterr = 0;

	while ((op = getopt(argc, argv, "i:sptn")) != -1) {

		switch (op) {

		case 'i':

			device = optarg;

			break;

		case 's':

			doselect = 1;

			mechanism = "select() and pcap_dispatch()";

			break;

		case 'p':

			dopoll = 1;

			mechanism = "poll() and pcap_dispatch()";

			break;

		case 't':

			dotimeout = 1;

			break;

		case 'n':

			dononblock = 1;

			break;

		default:

			usage();

			/* NOTREACHED */

		}

	}

	if (doselect && dopoll) {

		fprintf(stderr, "selpolltest: choose select (-s) or poll (-p), but not both\n");

		return 1;

	}

	if (dotimeout && !doselect && !dopoll) {

		fprintf(stderr, "selpolltest: timeout (-t) requires select (-s) or poll (-p)\n");

		return 1;

	}

	if (device == NULL) {

		if (pcap_findalldevs(&devlist, ebuf) == -1)

			error("%s", ebuf);

		if (devlist == NULL)

			error("no interfaces available for capture");

		device = strdup(devlist->name);

		pcap_freealldevs(devlist);

	}

	*ebuf = '\0';

	pd = pcap_open_live(device, 65535, 0, 1000, ebuf);

	if (pd == NULL)

		error("%s", ebuf);

	else if (*ebuf)

		warning("%s", ebuf);

	if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {

		localnet = 0;

		netmask = 0;

		warning("%s", ebuf);

	}

	cmdbuf = copy_argv(&argv[optind]);

	if (pcap_compile(pd, &fcode, cmdbuf, 1, netmask) < 0)

		error("%s", pcap_geterr(pd));

	if (pcap_setfilter(pd, &fcode) < 0)

		error("%s", pcap_geterr(pd));

	if (doselect || dopoll) {

		/*

		 * We need either an FD on which to do select()/poll()

		 * or, if there isn't one, a timeout to use in select()/

		 * poll().

		 */

		selectable_fd = pcap_get_selectable_fd(pd);

		if (selectable_fd == -1) {

			printf("Listening on %s, using %s, with a timeout\n",

			    device, mechanism);

			required_timeout = pcap_get_required_select_timeout(pd);

			if (required_timeout == NULL)

				error("select()/poll() isn't supported on %s, even with a timeout",

				    device);

			/*

			 * As we won't be notified by select() or poll()

			 * that a read can be done, we'll have to periodically

			 * try reading from the device every time the required

			 * timeout expires, and we don't want those attempts

			 * to block if nothing has arrived in that interval,

			 * so we want to force non-blocking mode.

			 */

			dononblock = 1;

		} else {

			printf("Listening on %s, using %s\n", device,

			    mechanism);

			required_timeout = NULL;

		}

	} else

		printf("Listening on %s, using pcap_dispatch()\n", device);

	if (dononblock) {

		if (pcap_setnonblock(pd, 1, ebuf) == -1)

			error("pcap_setnonblock failed: %s", ebuf);

	}

	if (doselect) {

		for (;;) {

			fd_set setread, setexcept;

			struct timeval seltimeout;

			FD_ZERO(&setread);

			if (selectable_fd != -1) {

				FD_SET(selectable_fd, &setread);

				FD_ZERO(&setexcept);

				FD_SET(selectable_fd, &setexcept);

			}

			if (dotimeout) {

				seltimeout.tv_sec = 0;

				if (required_timeout != NULL &&

				    required_timeout->tv_usec < 1000)

					seltimeout.tv_usec = required_timeout->tv_usec;

				else

					seltimeout.tv_usec = 1000;

				status = select(selectable_fd + 1, &setread,

				    NULL, &setexcept, &seltimeout);

			} else if (required_timeout != NULL) {

				seltimeout = *required_timeout;

				status = select(selectable_fd + 1, &setread,

				    NULL, &setexcept, &seltimeout);

			} else {

				status = select((selectable_fd == -1) ?

				    0 : selectable_fd + 1, &setread,

				    NULL, &setexcept, NULL);

			}

			if (status == -1) {

				printf("Select returns error (%s)\n",

				    strerror(errno));

			} else {

				if (selectable_fd == -1) {

					if (status != 0)

						printf("Select returned a descriptor\n");

				} else {

					if (status == 0)

						printf("Select timed out: ");

					else

						printf("Select returned a descriptor: ");

					if (FD_ISSET(selectable_fd, &setread))

						printf("readable, ");

					else

						printf("not readable, ");

					if (FD_ISSET(selectable_fd, &setexcept))

						printf("exceptional condition\n");

					else

						printf("no exceptional condition\n");

				}

				packet_count = 0;

				status = pcap_dispatch(pd, -1, countme,

				    (u_char *)&packet_count);

				if (status < 0)

					break;

				/*

				 * Don't report this if we're using a

				 * required timeout and we got no packets,

				 * because that could be a very short timeout,

				 * and we don't want to spam the user with

				 * a ton of "no packets" reports.

				 */

				if (status != 0 || packet_count != 0 ||

				    required_timeout != NULL) {

					printf("%d packets seen, %d packets counted after select returns\n",

					    status, packet_count);

				}

			}

		}

	} else if (dopoll) {

		for (;;) {

			struct pollfd fd;

			int polltimeout;

			fd.fd = selectable_fd;

			fd.events = POLLIN;

			if (dotimeout)

				polltimeout = 1;

			else if (required_timeout != NULL &&

			    required_timeout->tv_usec >= 1000)

				polltimeout = required_timeout->tv_usec/1000;

			else

				polltimeout = -1;

			status = poll(&fd, (selectable_fd == -1) ? 0 : 1, polltimeout);

			if (status == -1) {

				printf("Poll returns error (%s)\n",

				    strerror(errno));

			} else {

				if (selectable_fd == -1) {

					if (status != 0)

						printf("Poll returned a descriptor\n");

				} else {

					if (status == 0)

						printf("Poll timed out\n");

					else {

						printf("Poll returned a descriptor: ");

						if (fd.revents & POLLIN)

							printf("readable, ");

						else

							printf("not readable, ");

						if (fd.revents & POLLERR)

							printf("exceptional condition, ");

						else

							printf("no exceptional condition, ");

						if (fd.revents & POLLHUP)

							printf("disconnect, ");

						else

							printf("no disconnect, ");

						if (fd.revents & POLLNVAL)

							printf("invalid\n");

						else

							printf("not invalid\n");

					}

				}

				packet_count = 0;

				status = pcap_dispatch(pd, -1, countme,

				    (u_char *)&packet_count);

				if (status < 0)

					break;

				/*

				 * Don't report this if we're using a

				 * required timeout and we got no packets,

				 * because that could be a very short timeout,

				 * and we don't want to spam the user with

				 * a ton of "no packets" reports.

				 */

				if (status != 0 || packet_count != 0 ||

				    required_timeout != NULL) {

					printf("%d packets seen, %d packets counted after poll returns\n",

					    status, packet_count);

				}

			}

		}

	} else {

		for (;;) {

			packet_count = 0;

			status = pcap_dispatch(pd, -1, countme,

			    (u_char *)&packet_count);

			if (status < 0)

				break;

			printf("%d packets seen, %d packets counted after pcap_dispatch returns\n",

			    status, packet_count);

		}

	}

	if (status == -2) {

		/*

		 * We got interrupted, so perhaps we didn't

		 * manage to finish a line we were printing.

		 * Print an extra newline, just in case.

		 */

		putchar('\n');

	}

	(void)fflush(stdout);

	if (status == -1) {

		/*

		 * Error.  Report it.

		 */

		(void)fprintf(stderr, "%s: pcap_loop: %s\n",

		    program_name, pcap_geterr(pd));

	}

	pcap_close(pd);

	exit(status == -1 ? 1 : 0);

}

static void

countme(u_char *user, const struct pcap_pkthdr *h _U_, const u_char *sp _U_)

{

	int *counterp = (int *)user;

	(*counterp)++;

}

static void

usage(void)

{

	(void)fprintf(stderr, "Usage: %s [ -sptn ] [ -i interface ] [expression]\n",

	    program_name);

	exit(1);

}

/* VARARGS */

static void

error(const char *fmt, ...)

{

	va_list ap;

	(void)fprintf(stderr, "%s: ", program_name);

	va_start(ap, fmt);

	(void)vfprintf(stderr, fmt, ap);

	va_end(ap);

	if (*fmt) {

		fmt += strlen(fmt);

		if (fmt[-1] != '\n')

			(void)fputc('\n', stderr);

	}

	exit(1);

	/* NOTREACHED */

}

/* VARARGS */

static void

warning(const char *fmt, ...)

{

	va_list ap;

	(void)fprintf(stderr, "%s: WARNING: ", program_name);

	va_start(ap, fmt);

	(void)vfprintf(stderr, fmt, ap);

	va_end(ap);

	if (*fmt) {

		fmt += strlen(fmt);

		if (fmt[-1] != '\n')

			(void)fputc('\n', stderr);

	}

}

/*

 * Copy arg vector into a new buffer, concatenating arguments with spaces.

 */

static char *

copy_argv(register char **argv)

{

	register char **p;

	register u_int len = 0;

	char *buf;

	char *src, *dst;

	p = argv;

	if (*p == 0)

		return 0;

	while (*p)

		len += strlen(*p++) + 1;

	buf = (char *)malloc(len);

	if (buf == NULL)

		error("copy_argv: malloc");

	p = argv;

	dst = buf;

	while ((src = *p++) != NULL) {

		while ((*dst++ = *src++) != '\0')

			;

		dst[-1] = ' ';

	}

	dst[-1] = '\0';

	return buf;

}