xref: /freebsd/contrib/pf/pflogd/pflogd.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463) 
1 /*	$OpenBSD: pflogd.c,v 1.37 2006/10/26 13:34:47 jmc 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/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include <sys/types.h>
37 #include <sys/ioctl.h>
38 #include <sys/file.h>
39 #include <sys/stat.h>
40 #ifdef __FreeBSD__
41 #include <net/bpf.h>	/* BIOCLOCK */
42 #endif
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <pcap-int.h>
48 #include <pcap.h>
49 #include <syslog.h>
50 #include <signal.h>
51 #include <errno.h>
52 #include <stdarg.h>
53 #include <fcntl.h>
54 #ifdef __FreeBSD__
55 #include "pidfile.h"
56 #else
57 #include <util.h>
58 #endif
59 
60 #include "pflogd.h"
61 
62 pcap_t *hpcap;
63 static FILE *dpcap;
64 
65 int Debug = 0;
66 static int snaplen = DEF_SNAPLEN;
67 static int cur_snaplen = DEF_SNAPLEN;
68 
69 volatile sig_atomic_t gotsig_close, gotsig_alrm, gotsig_hup;
70 
71 char *filename = PFLOGD_LOG_FILE;
72 char *interface = PFLOGD_DEFAULT_IF;
73 char *filter = NULL;
74 
75 char errbuf[PCAP_ERRBUF_SIZE];
76 
77 int log_debug = 0;
78 unsigned int delay = FLUSH_DELAY;
79 
80 char *copy_argv(char * const *);
81 void  dump_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
82 void  dump_packet_nobuf(u_char *, const struct pcap_pkthdr *, const u_char *);
83 int   flush_buffer(FILE *);
84 int   init_pcap(void);
85 void  logmsg(int, const char *, ...);
86 void  purge_buffer(void);
87 int   reset_dump(int);
88 int   scan_dump(FILE *, off_t);
89 int   set_snaplen(int);
90 void  set_suspended(int);
91 void  sig_alrm(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] [-s snaplen]\n");
170 	fprintf(stderr, "              [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 set_pcap_filter(void)
194 {
195 	struct bpf_program bprog;
196 
197 	if (pcap_compile(hpcap, &bprog, filter, PCAP_OPT_FIL, 0) < 0)
198 		logmsg(LOG_WARNING, "%s", pcap_geterr(hpcap));
199 	else {
200 		if (pcap_setfilter(hpcap, &bprog) < 0)
201 			logmsg(LOG_WARNING, "%s", pcap_geterr(hpcap));
202 		pcap_freecode(&bprog);
203 	}
204 }
205 
206 int
207 init_pcap(void)
208 {
209 	hpcap = pcap_open_live(interface, snaplen, 1, PCAP_TO_MS, errbuf);
210 	if (hpcap == NULL) {
211 		logmsg(LOG_ERR, "Failed to initialize: %s", errbuf);
212 		return (-1);
213 	}
214 
215 	if (pcap_datalink(hpcap) != DLT_PFLOG) {
216 		logmsg(LOG_ERR, "Invalid datalink type");
217 		pcap_close(hpcap);
218 		hpcap = NULL;
219 		return (-1);
220 	}
221 
222 	set_pcap_filter();
223 
224 	cur_snaplen = snaplen = pcap_snapshot(hpcap);
225 
226 	/* lock */
227 	if (ioctl(pcap_fileno(hpcap), BIOCLOCK) < 0) {
228 		logmsg(LOG_ERR, "BIOCLOCK: %s", strerror(errno));
229 		return (-1);
230 	}
231 
232 	return (0);
233 }
234 
235 int
236 set_snaplen(int snap)
237 {
238 	if (priv_set_snaplen(snap))
239 		return (1);
240 
241 	if (cur_snaplen > snap)
242 		purge_buffer();
243 
244 	cur_snaplen = snap;
245 
246 	return (0);
247 }
248 
249 int
250 reset_dump(int nomove)
251 {
252 	int ret;
253 
254 	for (;;) {
255 		ret = try_reset_dump(nomove);
256 		if (ret <= 0)
257 			break;
258 	}
259 
260 	return (ret);
261 }
262 
263 /*
264  * tries to (re)open log file, nomove flag is used with -x switch
265  * returns 0: success, 1: retry (log moved), -1: error
266  */
267 int
268 try_reset_dump(int nomove)
269 {
270 	struct pcap_file_header hdr;
271 	struct stat st;
272 	int fd;
273 	FILE *fp;
274 
275 	if (hpcap == NULL)
276 		return (-1);
277 
278 	if (dpcap) {
279 		flush_buffer(dpcap);
280 		fclose(dpcap);
281 		dpcap = NULL;
282 	}
283 
284 	/*
285 	 * Basically reimplement pcap_dump_open() because it truncates
286 	 * files and duplicates headers and such.
287 	 */
288 	fd = priv_open_log();
289 	if (fd < 0)
290 		return (-1);
291 
292 	fp = fdopen(fd, "a+");
293 
294 	if (fp == NULL) {
295 		logmsg(LOG_ERR, "Error: %s: %s", filename, strerror(errno));
296 		close(fd);
297 		return (-1);
298 	}
299 	if (fstat(fileno(fp), &st) == -1) {
300 		logmsg(LOG_ERR, "Error: %s: %s", filename, strerror(errno));
301 		fclose(fp);
302 		return (-1);
303 	}
304 
305 	/* set FILE unbuffered, we do our own buffering */
306 	if (setvbuf(fp, NULL, _IONBF, 0)) {
307 		logmsg(LOG_ERR, "Failed to set output buffers");
308 		fclose(fp);
309 		return (-1);
310 	}
311 
312 #define TCPDUMP_MAGIC 0xa1b2c3d4
313 
314 	if (st.st_size == 0) {
315 		if (snaplen != cur_snaplen) {
316 			logmsg(LOG_NOTICE, "Using snaplen %d", snaplen);
317 			if (set_snaplen(snaplen))
318 				logmsg(LOG_WARNING,
319 				    "Failed, using old settings");
320 		}
321 		hdr.magic = TCPDUMP_MAGIC;
322 		hdr.version_major = PCAP_VERSION_MAJOR;
323 		hdr.version_minor = PCAP_VERSION_MINOR;
324 		hdr.thiszone = hpcap->tzoff;
325 		hdr.snaplen = hpcap->snapshot;
326 		hdr.sigfigs = 0;
327 		hdr.linktype = hpcap->linktype;
328 
329 		if (fwrite((char *)&hdr, sizeof(hdr), 1, fp) != 1) {
330 			fclose(fp);
331 			return (-1);
332 		}
333 	} else if (scan_dump(fp, st.st_size)) {
334 		fclose(fp);
335 		if (nomove || priv_move_log()) {
336 			logmsg(LOG_ERR,
337 			    "Invalid/incompatible log file, move it away");
338 			return (-1);
339 		}
340 		return (1);
341 	}
342 
343 	dpcap = fp;
344 
345 	set_suspended(0);
346 	flush_buffer(fp);
347 
348 	return (0);
349 }
350 
351 int
352 scan_dump(FILE *fp, off_t size)
353 {
354 	struct pcap_file_header hdr;
355 #ifdef __FreeBSD__
356 	struct pcap_sf_pkthdr ph;
357 #else
358 	struct pcap_pkthdr ph;
359 #endif
360 	off_t pos;
361 
362 	/*
363 	 * Must read the file, compare the header against our new
364 	 * options (in particular, snaplen) and adjust our options so
365 	 * that we generate a correct file. Furthermore, check the file
366 	 * for consistency so that we can append safely.
367 	 *
368 	 * XXX this may take a long time for large logs.
369 	 */
370 	(void) fseek(fp, 0L, SEEK_SET);
371 
372 	if (fread((char *)&hdr, sizeof(hdr), 1, fp) != 1) {
373 		logmsg(LOG_ERR, "Short file header");
374 		return (1);
375 	}
376 
377 	if (hdr.magic != TCPDUMP_MAGIC ||
378 	    hdr.version_major != PCAP_VERSION_MAJOR ||
379 	    hdr.version_minor != PCAP_VERSION_MINOR ||
380 	    hdr.linktype != hpcap->linktype ||
381 	    hdr.snaplen > PFLOGD_MAXSNAPLEN) {
382 		return (1);
383 	}
384 
385 	pos = sizeof(hdr);
386 
387 	while (!feof(fp)) {
388 		off_t len = fread((char *)&ph, 1, sizeof(ph), fp);
389 		if (len == 0)
390 			break;
391 
392 		if (len != sizeof(ph))
393 			goto error;
394 		if (ph.caplen > hdr.snaplen || ph.caplen > PFLOGD_MAXSNAPLEN)
395 			goto error;
396 		pos += sizeof(ph) + ph.caplen;
397 		if (pos > size)
398 			goto error;
399 		fseek(fp, ph.caplen, SEEK_CUR);
400 	}
401 
402 	if (pos != size)
403 		goto error;
404 
405 	if (hdr.snaplen != cur_snaplen) {
406 		logmsg(LOG_WARNING,
407 		       "Existing file has different snaplen %u, using it",
408 		       hdr.snaplen);
409 		if (set_snaplen(hdr.snaplen)) {
410 			logmsg(LOG_WARNING,
411 			       "Failed, using old settings, offset %llu",
412 			       (unsigned long long) size);
413 		}
414 	}
415 
416 	return (0);
417 
418  error:
419 	logmsg(LOG_ERR, "Corrupted log file.");
420 	return (1);
421 }
422 
423 /* dump a packet directly to the stream, which is unbuffered */
424 void
425 dump_packet_nobuf(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
426 {
427 	FILE *f = (FILE *)user;
428 #ifdef __FreeBSD__
429 	struct pcap_sf_pkthdr sh;
430 #endif
431 
432 	if (suspended) {
433 		packets_dropped++;
434 		return;
435 	}
436 
437 #ifdef __FreeBSD__
438 	sh.ts.tv_sec = (bpf_int32)h->ts.tv_sec;
439 	sh.ts.tv_usec = (bpf_int32)h->ts.tv_usec;
440 	sh.caplen = h->caplen;
441 	sh.len = h->len;
442 
443 	if (fwrite((char *)&sh, sizeof(sh), 1, f) != 1) {
444 #else
445 	if (fwrite((char *)h, sizeof(*h), 1, f) != 1) {
446 #endif
447 		off_t pos = ftello(f);
448 
449 		/* try to undo header to prevent corruption */
450 #ifdef __FreeBSD__
451 		if (pos < sizeof(sh) ||
452 		    ftruncate(fileno(f), pos - sizeof(sh))) {
453 #else
454 		if (pos < sizeof(*h) ||
455 		    ftruncate(fileno(f), pos - sizeof(*h))) {
456 #endif
457 			logmsg(LOG_ERR, "Write failed, corrupted logfile!");
458 			set_suspended(1);
459 			gotsig_close = 1;
460 			return;
461 		}
462 		goto error;
463 	}
464 
465 	if (fwrite((char *)sp, h->caplen, 1, f) != 1)
466 		goto error;
467 
468 	return;
469 
470 error:
471 	set_suspended(1);
472 	packets_dropped ++;
473 	logmsg(LOG_ERR, "Logging suspended: fwrite: %s", strerror(errno));
474 }
475 
476 int
477 flush_buffer(FILE *f)
478 {
479 	off_t offset;
480 	int len = bufpos - buffer;
481 
482 	if (len <= 0)
483 		return (0);
484 
485 	offset = ftello(f);
486 	if (offset == (off_t)-1) {
487 		set_suspended(1);
488 		logmsg(LOG_ERR, "Logging suspended: ftello: %s",
489 		    strerror(errno));
490 		return (1);
491 	}
492 
493 	if (fwrite(buffer, len, 1, f) != 1) {
494 		set_suspended(1);
495 		logmsg(LOG_ERR, "Logging suspended: fwrite: %s",
496 		    strerror(errno));
497 		ftruncate(fileno(f), offset);
498 		return (1);
499 	}
500 
501 	set_suspended(0);
502 	bufpos = buffer;
503 	bufleft = buflen;
504 	bufpkt = 0;
505 
506 	return (0);
507 }
508 
509 void
510 purge_buffer(void)
511 {
512 	packets_dropped += bufpkt;
513 
514 	set_suspended(0);
515 	bufpos = buffer;
516 	bufleft = buflen;
517 	bufpkt = 0;
518 }
519 
520 /* append packet to the buffer, flushing if necessary */
521 void
522 dump_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
523 {
524 	FILE *f = (FILE *)user;
525 #ifdef __FreeBSD__
526 	struct pcap_sf_pkthdr sh;
527 	size_t len = sizeof(sh) + h->caplen;
528 #else
529 	size_t len = sizeof(*h) + h->caplen;
530 #endif
531 
532 	if (len < sizeof(*h) || h->caplen > (size_t)cur_snaplen) {
533 		logmsg(LOG_NOTICE, "invalid size %u (%u/%u), packet dropped",
534 		       len, cur_snaplen, snaplen);
535 		packets_dropped++;
536 		return;
537 	}
538 
539 	if (len <= bufleft)
540 		goto append;
541 
542 	if (suspended) {
543 		packets_dropped++;
544 		return;
545 	}
546 
547 	if (flush_buffer(f)) {
548 		packets_dropped++;
549 		return;
550 	}
551 
552 	if (len > bufleft) {
553 		dump_packet_nobuf(user, h, sp);
554 		return;
555 	}
556 
557  append:
558 #ifdef __FreeBSD__
559  	sh.ts.tv_sec = (bpf_int32)h->ts.tv_sec;
560  	sh.ts.tv_usec = (bpf_int32)h->ts.tv_usec;
561 	sh.caplen = h->caplen;
562 	sh.len = h->len;
563 
564 	memcpy(bufpos, &sh, sizeof(sh));
565 	memcpy(bufpos + sizeof(sh), sp, h->caplen);
566 #else
567 	memcpy(bufpos, h, sizeof(*h));
568 	memcpy(bufpos + sizeof(*h), sp, h->caplen);
569 #endif
570 
571 	bufpos += len;
572 	bufleft -= len;
573 	bufpkt++;
574 
575 	return;
576 }
577 
578 int
579 main(int argc, char **argv)
580 {
581 	struct pcap_stat pstat;
582 	int ch, np, Xflag = 0;
583 	pcap_handler phandler = dump_packet;
584 	const char *errstr = NULL;
585 
586 #ifdef __FreeBSD__
587 	/* another ?paranoid? safety measure we do not have */
588 #else
589 	closefrom(STDERR_FILENO + 1);
590 #endif
591 
592 	while ((ch = getopt(argc, argv, "Dxd:f:i:s:")) != -1) {
593 		switch (ch) {
594 		case 'D':
595 			Debug = 1;
596 			break;
597 		case 'd':
598 			delay = strtonum(optarg, 5, 60*60, &errstr);
599 			if (errstr)
600 				usage();
601 			break;
602 		case 'f':
603 			filename = optarg;
604 			break;
605 		case 'i':
606 			interface = optarg;
607 			break;
608 		case 's':
609 			snaplen = strtonum(optarg, 0, PFLOGD_MAXSNAPLEN,
610 			    &errstr);
611 			if (snaplen <= 0)
612 				snaplen = DEF_SNAPLEN;
613 			if (errstr)
614 				snaplen = PFLOGD_MAXSNAPLEN;
615 			break;
616 		case 'x':
617 			Xflag++;
618 			break;
619 		default:
620 			usage();
621 		}
622 
623 	}
624 
625 	log_debug = Debug;
626 	argc -= optind;
627 	argv += optind;
628 
629 	if (!Debug) {
630 		openlog("pflogd", LOG_PID | LOG_CONS, LOG_DAEMON);
631 		if (daemon(0, 0)) {
632 			logmsg(LOG_WARNING, "Failed to become daemon: %s",
633 			    strerror(errno));
634 		}
635 		pidfile(NULL);
636 	}
637 
638 	tzset();
639 	(void)umask(S_IRWXG | S_IRWXO);
640 
641 	/* filter will be used by the privileged process */
642 	if (argc) {
643 		filter = copy_argv(argv);
644 		if (filter == NULL)
645 			logmsg(LOG_NOTICE, "Failed to form filter expression");
646 	}
647 
648 	/* initialize pcap before dropping privileges */
649 	if (init_pcap()) {
650 		logmsg(LOG_ERR, "Exiting, init failure");
651 		exit(1);
652 	}
653 
654 	/* Privilege separation begins here */
655 	if (priv_init()) {
656 		logmsg(LOG_ERR, "unable to privsep");
657 		exit(1);
658 	}
659 
660 	setproctitle("[initializing]");
661 	/* Process is now unprivileged and inside a chroot */
662 	signal(SIGTERM, sig_close);
663 	signal(SIGINT, sig_close);
664 	signal(SIGQUIT, sig_close);
665 	signal(SIGALRM, sig_alrm);
666 	signal(SIGHUP, sig_hup);
667 	alarm(delay);
668 
669 	buffer = malloc(PFLOGD_BUFSIZE);
670 
671 	if (buffer == NULL) {
672 		logmsg(LOG_WARNING, "Failed to allocate output buffer");
673 		phandler = dump_packet_nobuf;
674 	} else {
675 		bufleft = buflen = PFLOGD_BUFSIZE;
676 		bufpos = buffer;
677 		bufpkt = 0;
678 	}
679 
680 	if (reset_dump(Xflag) < 0) {
681 		if (Xflag)
682 			return (1);
683 
684 		logmsg(LOG_ERR, "Logging suspended: open error");
685 		set_suspended(1);
686 	} else if (Xflag)
687 		return (0);
688 
689 	while (1) {
690 		np = pcap_dispatch(hpcap, PCAP_NUM_PKTS,
691 		    phandler, (u_char *)dpcap);
692 		if (np < 0) {
693 #ifdef __FreeBSD__
694 			if (errno == ENXIO) {
695 				logmsg(LOG_ERR,
696 				    "Device not/no longer configured");
697 				break;
698 			}
699 #endif
700 			logmsg(LOG_NOTICE, "%s", pcap_geterr(hpcap));
701 		}
702 
703 		if (gotsig_close)
704 			break;
705 		if (gotsig_hup) {
706 			if (reset_dump(0)) {
707 				logmsg(LOG_ERR,
708 				    "Logging suspended: open error");
709 				set_suspended(1);
710 			}
711 			gotsig_hup = 0;
712 		}
713 
714 		if (gotsig_alrm) {
715 			if (dpcap)
716 				flush_buffer(dpcap);
717 			else
718 				gotsig_hup = 1;
719 			gotsig_alrm = 0;
720 			alarm(delay);
721 		}
722 	}
723 
724 	logmsg(LOG_NOTICE, "Exiting");
725 	if (dpcap) {
726 		flush_buffer(dpcap);
727 		fclose(dpcap);
728 	}
729 	purge_buffer();
730 
731 	if (pcap_stats(hpcap, &pstat) < 0)
732 		logmsg(LOG_WARNING, "Reading stats: %s", pcap_geterr(hpcap));
733 	else
734 		logmsg(LOG_NOTICE,
735 		    "%u packets received, %u/%u dropped (kernel/pflogd)",
736 		    pstat.ps_recv, pstat.ps_drop, packets_dropped);
737 
738 	pcap_close(hpcap);
739 	if (!Debug)
740 		closelog();
741 	return (0);
742 }
743