testprogs/writecaptest.c

/*
 * 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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <limits.h>
#ifdef _WIN32
  #include "getopt.h"
#else
  #include <unistd.h>
#endif
#include <errno.h>
#ifndef _WIN32
  #include <signal.h>
#endif
#include <sys/types.h>

#include <pcap.h>

#include "pcap/funcattrs.h"

#ifdef _WIN32
  #include "portability.h"
#endif

static char *program_name;

/* Forwards */
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;

#ifdef _WIN32
static BOOL WINAPI
stop_capture(DWORD ctrltype _U_)
{
	pcap_breakloop(pd);
	return TRUE;
}
#else
static void
stop_capture(int signum _U_)
{
	pcap_breakloop(pd);
}
#endif

static long
parse_interface_number(const char *device)
{
	const char *p;
	long devnum;
	char *end;

	/*
	 * Search for a colon, terminating any scheme at the beginning
	 * of the device.
	 */
	p = strchr(device, ':');
	if (p != NULL) {
		/*
		 * We found it.  Is it followed by "//"?
		 */
		p++;	/* skip the : */
		if (strncmp(p, "//", 2) == 0) {
			/*
			 * Yes.  Search for the next /, at the end of the
			 * authority part of the URL.
			 */
			p += 2;	/* skip the // */
			p = strchr(p, '/');
			if (p != NULL) {
				/*
				 * OK, past the / is the path.
				 */
				device = p + 1;
			}
		}
	}
	devnum = strtol(device, &end, 10);
	if (device != end && *end == '\0') {
		/*
		 * It's all-numeric, but is it a valid number?
		 */
		if (devnum <= 0) {
			/*
			 * No, it's not an ordinal.
			 */
			error("Invalid adapter index");
		}
		return (devnum);
	} else {
		/*
		 * It's not all-numeric; return -1, so our caller
		 * knows that.
		 */
		return (-1);
	}
}

static char *
find_interface_by_number(long devnum)
{
	pcap_if_t *dev, *devlist;
	long i;
	char ebuf[PCAP_ERRBUF_SIZE];
	char *device;
	int status;

	status = pcap_findalldevs(&devlist, ebuf);
	if (status < 0)
		error("%s", ebuf);
	/*
	 * Look for the devnum-th entry in the list of devices (1-based).
	 */
	for (i = 0, dev = devlist; i < devnum-1 && dev != NULL;
	    i++, dev = dev->next)
		;
	if (dev == NULL)
		error("Invalid adapter index");
	device = strdup(dev->name);
	pcap_freealldevs(devlist);
	return (device);
}

static pcap_t *
open_interface(const char *device, int snaplen_set, int snaplen, char *ebuf)
{
	pcap_t *pc;
	int status;
	char *cp;

	pc = pcap_create(device, ebuf);
	if (pc == NULL) {
		/*
		 * If this failed with "No such device", that means
		 * the interface doesn't exist; return NULL, so that
		 * the caller can see whether the device name is
		 * actually an interface index.
		 */
		if (strstr(ebuf, "No such device") != NULL)
			return (NULL);
		error("%s", ebuf);
	}
	if (snaplen_set) {
		status = pcap_set_snaplen(pc, snaplen);
		if (status != 0)
			error("%s: pcap_set_snaplen failed: %s",
			    device, pcap_statustostr(status));
	}
	status = pcap_set_timeout(pc, 100);
	if (status != 0)
		error("%s: pcap_set_timeout failed: %s",
		    device, pcap_statustostr(status));
	status = pcap_activate(pc);
	if (status < 0) {
		/*
		 * pcap_activate() failed.
		 */
		cp = pcap_geterr(pc);
		if (status == PCAP_ERROR)
			error("%s", cp);
		else if (status == PCAP_ERROR_NO_SUCH_DEVICE) {
			/*
			 * Return an error for our caller to handle.
			 */
			snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s: %s\n(%s)",
			    device, pcap_statustostr(status), cp);
		} else if (status == PCAP_ERROR_PERM_DENIED && *cp != '\0')
			error("%s: %s\n(%s)", device,
			    pcap_statustostr(status), cp);
		else
			error("%s: %s", device,
			    pcap_statustostr(status));
		pcap_close(pc);
		return (NULL);
	} else if (status > 0) {
		/*
		 * pcap_activate() succeeded, but it's warning us
		 * of a problem it had.
		 */
		cp = pcap_geterr(pc);
		if (status == PCAP_WARNING)
			warning("%s", cp);
		else if (status == PCAP_WARNING_PROMISC_NOTSUP &&
		         *cp != '\0')
			warning("%s: %s\n(%s)", device,
			    pcap_statustostr(status), cp);
		else
			warning("%s: %s", device,
			    pcap_statustostr(status));
	}
	return (pc);
}

#define COMMAND_OPTIONS	"DLi:s:w:y:"

int
main(int argc, char **argv)
{
	int op;
	char *cp, *cmdbuf = NULL, *device, *end, *savefile = NULL;
	int snaplen = 0;
	int snaplen_set = 0;
	pcap_if_t *devlist;
	long devnum;
	int show_interfaces = 0;
	int show_dlt_types = 0;
	int ndlts;
	int *dlts;
	bpf_u_int32 localnet, netmask;
	struct bpf_program fcode;
	char ebuf[PCAP_ERRBUF_SIZE];
#ifndef _WIN32
	struct sigaction action;
#endif
	int dlt;
	const char *dlt_name = NULL;
	int status;
	pcap_dumper_t *pdd;

	device = NULL;
	if ((cp = strrchr(argv[0], '/')) != NULL)
		program_name = cp + 1;
	else
		program_name = argv[0];

	opterr = 0;
	while ((op = getopt(argc, argv, COMMAND_OPTIONS)) != -1) {
		switch (op) {

		case 'D':
			show_interfaces = 1;
			break;

		case 'L':
			show_dlt_types = 1;
			break;

		case 'i':
			device = optarg;
			break;

		case 's':
			snaplen = (int)strtol(optarg, &end, 0);
			if (optarg == end || *end != '\0' || snaplen < 0)
				error("invalid snaplen %s (must be >= 0)",
				    optarg);
			snaplen_set = 1;
			break;

		case 'w':
			savefile = optarg;
			break;

		case 'y':
			dlt_name = optarg;
			break;

		default:
			usage();
			/* NOTREACHED */
		}
	}

	if (show_interfaces) {
		pcap_if_t *dev;
		int i;

		if (pcap_findalldevs(&devlist, ebuf) < 0)
			error("%s", ebuf);
		for (i = 0, dev = devlist; dev != NULL; i++, dev = dev->next) {
			printf("%d.%s", i+1, dev->name);
			if (dev->description != NULL)
				printf(" (%s)", dev->description);
			printf("\n");
		}
		pcap_freealldevs(devlist);
		return (0);
	}

	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);
	}
	if (show_dlt_types) {
		pd = pcap_create(device, ebuf);
		if (pd == NULL)
			error("%s", ebuf);
		status = pcap_activate(pd);
		if (status < 0) {
			/*
			 * pcap_activate() failed.
			 */
			error("%s: %s\n(%s)", device,
			    pcap_statustostr(status), pcap_geterr(pd));
		}
		ndlts = pcap_list_datalinks(pd, &dlts);
		if (ndlts < 0) {
			/*
			 * pcap_list_datalinks() failed.
			 */
			error("%s: %s\n(%s)", device,
			    pcap_statustostr(status), pcap_geterr(pd));
		}
		for (int i = 0; i < ndlts; i++) {
			dlt_name = pcap_datalink_val_to_name(dlts[i]);
			if (dlt_name == NULL)
				printf("DLT %d", dlts[i]);
			else
				printf("%s", dlt_name);
			printf("\n");
		}
		pcap_free_datalinks(dlts);
		pcap_close(pd);
		return 0;
	}

	if (savefile == NULL)
		error("no savefile specified");

	*ebuf = '\0';

	pd = open_interface(device, snaplen_set, snaplen, ebuf);
	if (pd == NULL) {
		/*
		 * That failed because the interface couldn't be found.
		 *
		 * If we can get a list of interfaces, and the interface name
		 * is purely numeric, try to use it as a 1-based index
		 * in the list of interfaces.
		 */
		devnum = parse_interface_number(device);
		if (devnum == -1) {
			/*
			 * It's not a number; just report
			 * the open error and fail.
			 */
			error("%s", ebuf);
		}

		/*
		 * OK, it's a number; try to find the
		 * interface with that index, and try
		 * to open it.
		 *
		 * find_interface_by_number() exits if it
		 * couldn't be found.
		 */
		device = find_interface_by_number(devnum);
		pd = open_interface(device, snaplen_set, snaplen, ebuf);
		if (pd == NULL)
			error("%s", ebuf);
	}

	if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {
		localnet = 0;
		netmask = 0;
		warning("%s", ebuf);
	}

	if (dlt_name != NULL) {
		dlt = pcap_datalink_name_to_val(dlt_name);
		if (dlt == PCAP_ERROR)
			error("%s isn't a valid DLT name", dlt_name);
		if (pcap_set_datalink(pd, dlt) == PCAP_ERROR)
			error("%s: %s", device, pcap_geterr(pd));
	}

	/*
	 * Don't set a filter unless we were given one on the
	 * command line; if capturing doesn't work, or doesn't
	 * use the snapshot length, without a filter, that's
	 * a bug.
	 */
	if (optind < argc) {
		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));
	}

	pdd = pcap_dump_open(pd, savefile);
	if (pdd == NULL)
		error("%s", pcap_geterr(pd));

#ifdef _WIN32
	SetConsoleCtrlHandler(stop_capture, TRUE);
#else
	action.sa_handler = stop_capture;
	sigemptyset(&action.sa_mask);
	action.sa_flags = 0;
	if (sigaction(SIGINT, &action, NULL) == -1)
		error("Can't catch SIGINT: %s\n", strerror(errno));
#endif

	printf("Listening on %s, link-type ", device);
	dlt = pcap_datalink(pd);
	dlt_name = pcap_datalink_val_to_name(dlt);
	if (dlt_name == NULL)
		printf("DLT %d", dlt);
	else
		printf("%s", dlt_name);
	printf("\n");
	for (;;) {
		status = pcap_dispatch(pd, -1, pcap_dump, (u_char *)pdd);
		if (status < 0)
			break;
		if (status != 0) {
			printf("%d packets seen\n", status);
			struct pcap_stat ps;
			pcap_stats(pd, &ps);
			printf("%d ps_recv, %d ps_drop, %d ps_ifdrop\n",
			    ps.ps_recv, ps.ps_drop, ps.ps_ifdrop);
		}
	}
	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');
		printf("Broken out of loop from SIGINT handler\n");
	}
	(void)fflush(stdout);
	if (status == -1) {
		/*
		 * Error.  Report it.
		 */
		(void)fprintf(stderr, "%s: pcap_dispatch: %s\n",
		    program_name, pcap_geterr(pd));
	}
	pcap_close(pd);
	if (cmdbuf != NULL) {
		pcap_freecode(&fcode);
		free(cmdbuf);
	}
	exit(status == -1 ? 1 : 0);
}

static void
usage(void)
{
	(void)fprintf(stderr, "Usage: %s -D -L [ -i interface ] [ -s snaplen ] [ -w file ] [ -y dlt ] [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 size_t 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;
}