xref: /freebsd/contrib/pf/pflogd/pflogd.c (revision a90b9d0159070121c221b966469c3e36d912bf82) 
1 /*	$OpenBSD: pflogd.c,v 1.46 2008/10/22 08:16:49 henning Exp $	*/
2 
3 /*
4  * Copyright (c) 2001 Theo de Raadt
5  * Copyright (c) 2001 Can Erkin Acar
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  *    - Redistributions of source code must retain the above copyright
13  *      notice, this list of conditions and the following disclaimer.
14  *    - Redistributions in binary form must reproduce the above
15  *      copyright notice, this list of conditions and the following
16  *      disclaimer in the documentation and/or other materials provided
17  *      with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 #include <sys/types.h>
34 #include <sys/ioctl.h>
35 #include <sys/file.h>
36 #include <sys/stat.h>
37 #include <sys/socket.h>
38 #include <net/if.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <pcap-int.h>
44 #include <pcap.h>
45 #include <syslog.h>
46 #include <signal.h>
47 #include <err.h>
48 #include <errno.h>
49 #include <stdarg.h>
50 #include <fcntl.h>
51 #ifdef __FreeBSD__
52 #include <ifaddrs.h>
53 #include "pidfile.h"
54 #else
55 #include <util.h>
56 #endif
57 #include "pflogd.h"
58 
59 pcap_t *hpcap;
60 static FILE *dpcap;
61 
62 int Debug = 0;
63 static int snaplen = DEF_SNAPLEN;
64 static int cur_snaplen = DEF_SNAPLEN;
65 
66 volatile sig_atomic_t gotsig_close, gotsig_alrm, gotsig_hup, gotsig_usr1;
67 
68 char *filename = PFLOGD_LOG_FILE;
69 char *interface = PFLOGD_DEFAULT_IF;
70 char *filter = NULL;
71 
72 char errbuf[PCAP_ERRBUF_SIZE];
73 
74 int log_debug = 0;
75 unsigned int delay = FLUSH_DELAY;
76 
77 char *copy_argv(char * const *);
78 void  dump_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
79 void  dump_packet_nobuf(u_char *, const struct pcap_pkthdr *, const u_char *);
80 void  log_pcap_stats(void);
81 int   flush_buffer(FILE *);
82 int   if_exists(char *);
83 int   init_pcap(void);
84 void  logmsg(int, const char *, ...);
85 void  purge_buffer(void);
86 int   reset_dump(int);
87 int   scan_dump(FILE *, off_t);
88 int   set_snaplen(int);
89 void  set_suspended(int);
90 void  sig_alrm(int);
91 void  sig_usr1(int);
92 void  sig_close(int);
93 void  sig_hup(int);
94 void  usage(void);
95 
96 static int try_reset_dump(int);
97 
98 /* buffer must always be greater than snaplen */
99 static int    bufpkt = 0;	/* number of packets in buffer */
100 static int    buflen = 0;	/* allocated size of buffer */
101 static char  *buffer = NULL;	/* packet buffer */
102 static char  *bufpos = NULL;	/* position in buffer */
103 static int    bufleft = 0;	/* bytes left in buffer */
104 
105 /* if error, stop logging but count dropped packets */
106 static int suspended = -1;
107 static long packets_dropped = 0;
108 
109 void
110 set_suspended(int s)
111 {
112 	if (suspended == s)
113 		return;
114 
115 	suspended = s;
116 	setproctitle("[%s] -s %d -i %s -f %s",
117 	    suspended ? "suspended" : "running",
118 	    cur_snaplen, interface, filename);
119 }
120 
121 char *
122 copy_argv(char * const *argv)
123 {
124 	size_t len = 0, n;
125 	char *buf;
126 
127 	if (argv == NULL)
128 		return (NULL);
129 
130 	for (n = 0; argv[n]; n++)
131 		len += strlen(argv[n])+1;
132 	if (len == 0)
133 		return (NULL);
134 
135 	buf = malloc(len);
136 	if (buf == NULL)
137 		return (NULL);
138 
139 	strlcpy(buf, argv[0], len);
140 	for (n = 1; argv[n]; n++) {
141 		strlcat(buf, " ", len);
142 		strlcat(buf, argv[n], len);
143 	}
144 	return (buf);
145 }
146 
147 void
148 logmsg(int pri, const char *message, ...)
149 {
150 	va_list ap;
151 	va_start(ap, message);
152 
153 	if (log_debug) {
154 		vfprintf(stderr, message, ap);
155 		fprintf(stderr, "\n");
156 	} else
157 		vsyslog(pri, message, ap);
158 	va_end(ap);
159 }
160 
161 #ifdef __FreeBSD__
162 __dead2 void
163 #else
164 __dead void
165 #endif
166 usage(void)
167 {
168 	fprintf(stderr, "usage: pflogd [-Dx] [-d delay] [-f filename]");
169 	fprintf(stderr, " [-i interface] [-p pidfile]\n");
170 	fprintf(stderr, "              [-s snaplen] [expression]\n");
171 	exit(1);
172 }
173 
174 void
175 sig_close(int sig)
176 {
177 	gotsig_close = 1;
178 }
179 
180 void
181 sig_hup(int sig)
182 {
183 	gotsig_hup = 1;
184 }
185 
186 void
187 sig_alrm(int sig)
188 {
189 	gotsig_alrm = 1;
190 }
191 
192 void
193 sig_usr1(int sig)
194 {
195 	gotsig_usr1 = 1;
196 }
197 
198 void
199 set_pcap_filter(void)
200 {
201 	struct bpf_program bprog;
202 
203 	if (pcap_compile(hpcap, &bprog, filter, PCAP_OPT_FIL, 0) < 0)
204 		logmsg(LOG_WARNING, "%s", pcap_geterr(hpcap));
205 	else {
206 		if (pcap_setfilter(hpcap, &bprog) < 0)
207 			logmsg(LOG_WARNING, "%s", pcap_geterr(hpcap));
208 		pcap_freecode(&bprog);
209 	}
210 }
211 
212 int
213 if_exists(char *ifname)
214 {
215 #ifdef __FreeBSD__
216 	struct ifaddrs *ifdata, *mb;
217 	int exists = 0;
218 
219 	getifaddrs(&ifdata);
220         if (ifdata == NULL)
221 		return (0);
222 
223 	for (mb = ifdata; mb != NULL; mb = mb->ifa_next) {
224 		if (mb == NULL)
225 			continue;
226 		if (strlen(ifname) != strlen(mb->ifa_name))
227 			continue;
228 		if (strncmp(ifname, mb->ifa_name, strlen(ifname)) != 0)
229 			continue;
230 		exists = 1;
231 		break;
232 	}
233 	freeifaddrs(ifdata);
234 
235 	return (exists);
236 #else
237 	int s;
238 	struct ifreq ifr;
239 	struct if_data ifrdat;
240 
241 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
242 		err(1, "socket");
243 	bzero(&ifr, sizeof(ifr));
244 	if (strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)) >=
245 		sizeof(ifr.ifr_name))
246 			errx(1, "main ifr_name: strlcpy");
247 	ifr.ifr_data = (caddr_t)&ifrdat;
248 	if (ioctl(s, SIOCGIFDATA, (caddr_t)&ifr) == -1)
249 		return (0);
250 	if (close(s))
251 		err(1, "close");
252 
253 	return (1);
254 #endif
255 }
256 
257 int
258 init_pcap(void)
259 {
260 	hpcap = pcap_open_live(interface, snaplen, 1, PCAP_TO_MS, errbuf);
261 	if (hpcap == NULL) {
262 		logmsg(LOG_ERR, "Failed to initialize: %s", errbuf);
263 		return (-1);
264 	}
265 
266 	if (pcap_datalink(hpcap) != DLT_PFLOG) {
267 		logmsg(LOG_ERR, "Invalid datalink type");
268 		pcap_close(hpcap);
269 		hpcap = NULL;
270 		return (-1);
271 	}
272 
273 	set_pcap_filter();
274 
275 	cur_snaplen = snaplen = pcap_snapshot(hpcap);
276 
277 	/* lock */
278 	if (ioctl(pcap_fileno(hpcap), BIOCLOCK) < 0) {
279 		logmsg(LOG_ERR, "BIOCLOCK: %s", strerror(errno));
280 		return (-1);
281 	}
282 
283 	return (0);
284 }
285 
286 int
287 set_snaplen(int snap)
288 {
289 	if (priv_set_snaplen(snap))
290 		return (1);
291 
292 	if (cur_snaplen > snap)
293 		purge_buffer();
294 
295 	cur_snaplen = snap;
296 
297 	return (0);
298 }
299 
300 int
301 reset_dump(int nomove)
302 {
303 	int ret;
304 
305 	for (;;) {
306 		ret = try_reset_dump(nomove);
307 		if (ret <= 0)
308 			break;
309 	}
310 
311 	return (ret);
312 }
313 
314 /*
315  * tries to (re)open log file, nomove flag is used with -x switch
316  * returns 0: success, 1: retry (log moved), -1: error
317  */
318 int
319 try_reset_dump(int nomove)
320 {
321 	struct pcap_file_header hdr;
322 	struct stat st;
323 	int fd;
324 	FILE *fp;
325 
326 	if (hpcap == NULL)
327 		return (-1);
328 
329 	if (dpcap) {
330 		flush_buffer(dpcap);
331 		fclose(dpcap);
332 		dpcap = NULL;
333 	}
334 
335 	/*
336 	 * Basically reimplement pcap_dump_open() because it truncates
337 	 * files and duplicates headers and such.
338 	 */
339 	fd = priv_open_log();
340 	if (fd < 0)
341 		return (-1);
342 
343 	fp = fdopen(fd, "a+");
344 
345 	if (fp == NULL) {
346 		logmsg(LOG_ERR, "Error: %s: %s", filename, strerror(errno));
347 		close(fd);
348 		return (-1);
349 	}
350 	if (fstat(fileno(fp), &st) == -1) {
351 		logmsg(LOG_ERR, "Error: %s: %s", filename, strerror(errno));
352 		fclose(fp);
353 		return (-1);
354 	}
355 
356 	/* set FILE unbuffered, we do our own buffering */
357 	if (setvbuf(fp, NULL, _IONBF, 0)) {
358 		logmsg(LOG_ERR, "Failed to set output buffers");
359 		fclose(fp);
360 		return (-1);
361 	}
362 
363 #define TCPDUMP_MAGIC 0xa1b2c3d4
364 
365 	if (st.st_size == 0) {
366 		if (snaplen != cur_snaplen) {
367 			logmsg(LOG_NOTICE, "Using snaplen %d", snaplen);
368 			if (set_snaplen(snaplen))
369 				logmsg(LOG_WARNING,
370 				    "Failed, using old settings");
371 		}
372 		hdr.magic = TCPDUMP_MAGIC;
373 		hdr.version_major = PCAP_VERSION_MAJOR;
374 		hdr.version_minor = PCAP_VERSION_MINOR;
375 		hdr.thiszone = 0;
376 		hdr.snaplen = hpcap->snapshot;
377 		hdr.sigfigs = 0;
378 		hdr.linktype = hpcap->linktype;
379 
380 		if (fwrite((char *)&hdr, sizeof(hdr), 1, fp) != 1) {
381 			fclose(fp);
382 			return (-1);
383 		}
384 	} else if (scan_dump(fp, st.st_size)) {
385 		fclose(fp);
386 		if (nomove || priv_move_log()) {
387 			logmsg(LOG_ERR,
388 			    "Invalid/incompatible log file, move it away");
389 			return (-1);
390 		}
391 		return (1);
392 	}
393 
394 	dpcap = fp;
395 
396 	set_suspended(0);
397 	flush_buffer(fp);
398 
399 	return (0);
400 }
401 
402 int
403 scan_dump(FILE *fp, off_t size)
404 {
405 	struct pcap_file_header hdr;
406 #ifdef __FreeBSD__
407 	struct pcap_sf_pkthdr ph;
408 #else
409 	struct pcap_pkthdr ph;
410 #endif
411 	off_t pos;
412 
413 	/*
414 	 * Must read the file, compare the header against our new
415 	 * options (in particular, snaplen) and adjust our options so
416 	 * that we generate a correct file. Furthermore, check the file
417 	 * for consistency so that we can append safely.
418 	 *
419 	 * XXX this may take a long time for large logs.
420 	 */
421 	(void) fseek(fp, 0L, SEEK_SET);
422 
423 	if (fread((char *)&hdr, sizeof(hdr), 1, fp) != 1) {
424 		logmsg(LOG_ERR, "Short file header");
425 		return (1);
426 	}
427 
428 	if (hdr.magic != TCPDUMP_MAGIC ||
429 	    hdr.version_major != PCAP_VERSION_MAJOR ||
430 	    hdr.version_minor != PCAP_VERSION_MINOR ||
431 	    hdr.linktype != hpcap->linktype ||
432 	    hdr.snaplen > PFLOGD_MAXSNAPLEN) {
433 		return (1);
434 	}
435 
436 	pos = sizeof(hdr);
437 
438 	while (!feof(fp)) {
439 		off_t len = fread((char *)&ph, 1, sizeof(ph), fp);
440 		if (len == 0)
441 			break;
442 
443 		if (len != sizeof(ph))
444 			goto error;
445 		if (ph.caplen > hdr.snaplen || ph.caplen > PFLOGD_MAXSNAPLEN)
446 			goto error;
447 		pos += sizeof(ph) + ph.caplen;
448 		if (pos > size)
449 			goto error;
450 		fseek(fp, ph.caplen, SEEK_CUR);
451 	}
452 
453 	if (pos != size)
454 		goto error;
455 
456 	if (hdr.snaplen != cur_snaplen) {
457 		logmsg(LOG_WARNING,
458 		       "Existing file has different snaplen %u, using it",
459 		       hdr.snaplen);
460 		if (set_snaplen(hdr.snaplen)) {
461 			logmsg(LOG_WARNING,
462 			       "Failed, using old settings, offset %llu",
463 			       (unsigned long long) size);
464 		}
465 	}
466 
467 	return (0);
468 
469  error:
470 	logmsg(LOG_ERR, "Corrupted log file.");
471 	return (1);
472 }
473 
474 /* dump a packet directly to the stream, which is unbuffered */
475 void
476 dump_packet_nobuf(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
477 {
478 	FILE *f = (FILE *)user;
479 #ifdef __FreeBSD__
480 	struct pcap_sf_pkthdr sh;
481 #endif
482 
483 	if (suspended) {
484 		packets_dropped++;
485 		return;
486 	}
487 
488 #ifdef __FreeBSD__
489 	sh.ts.tv_sec = (bpf_int32)h->ts.tv_sec;
490 	sh.ts.tv_usec = (bpf_int32)h->ts.tv_usec;
491 	sh.caplen = h->caplen;
492 	sh.len = h->len;
493 
494 	if (fwrite((char *)&sh, sizeof(sh), 1, f) != 1) {
495 #else
496 	if (fwrite((char *)h, sizeof(*h), 1, f) != 1) {
497 #endif
498 		off_t pos = ftello(f);
499 
500 		/* try to undo header to prevent corruption */
501 #ifdef __FreeBSD__
502 		if (pos < sizeof(sh) ||
503 		    ftruncate(fileno(f), pos - sizeof(sh))) {
504 #else
505 		if (pos < sizeof(*h) ||
506 		    ftruncate(fileno(f), pos - sizeof(*h))) {
507 #endif
508 			logmsg(LOG_ERR, "Write failed, corrupted logfile!");
509 			set_suspended(1);
510 			gotsig_close = 1;
511 			return;
512 		}
513 		goto error;
514 	}
515 
516 	if (fwrite((char *)sp, h->caplen, 1, f) != 1)
517 		goto error;
518 
519 	return;
520 
521 error:
522 	set_suspended(1);
523 	packets_dropped ++;
524 	logmsg(LOG_ERR, "Logging suspended: fwrite: %s", strerror(errno));
525 }
526 
527 int
528 flush_buffer(FILE *f)
529 {
530 	off_t offset;
531 	int len = bufpos - buffer;
532 
533 	if (len <= 0)
534 		return (0);
535 
536 	offset = ftello(f);
537 	if (offset == (off_t)-1) {
538 		set_suspended(1);
539 		logmsg(LOG_ERR, "Logging suspended: ftello: %s",
540 		    strerror(errno));
541 		return (1);
542 	}
543 
544 	if (fwrite(buffer, len, 1, f) != 1) {
545 		set_suspended(1);
546 		logmsg(LOG_ERR, "Logging suspended: fwrite: %s",
547 		    strerror(errno));
548 		ftruncate(fileno(f), offset);
549 		return (1);
550 	}
551 
552 	set_suspended(0);
553 	bufpos = buffer;
554 	bufleft = buflen;
555 	bufpkt = 0;
556 
557 	return (0);
558 }
559 
560 void
561 purge_buffer(void)
562 {
563 	packets_dropped += bufpkt;
564 
565 	set_suspended(0);
566 	bufpos = buffer;
567 	bufleft = buflen;
568 	bufpkt = 0;
569 }
570 
571 /* append packet to the buffer, flushing if necessary */
572 void
573 dump_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
574 {
575 	FILE *f = (FILE *)user;
576 #ifdef __FreeBSD__
577 	struct pcap_sf_pkthdr sh;
578 	size_t len = sizeof(sh) + h->caplen;
579 #else
580 	size_t len = sizeof(*h) + h->caplen;
581 #endif
582 
583 	if (len < sizeof(*h) || h->caplen > (size_t)cur_snaplen) {
584 		logmsg(LOG_NOTICE, "invalid size %u (%u/%u), packet dropped",
585 		       len, cur_snaplen, snaplen);
586 		packets_dropped++;
587 		return;
588 	}
589 
590 	if (len <= bufleft)
591 		goto append;
592 
593 	if (suspended) {
594 		packets_dropped++;
595 		return;
596 	}
597 
598 	if (flush_buffer(f)) {
599 		packets_dropped++;
600 		return;
601 	}
602 
603 	if (len > bufleft) {
604 		dump_packet_nobuf(user, h, sp);
605 		return;
606 	}
607 
608  append:
609 #ifdef __FreeBSD__
610 	sh.ts.tv_sec = (bpf_int32)h->ts.tv_sec;
611 	sh.ts.tv_usec = (bpf_int32)h->ts.tv_usec;
612 	sh.caplen = h->caplen;
613 	sh.len = h->len;
614 
615 	memcpy(bufpos, &sh, sizeof(sh));
616 	memcpy(bufpos + sizeof(sh), sp, h->caplen);
617 #else
618 	memcpy(bufpos, h, sizeof(*h));
619 	memcpy(bufpos + sizeof(*h), sp, h->caplen);
620 #endif
621 
622 	bufpos += len;
623 	bufleft -= len;
624 	bufpkt++;
625 
626 	return;
627 }
628 
629 void
630 log_pcap_stats(void)
631 {
632 	struct pcap_stat pstat;
633 	if (pcap_stats(hpcap, &pstat) < 0)
634 		logmsg(LOG_WARNING, "Reading stats: %s", pcap_geterr(hpcap));
635 	else
636 		logmsg(LOG_NOTICE,
637 			"%u packets received, %u/%u dropped (kernel/pflogd)",
638 			pstat.ps_recv, pstat.ps_drop, packets_dropped);
639 }
640 
641 int
642 main(int argc, char **argv)
643 {
644 	int ch, np, ret, Xflag = 0;
645 	pcap_handler phandler = dump_packet;
646 	const char *errstr = NULL;
647 	char *pidf = NULL;
648 
649 	ret = 0;
650 
651 	closefrom(STDERR_FILENO + 1);
652 
653 	while ((ch = getopt(argc, argv, "Dxd:f:i:p:s:")) != -1) {
654 		switch (ch) {
655 		case 'D':
656 			Debug = 1;
657 			break;
658 		case 'd':
659 			delay = strtonum(optarg, 5, 60*60, &errstr);
660 			if (errstr)
661 				usage();
662 			break;
663 		case 'f':
664 			filename = optarg;
665 			break;
666 		case 'i':
667 			interface = optarg;
668 			break;
669 		case 'p':
670 			pidf = optarg;
671 			break;
672 		case 's':
673 			snaplen = strtonum(optarg, 0, PFLOGD_MAXSNAPLEN,
674 			    &errstr);
675 			if (snaplen <= 0)
676 				snaplen = DEF_SNAPLEN;
677 			if (errstr)
678 				snaplen = PFLOGD_MAXSNAPLEN;
679 			break;
680 		case 'x':
681 			Xflag++;
682 			break;
683 		default:
684 			usage();
685 		}
686 
687 	}
688 
689 	log_debug = Debug;
690 	argc -= optind;
691 	argv += optind;
692 
693 	/* does interface exist */
694 	if (!if_exists(interface)) {
695 		warn("Failed to initialize: %s", interface);
696 		logmsg(LOG_ERR, "Failed to initialize: %s", interface);
697 		logmsg(LOG_ERR, "Exiting, init failure");
698 		exit(1);
699 	}
700 
701 	if (!Debug) {
702 		openlog("pflogd", LOG_PID | LOG_CONS, LOG_DAEMON);
703 		if (daemon(0, 0)) {
704 			logmsg(LOG_WARNING, "Failed to become daemon: %s",
705 			    strerror(errno));
706 		}
707 		pidfile(pidf);
708 	}
709 
710 	tzset();
711 	(void)umask(S_IRWXG | S_IRWXO);
712 
713 	/* filter will be used by the privileged process */
714 	if (argc) {
715 		filter = copy_argv(argv);
716 		if (filter == NULL)
717 			logmsg(LOG_NOTICE, "Failed to form filter expression");
718 	}
719 
720 	/* initialize pcap before dropping privileges */
721 	if (init_pcap()) {
722 		logmsg(LOG_ERR, "Exiting, init failure");
723 		exit(1);
724 	}
725 
726 	/* Privilege separation begins here */
727 	if (priv_init()) {
728 		logmsg(LOG_ERR, "unable to privsep");
729 		exit(1);
730 	}
731 
732 	setproctitle("[initializing]");
733 	/* Process is now unprivileged and inside a chroot */
734 	signal(SIGTERM, sig_close);
735 	signal(SIGINT, sig_close);
736 	signal(SIGQUIT, sig_close);
737 	signal(SIGALRM, sig_alrm);
738 	signal(SIGUSR1, sig_usr1);
739 	signal(SIGHUP, sig_hup);
740 	alarm(delay);
741 
742 	buffer = malloc(PFLOGD_BUFSIZE);
743 
744 	if (buffer == NULL) {
745 		logmsg(LOG_WARNING, "Failed to allocate output buffer");
746 		phandler = dump_packet_nobuf;
747 	} else {
748 		bufleft = buflen = PFLOGD_BUFSIZE;
749 		bufpos = buffer;
750 		bufpkt = 0;
751 	}
752 
753 	if (reset_dump(Xflag) < 0) {
754 		if (Xflag)
755 			return (1);
756 
757 		logmsg(LOG_ERR, "Logging suspended: open error");
758 		set_suspended(1);
759 	} else if (Xflag)
760 		return (0);
761 
762 	while (1) {
763 		np = pcap_dispatch(hpcap, PCAP_NUM_PKTS,
764 		    phandler, (u_char *)dpcap);
765 		if (np < 0) {
766 			if (!if_exists(interface)) {
767 				logmsg(LOG_NOTICE, "interface %s went away",
768 				    interface);
769 				ret = -1;
770 				break;
771 			}
772 			logmsg(LOG_NOTICE, "%s", pcap_geterr(hpcap));
773 		}
774 
775 		if (gotsig_close)
776 			break;
777 		if (gotsig_hup) {
778 			if (reset_dump(0)) {
779 				logmsg(LOG_ERR,
780 				    "Logging suspended: open error");
781 				set_suspended(1);
782 			}
783 			gotsig_hup = 0;
784 		}
785 
786 		if (gotsig_alrm) {
787 			if (dpcap)
788 				flush_buffer(dpcap);
789 			else
790 				gotsig_hup = 1;
791 			gotsig_alrm = 0;
792 			alarm(delay);
793 		}
794 
795 		if (gotsig_usr1) {
796 			log_pcap_stats();
797 			gotsig_usr1 = 0;
798 		}
799 	}
800 
801 	logmsg(LOG_NOTICE, "Exiting");
802 	if (dpcap) {
803 		flush_buffer(dpcap);
804 		fclose(dpcap);
805 	}
806 	purge_buffer();
807 
808 	log_pcap_stats();
809 	pcap_close(hpcap);
810 	if (!Debug)
811 		closelog();
812 	return (ret);
813 }
814