xref: /freebsd/sbin/pfctl/pfctl.c (revision 1e4c802913af619ac15741bbd276e1141ca17dc9)
1 /*	$OpenBSD: pfctl.c,v 1.278 2008/08/31 20:18:17 jmc Exp $ */
2 
3 /*-
4  * SPDX-License-Identifier: BSD-2-Clause
5  *
6  * Copyright (c) 2001 Daniel Hartmeier
7  * Copyright (c) 2002,2003 Henning Brauer
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  *    - Redistributions of source code must retain the above copyright
15  *      notice, this list of conditions and the following disclaimer.
16  *    - Redistributions in binary form must reproduce the above
17  *      copyright notice, this list of conditions and the following
18  *      disclaimer in the documentation and/or other materials provided
19  *      with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  */
35 
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 
39 #define PFIOC_USE_LATEST
40 
41 #include <sys/types.h>
42 #include <sys/ioctl.h>
43 #include <sys/nv.h>
44 #include <sys/socket.h>
45 #include <sys/stat.h>
46 #include <sys/endian.h>
47 
48 #include <net/if.h>
49 #include <netinet/in.h>
50 #include <net/pfvar.h>
51 #include <arpa/inet.h>
52 #include <net/altq/altq.h>
53 #include <sys/sysctl.h>
54 
55 #include <err.h>
56 #include <errno.h>
57 #include <fcntl.h>
58 #include <libpfctl.h>
59 #include <limits.h>
60 #include <netdb.h>
61 #include <stdint.h>
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <unistd.h>
66 
67 #include "pfctl_parser.h"
68 #include "pfctl.h"
69 
70 void	 usage(void);
71 int	 pfctl_enable(int, int);
72 int	 pfctl_disable(int, int);
73 int	 pfctl_clear_stats(int, int);
74 int	 pfctl_get_skip_ifaces(void);
75 int	 pfctl_check_skip_ifaces(char *);
76 int	 pfctl_adjust_skip_ifaces(struct pfctl *);
77 int	 pfctl_clear_interface_flags(int, int);
78 int	 pfctl_clear_rules(int, int, char *);
79 int	 pfctl_clear_nat(int, int, char *);
80 int	 pfctl_clear_altq(int, int);
81 int	 pfctl_clear_src_nodes(int, int);
82 int	 pfctl_clear_iface_states(int, const char *, int);
83 void	 pfctl_addrprefix(char *, struct pf_addr *);
84 int	 pfctl_kill_src_nodes(int, const char *, int);
85 int	 pfctl_net_kill_states(int, const char *, int);
86 int	 pfctl_gateway_kill_states(int, const char *, int);
87 int	 pfctl_label_kill_states(int, const char *, int);
88 int	 pfctl_id_kill_states(int, const char *, int);
89 void	 pfctl_init_options(struct pfctl *);
90 int	 pfctl_load_options(struct pfctl *);
91 int	 pfctl_load_limit(struct pfctl *, unsigned int, unsigned int);
92 int	 pfctl_load_timeout(struct pfctl *, unsigned int, unsigned int);
93 int	 pfctl_load_debug(struct pfctl *, unsigned int);
94 int	 pfctl_load_logif(struct pfctl *, char *);
95 int	 pfctl_load_hostid(struct pfctl *, u_int32_t);
96 int	 pfctl_load_syncookies(struct pfctl *, u_int8_t);
97 int	 pfctl_get_pool(int, struct pfctl_pool *, u_int32_t, u_int32_t, int,
98 	    char *);
99 void	 pfctl_print_rule_counters(struct pfctl_rule *, int);
100 int	 pfctl_show_rules(int, char *, int, enum pfctl_show, char *, int);
101 int	 pfctl_show_nat(int, int, char *);
102 int	 pfctl_show_src_nodes(int, int);
103 int	 pfctl_show_states(int, const char *, int);
104 int	 pfctl_show_status(int, int);
105 int	 pfctl_show_running(int);
106 int	 pfctl_show_timeouts(int, int);
107 int	 pfctl_show_limits(int, int);
108 void	 pfctl_debug(int, u_int32_t, int);
109 int	 pfctl_test_altqsupport(int, int);
110 int	 pfctl_show_anchors(int, int, char *);
111 int	 pfctl_ruleset_trans(struct pfctl *, char *, struct pfctl_anchor *);
112 int	 pfctl_load_ruleset(struct pfctl *, char *,
113 		struct pfctl_ruleset *, int, int);
114 int	 pfctl_load_rule(struct pfctl *, char *, struct pfctl_rule *, int);
115 const char	*pfctl_lookup_option(char *, const char * const *);
116 
117 static struct pfctl_anchor_global	 pf_anchors;
118 static struct pfctl_anchor	 pf_main_anchor;
119 static struct pfr_buffer skip_b;
120 
121 static const char	*clearopt;
122 static char		*rulesopt;
123 static const char	*showopt;
124 static const char	*debugopt;
125 static char		*anchoropt;
126 static const char	*optiopt = NULL;
127 static const char	*pf_device = "/dev/pf";
128 static char		*ifaceopt;
129 static char		*tableopt;
130 static const char	*tblcmdopt;
131 static int		 src_node_killers;
132 static char		*src_node_kill[2];
133 static int		 state_killers;
134 static char		*state_kill[2];
135 int			 loadopt;
136 int			 altqsupport;
137 
138 int			 dev = -1;
139 static int		 first_title = 1;
140 static int		 labels = 0;
141 
142 #define INDENT(d, o)	do {						\
143 				if (o) {				\
144 					int i;				\
145 					for (i=0; i < d; i++)		\
146 						printf("  ");		\
147 				}					\
148 			} while (0);					\
149 
150 
151 static const struct {
152 	const char	*name;
153 	int		index;
154 } pf_limits[] = {
155 	{ "states",		PF_LIMIT_STATES },
156 	{ "src-nodes",		PF_LIMIT_SRC_NODES },
157 	{ "frags",		PF_LIMIT_FRAGS },
158 	{ "table-entries",	PF_LIMIT_TABLE_ENTRIES },
159 	{ NULL,			0 }
160 };
161 
162 struct pf_hint {
163 	const char	*name;
164 	int		timeout;
165 };
166 static const struct pf_hint pf_hint_normal[] = {
167 	{ "tcp.first",		2 * 60 },
168 	{ "tcp.opening",	30 },
169 	{ "tcp.established",	24 * 60 * 60 },
170 	{ "tcp.closing",	15 * 60 },
171 	{ "tcp.finwait",	45 },
172 	{ "tcp.closed",		90 },
173 	{ "tcp.tsdiff",		30 },
174 	{ NULL,			0 }
175 };
176 static const struct pf_hint pf_hint_satellite[] = {
177 	{ "tcp.first",		3 * 60 },
178 	{ "tcp.opening",	30 + 5 },
179 	{ "tcp.established",	24 * 60 * 60 },
180 	{ "tcp.closing",	15 * 60 + 5 },
181 	{ "tcp.finwait",	45 + 5 },
182 	{ "tcp.closed",		90 + 5 },
183 	{ "tcp.tsdiff",		60 },
184 	{ NULL,			0 }
185 };
186 static const struct pf_hint pf_hint_conservative[] = {
187 	{ "tcp.first",		60 * 60 },
188 	{ "tcp.opening",	15 * 60 },
189 	{ "tcp.established",	5 * 24 * 60 * 60 },
190 	{ "tcp.closing",	60 * 60 },
191 	{ "tcp.finwait",	10 * 60 },
192 	{ "tcp.closed",		3 * 60 },
193 	{ "tcp.tsdiff",		60 },
194 	{ NULL,			0 }
195 };
196 static const struct pf_hint pf_hint_aggressive[] = {
197 	{ "tcp.first",		30 },
198 	{ "tcp.opening",	5 },
199 	{ "tcp.established",	5 * 60 * 60 },
200 	{ "tcp.closing",	60 },
201 	{ "tcp.finwait",	30 },
202 	{ "tcp.closed",		30 },
203 	{ "tcp.tsdiff",		10 },
204 	{ NULL,			0 }
205 };
206 
207 static const struct {
208 	const char *name;
209 	const struct pf_hint *hint;
210 } pf_hints[] = {
211 	{ "normal",		pf_hint_normal },
212 	{ "satellite",		pf_hint_satellite },
213 	{ "high-latency",	pf_hint_satellite },
214 	{ "conservative",	pf_hint_conservative },
215 	{ "aggressive",		pf_hint_aggressive },
216 	{ NULL,			NULL }
217 };
218 
219 static const char * const clearopt_list[] = {
220 	"nat", "queue", "rules", "Sources",
221 	"states", "info", "Tables", "osfp", "all", NULL
222 };
223 
224 static const char * const showopt_list[] = {
225 	"nat", "queue", "rules", "Anchors", "Sources", "states", "info",
226 	"Interfaces", "labels", "timeouts", "memory", "Tables", "osfp",
227 	"Running", "all", NULL
228 };
229 
230 static const char * const tblcmdopt_list[] = {
231 	"kill", "flush", "add", "delete", "load", "replace", "show",
232 	"test", "zero", "expire", NULL
233 };
234 
235 static const char * const debugopt_list[] = {
236 	"none", "urgent", "misc", "loud", NULL
237 };
238 
239 static const char * const optiopt_list[] = {
240 	"none", "basic", "profile", NULL
241 };
242 
243 void
244 usage(void)
245 {
246 	extern char *__progname;
247 
248 	fprintf(stderr,
249 "usage: %s [-AdeghMmNnOPqRrvz] [-a anchor] [-D macro=value] [-F modifier]\n"
250 	"\t[-f file] [-i interface] [-K host | network]\n"
251 	"\t[-k host | network | gateway | label | id] [-o level] [-p device]\n"
252 	"\t[-s modifier] [-t table -T command [address ...]] [-x level]\n",
253 	    __progname);
254 
255 	exit(1);
256 }
257 
258 /*
259  * Cache protocol number to name translations.
260  *
261  * Translation is performed a lot e.g., when dumping states and
262  * getprotobynumber is incredibly expensive.
263  *
264  * Note from the getprotobynumber(3) manpage:
265  * <quote>
266  * These functions use a thread-specific data space; if the data is needed
267  * for future use, it should be copied before any subsequent calls overwrite
268  * it.  Only the Internet protocols are currently understood.
269  * </quote>
270  *
271  * Consequently we only cache the name and strdup it for safety.
272  *
273  * At the time of writing this comment the last entry in /etc/protocols is:
274  * divert  258     DIVERT          # Divert pseudo-protocol [non IANA]
275  */
276 const char *
277 pfctl_proto2name(int proto)
278 {
279 	static const char *pfctl_proto_cache[259];
280 	struct protoent *p;
281 
282 	if (proto >= nitems(pfctl_proto_cache)) {
283 		p = getprotobynumber(proto);
284 		if (p == NULL) {
285 			return (NULL);
286 		}
287 		return (p->p_name);
288 	}
289 
290 	if (pfctl_proto_cache[proto] == NULL) {
291 		p = getprotobynumber(proto);
292 		if (p == NULL) {
293 			return (NULL);
294 		}
295 		pfctl_proto_cache[proto] = strdup(p->p_name);
296 	}
297 
298 	return (pfctl_proto_cache[proto]);
299 }
300 
301 int
302 pfctl_enable(int dev, int opts)
303 {
304 	if (ioctl(dev, DIOCSTART)) {
305 		if (errno == EEXIST)
306 			errx(1, "pf already enabled");
307 		else if (errno == ESRCH)
308 			errx(1, "pfil registeration failed");
309 		else
310 			err(1, "DIOCSTART");
311 	}
312 	if ((opts & PF_OPT_QUIET) == 0)
313 		fprintf(stderr, "pf enabled\n");
314 
315 	if (altqsupport && ioctl(dev, DIOCSTARTALTQ))
316 		if (errno != EEXIST)
317 			err(1, "DIOCSTARTALTQ");
318 
319 	return (0);
320 }
321 
322 int
323 pfctl_disable(int dev, int opts)
324 {
325 	if (ioctl(dev, DIOCSTOP)) {
326 		if (errno == ENOENT)
327 			errx(1, "pf not enabled");
328 		else
329 			err(1, "DIOCSTOP");
330 	}
331 	if ((opts & PF_OPT_QUIET) == 0)
332 		fprintf(stderr, "pf disabled\n");
333 
334 	if (altqsupport && ioctl(dev, DIOCSTOPALTQ))
335 			if (errno != ENOENT)
336 				err(1, "DIOCSTOPALTQ");
337 
338 	return (0);
339 }
340 
341 int
342 pfctl_clear_stats(int dev, int opts)
343 {
344 	if (ioctl(dev, DIOCCLRSTATUS))
345 		err(1, "DIOCCLRSTATUS");
346 	if ((opts & PF_OPT_QUIET) == 0)
347 		fprintf(stderr, "pf: statistics cleared\n");
348 	return (0);
349 }
350 
351 int
352 pfctl_get_skip_ifaces(void)
353 {
354 	bzero(&skip_b, sizeof(skip_b));
355 	skip_b.pfrb_type = PFRB_IFACES;
356 	for (;;) {
357 		pfr_buf_grow(&skip_b, skip_b.pfrb_size);
358 		skip_b.pfrb_size = skip_b.pfrb_msize;
359 		if (pfi_get_ifaces(NULL, skip_b.pfrb_caddr, &skip_b.pfrb_size))
360 			err(1, "pfi_get_ifaces");
361 		if (skip_b.pfrb_size <= skip_b.pfrb_msize)
362 			break;
363 	}
364 	return (0);
365 }
366 
367 int
368 pfctl_check_skip_ifaces(char *ifname)
369 {
370 	struct pfi_kif		*p;
371 	struct node_host	*h = NULL, *n = NULL;
372 
373 	PFRB_FOREACH(p, &skip_b) {
374 		if (!strcmp(ifname, p->pfik_name) &&
375 		    (p->pfik_flags & PFI_IFLAG_SKIP))
376 			p->pfik_flags &= ~PFI_IFLAG_SKIP;
377 		if (!strcmp(ifname, p->pfik_name) && p->pfik_group != NULL) {
378 			if ((h = ifa_grouplookup(p->pfik_name, 0)) == NULL)
379 				continue;
380 
381 			for (n = h; n != NULL; n = n->next) {
382 				if (p->pfik_ifp == NULL)
383 					continue;
384 				if (strncmp(p->pfik_name, ifname, IFNAMSIZ))
385 					continue;
386 
387 				p->pfik_flags &= ~PFI_IFLAG_SKIP;
388 			}
389 		}
390 	}
391 	return (0);
392 }
393 
394 int
395 pfctl_adjust_skip_ifaces(struct pfctl *pf)
396 {
397 	struct pfi_kif		*p, *pp;
398 	struct node_host	*h = NULL, *n = NULL;
399 
400 	PFRB_FOREACH(p, &skip_b) {
401 		if (p->pfik_group == NULL || !(p->pfik_flags & PFI_IFLAG_SKIP))
402 			continue;
403 
404 		pfctl_set_interface_flags(pf, p->pfik_name, PFI_IFLAG_SKIP, 0);
405 		if ((h = ifa_grouplookup(p->pfik_name, 0)) == NULL)
406 			continue;
407 
408 		for (n = h; n != NULL; n = n->next)
409 			PFRB_FOREACH(pp, &skip_b) {
410 				if (pp->pfik_ifp == NULL)
411 					continue;
412 
413 				if (strncmp(pp->pfik_name, n->ifname, IFNAMSIZ))
414 					continue;
415 
416 				if (!(pp->pfik_flags & PFI_IFLAG_SKIP))
417 					pfctl_set_interface_flags(pf,
418 					    pp->pfik_name, PFI_IFLAG_SKIP, 1);
419 				if (pp->pfik_flags & PFI_IFLAG_SKIP)
420 					pp->pfik_flags &= ~PFI_IFLAG_SKIP;
421 			}
422 	}
423 
424 	PFRB_FOREACH(p, &skip_b) {
425 		if (p->pfik_ifp == NULL || ! (p->pfik_flags & PFI_IFLAG_SKIP))
426 			continue;
427 
428 		pfctl_set_interface_flags(pf, p->pfik_name, PFI_IFLAG_SKIP, 0);
429 	}
430 
431 	return (0);
432 }
433 
434 int
435 pfctl_clear_interface_flags(int dev, int opts)
436 {
437 	struct pfioc_iface	pi;
438 
439 	if ((opts & PF_OPT_NOACTION) == 0) {
440 		bzero(&pi, sizeof(pi));
441 		pi.pfiio_flags = PFI_IFLAG_SKIP;
442 
443 		if (ioctl(dev, DIOCCLRIFFLAG, &pi))
444 			err(1, "DIOCCLRIFFLAG");
445 		if ((opts & PF_OPT_QUIET) == 0)
446 			fprintf(stderr, "pf: interface flags reset\n");
447 	}
448 	return (0);
449 }
450 
451 int
452 pfctl_clear_rules(int dev, int opts, char *anchorname)
453 {
454 	struct pfr_buffer t;
455 
456 	memset(&t, 0, sizeof(t));
457 	t.pfrb_type = PFRB_TRANS;
458 	if (pfctl_add_trans(&t, PF_RULESET_SCRUB, anchorname) ||
459 	    pfctl_add_trans(&t, PF_RULESET_FILTER, anchorname) ||
460 	    pfctl_trans(dev, &t, DIOCXBEGIN, 0) ||
461 	    pfctl_trans(dev, &t, DIOCXCOMMIT, 0))
462 		err(1, "pfctl_clear_rules");
463 	if ((opts & PF_OPT_QUIET) == 0)
464 		fprintf(stderr, "rules cleared\n");
465 	return (0);
466 }
467 
468 int
469 pfctl_clear_nat(int dev, int opts, char *anchorname)
470 {
471 	struct pfr_buffer t;
472 
473 	memset(&t, 0, sizeof(t));
474 	t.pfrb_type = PFRB_TRANS;
475 	if (pfctl_add_trans(&t, PF_RULESET_NAT, anchorname) ||
476 	    pfctl_add_trans(&t, PF_RULESET_BINAT, anchorname) ||
477 	    pfctl_add_trans(&t, PF_RULESET_RDR, anchorname) ||
478 	    pfctl_trans(dev, &t, DIOCXBEGIN, 0) ||
479 	    pfctl_trans(dev, &t, DIOCXCOMMIT, 0))
480 		err(1, "pfctl_clear_nat");
481 	if ((opts & PF_OPT_QUIET) == 0)
482 		fprintf(stderr, "nat cleared\n");
483 	return (0);
484 }
485 
486 int
487 pfctl_clear_altq(int dev, int opts)
488 {
489 	struct pfr_buffer t;
490 
491 	if (!altqsupport)
492 		return (-1);
493 	memset(&t, 0, sizeof(t));
494 	t.pfrb_type = PFRB_TRANS;
495 	if (pfctl_add_trans(&t, PF_RULESET_ALTQ, "") ||
496 	    pfctl_trans(dev, &t, DIOCXBEGIN, 0) ||
497 	    pfctl_trans(dev, &t, DIOCXCOMMIT, 0))
498 		err(1, "pfctl_clear_altq");
499 	if ((opts & PF_OPT_QUIET) == 0)
500 		fprintf(stderr, "altq cleared\n");
501 	return (0);
502 }
503 
504 int
505 pfctl_clear_src_nodes(int dev, int opts)
506 {
507 	if (ioctl(dev, DIOCCLRSRCNODES))
508 		err(1, "DIOCCLRSRCNODES");
509 	if ((opts & PF_OPT_QUIET) == 0)
510 		fprintf(stderr, "source tracking entries cleared\n");
511 	return (0);
512 }
513 
514 int
515 pfctl_clear_iface_states(int dev, const char *iface, int opts)
516 {
517 	struct pfctl_kill kill;
518 	unsigned int killed;
519 
520 	memset(&kill, 0, sizeof(kill));
521 	if (iface != NULL && strlcpy(kill.ifname, iface,
522 	    sizeof(kill.ifname)) >= sizeof(kill.ifname))
523 		errx(1, "invalid interface: %s", iface);
524 
525 	if (opts & PF_OPT_KILLMATCH)
526 		kill.kill_match = true;
527 
528 	if (pfctl_clear_states(dev, &kill, &killed))
529 		err(1, "DIOCCLRSTATES");
530 	if ((opts & PF_OPT_QUIET) == 0)
531 		fprintf(stderr, "%d states cleared\n", killed);
532 	return (0);
533 }
534 
535 void
536 pfctl_addrprefix(char *addr, struct pf_addr *mask)
537 {
538 	char *p;
539 	const char *errstr;
540 	int prefix, ret_ga, q, r;
541 	struct addrinfo hints, *res;
542 
543 	if ((p = strchr(addr, '/')) == NULL)
544 		return;
545 
546 	*p++ = '\0';
547 	prefix = strtonum(p, 0, 128, &errstr);
548 	if (errstr)
549 		errx(1, "prefix is %s: %s", errstr, p);
550 
551 	bzero(&hints, sizeof(hints));
552 	/* prefix only with numeric addresses */
553 	hints.ai_flags |= AI_NUMERICHOST;
554 
555 	if ((ret_ga = getaddrinfo(addr, NULL, &hints, &res))) {
556 		errx(1, "getaddrinfo: %s", gai_strerror(ret_ga));
557 		/* NOTREACHED */
558 	}
559 
560 	if (res->ai_family == AF_INET && prefix > 32)
561 		errx(1, "prefix too long for AF_INET");
562 	else if (res->ai_family == AF_INET6 && prefix > 128)
563 		errx(1, "prefix too long for AF_INET6");
564 
565 	q = prefix >> 3;
566 	r = prefix & 7;
567 	switch (res->ai_family) {
568 	case AF_INET:
569 		bzero(&mask->v4, sizeof(mask->v4));
570 		mask->v4.s_addr = htonl((u_int32_t)
571 		    (0xffffffffffULL << (32 - prefix)));
572 		break;
573 	case AF_INET6:
574 		bzero(&mask->v6, sizeof(mask->v6));
575 		if (q > 0)
576 			memset((void *)&mask->v6, 0xff, q);
577 		if (r > 0)
578 			*((u_char *)&mask->v6 + q) =
579 			    (0xff00 >> r) & 0xff;
580 		break;
581 	}
582 	freeaddrinfo(res);
583 }
584 
585 int
586 pfctl_kill_src_nodes(int dev, const char *iface, int opts)
587 {
588 	struct pfioc_src_node_kill psnk;
589 	struct addrinfo *res[2], *resp[2];
590 	struct sockaddr last_src, last_dst;
591 	int killed, sources, dests;
592 	int ret_ga;
593 
594 	killed = sources = dests = 0;
595 
596 	memset(&psnk, 0, sizeof(psnk));
597 	memset(&psnk.psnk_src.addr.v.a.mask, 0xff,
598 	    sizeof(psnk.psnk_src.addr.v.a.mask));
599 	memset(&last_src, 0xff, sizeof(last_src));
600 	memset(&last_dst, 0xff, sizeof(last_dst));
601 
602 	pfctl_addrprefix(src_node_kill[0], &psnk.psnk_src.addr.v.a.mask);
603 
604 	if ((ret_ga = getaddrinfo(src_node_kill[0], NULL, NULL, &res[0]))) {
605 		errx(1, "getaddrinfo: %s", gai_strerror(ret_ga));
606 		/* NOTREACHED */
607 	}
608 	for (resp[0] = res[0]; resp[0]; resp[0] = resp[0]->ai_next) {
609 		if (resp[0]->ai_addr == NULL)
610 			continue;
611 		/* We get lots of duplicates.  Catch the easy ones */
612 		if (memcmp(&last_src, resp[0]->ai_addr, sizeof(last_src)) == 0)
613 			continue;
614 		last_src = *(struct sockaddr *)resp[0]->ai_addr;
615 
616 		psnk.psnk_af = resp[0]->ai_family;
617 		sources++;
618 
619 		if (psnk.psnk_af == AF_INET)
620 			psnk.psnk_src.addr.v.a.addr.v4 =
621 			    ((struct sockaddr_in *)resp[0]->ai_addr)->sin_addr;
622 		else if (psnk.psnk_af == AF_INET6)
623 			psnk.psnk_src.addr.v.a.addr.v6 =
624 			    ((struct sockaddr_in6 *)resp[0]->ai_addr)->
625 			    sin6_addr;
626 		else
627 			errx(1, "Unknown address family %d", psnk.psnk_af);
628 
629 		if (src_node_killers > 1) {
630 			dests = 0;
631 			memset(&psnk.psnk_dst.addr.v.a.mask, 0xff,
632 			    sizeof(psnk.psnk_dst.addr.v.a.mask));
633 			memset(&last_dst, 0xff, sizeof(last_dst));
634 			pfctl_addrprefix(src_node_kill[1],
635 			    &psnk.psnk_dst.addr.v.a.mask);
636 			if ((ret_ga = getaddrinfo(src_node_kill[1], NULL, NULL,
637 			    &res[1]))) {
638 				errx(1, "getaddrinfo: %s",
639 				    gai_strerror(ret_ga));
640 				/* NOTREACHED */
641 			}
642 			for (resp[1] = res[1]; resp[1];
643 			    resp[1] = resp[1]->ai_next) {
644 				if (resp[1]->ai_addr == NULL)
645 					continue;
646 				if (psnk.psnk_af != resp[1]->ai_family)
647 					continue;
648 
649 				if (memcmp(&last_dst, resp[1]->ai_addr,
650 				    sizeof(last_dst)) == 0)
651 					continue;
652 				last_dst = *(struct sockaddr *)resp[1]->ai_addr;
653 
654 				dests++;
655 
656 				if (psnk.psnk_af == AF_INET)
657 					psnk.psnk_dst.addr.v.a.addr.v4 =
658 					    ((struct sockaddr_in *)resp[1]->
659 					    ai_addr)->sin_addr;
660 				else if (psnk.psnk_af == AF_INET6)
661 					psnk.psnk_dst.addr.v.a.addr.v6 =
662 					    ((struct sockaddr_in6 *)resp[1]->
663 					    ai_addr)->sin6_addr;
664 				else
665 					errx(1, "Unknown address family %d",
666 					    psnk.psnk_af);
667 
668 				if (ioctl(dev, DIOCKILLSRCNODES, &psnk))
669 					err(1, "DIOCKILLSRCNODES");
670 				killed += psnk.psnk_killed;
671 			}
672 			freeaddrinfo(res[1]);
673 		} else {
674 			if (ioctl(dev, DIOCKILLSRCNODES, &psnk))
675 				err(1, "DIOCKILLSRCNODES");
676 			killed += psnk.psnk_killed;
677 		}
678 	}
679 
680 	freeaddrinfo(res[0]);
681 
682 	if ((opts & PF_OPT_QUIET) == 0)
683 		fprintf(stderr, "killed %d src nodes from %d sources and %d "
684 		    "destinations\n", killed, sources, dests);
685 	return (0);
686 }
687 
688 int
689 pfctl_net_kill_states(int dev, const char *iface, int opts)
690 {
691 	struct pfctl_kill kill;
692 	struct addrinfo *res[2], *resp[2];
693 	struct sockaddr last_src, last_dst;
694 	unsigned int newkilled;
695 	int killed, sources, dests;
696 	int ret_ga;
697 
698 	killed = sources = dests = 0;
699 
700 	memset(&kill, 0, sizeof(kill));
701 	memset(&kill.src.addr.v.a.mask, 0xff,
702 	    sizeof(kill.src.addr.v.a.mask));
703 	memset(&last_src, 0xff, sizeof(last_src));
704 	memset(&last_dst, 0xff, sizeof(last_dst));
705 	if (iface != NULL && strlcpy(kill.ifname, iface,
706 	    sizeof(kill.ifname)) >= sizeof(kill.ifname))
707 		errx(1, "invalid interface: %s", iface);
708 
709 	pfctl_addrprefix(state_kill[0], &kill.src.addr.v.a.mask);
710 
711 	if (opts & PF_OPT_KILLMATCH)
712 		kill.kill_match = true;
713 
714 	if ((ret_ga = getaddrinfo(state_kill[0], NULL, NULL, &res[0]))) {
715 		errx(1, "getaddrinfo: %s", gai_strerror(ret_ga));
716 		/* NOTREACHED */
717 	}
718 	for (resp[0] = res[0]; resp[0]; resp[0] = resp[0]->ai_next) {
719 		if (resp[0]->ai_addr == NULL)
720 			continue;
721 		/* We get lots of duplicates.  Catch the easy ones */
722 		if (memcmp(&last_src, resp[0]->ai_addr, sizeof(last_src)) == 0)
723 			continue;
724 		last_src = *(struct sockaddr *)resp[0]->ai_addr;
725 
726 		kill.af = resp[0]->ai_family;
727 		sources++;
728 
729 		if (kill.af == AF_INET)
730 			kill.src.addr.v.a.addr.v4 =
731 			    ((struct sockaddr_in *)resp[0]->ai_addr)->sin_addr;
732 		else if (kill.af == AF_INET6)
733 			kill.src.addr.v.a.addr.v6 =
734 			    ((struct sockaddr_in6 *)resp[0]->ai_addr)->
735 			    sin6_addr;
736 		else
737 			errx(1, "Unknown address family %d", kill.af);
738 
739 		if (state_killers > 1) {
740 			dests = 0;
741 			memset(&kill.dst.addr.v.a.mask, 0xff,
742 			    sizeof(kill.dst.addr.v.a.mask));
743 			memset(&last_dst, 0xff, sizeof(last_dst));
744 			pfctl_addrprefix(state_kill[1],
745 			    &kill.dst.addr.v.a.mask);
746 			if ((ret_ga = getaddrinfo(state_kill[1], NULL, NULL,
747 			    &res[1]))) {
748 				errx(1, "getaddrinfo: %s",
749 				    gai_strerror(ret_ga));
750 				/* NOTREACHED */
751 			}
752 			for (resp[1] = res[1]; resp[1];
753 			    resp[1] = resp[1]->ai_next) {
754 				if (resp[1]->ai_addr == NULL)
755 					continue;
756 				if (kill.af != resp[1]->ai_family)
757 					continue;
758 
759 				if (memcmp(&last_dst, resp[1]->ai_addr,
760 				    sizeof(last_dst)) == 0)
761 					continue;
762 				last_dst = *(struct sockaddr *)resp[1]->ai_addr;
763 
764 				dests++;
765 
766 				if (kill.af == AF_INET)
767 					kill.dst.addr.v.a.addr.v4 =
768 					    ((struct sockaddr_in *)resp[1]->
769 					    ai_addr)->sin_addr;
770 				else if (kill.af == AF_INET6)
771 					kill.dst.addr.v.a.addr.v6 =
772 					    ((struct sockaddr_in6 *)resp[1]->
773 					    ai_addr)->sin6_addr;
774 				else
775 					errx(1, "Unknown address family %d",
776 					    kill.af);
777 
778 				if (pfctl_kill_states(dev, &kill, &newkilled))
779 					err(1, "DIOCKILLSTATES");
780 				killed += newkilled;
781 			}
782 			freeaddrinfo(res[1]);
783 		} else {
784 			if (pfctl_kill_states(dev, &kill, &newkilled))
785 				err(1, "DIOCKILLSTATES");
786 			killed += newkilled;
787 		}
788 	}
789 
790 	freeaddrinfo(res[0]);
791 
792 	if ((opts & PF_OPT_QUIET) == 0)
793 		fprintf(stderr, "killed %d states from %d sources and %d "
794 		    "destinations\n", killed, sources, dests);
795 	return (0);
796 }
797 
798 int
799 pfctl_gateway_kill_states(int dev, const char *iface, int opts)
800 {
801 	struct pfctl_kill kill;
802 	struct addrinfo *res, *resp;
803 	struct sockaddr last_src;
804 	unsigned int newkilled;
805 	int killed = 0;
806 	int ret_ga;
807 
808 	if (state_killers != 2 || (strlen(state_kill[1]) == 0)) {
809 		warnx("no gateway specified");
810 		usage();
811 	}
812 
813 	memset(&kill, 0, sizeof(kill));
814 	memset(&kill.rt_addr.addr.v.a.mask, 0xff,
815 	    sizeof(kill.rt_addr.addr.v.a.mask));
816 	memset(&last_src, 0xff, sizeof(last_src));
817 	if (iface != NULL && strlcpy(kill.ifname, iface,
818 	    sizeof(kill.ifname)) >= sizeof(kill.ifname))
819 		errx(1, "invalid interface: %s", iface);
820 
821 	if (opts & PF_OPT_KILLMATCH)
822 		kill.kill_match = true;
823 
824 	pfctl_addrprefix(state_kill[1], &kill.rt_addr.addr.v.a.mask);
825 
826 	if ((ret_ga = getaddrinfo(state_kill[1], NULL, NULL, &res))) {
827 		errx(1, "getaddrinfo: %s", gai_strerror(ret_ga));
828 		/* NOTREACHED */
829 	}
830 	for (resp = res; resp; resp = resp->ai_next) {
831 		if (resp->ai_addr == NULL)
832 			continue;
833 		/* We get lots of duplicates.  Catch the easy ones */
834 		if (memcmp(&last_src, resp->ai_addr, sizeof(last_src)) == 0)
835 			continue;
836 		last_src = *(struct sockaddr *)resp->ai_addr;
837 
838 		kill.af = resp->ai_family;
839 
840 		if (kill.af == AF_INET)
841 			kill.rt_addr.addr.v.a.addr.v4 =
842 			    ((struct sockaddr_in *)resp->ai_addr)->sin_addr;
843 		else if (kill.af == AF_INET6)
844 			kill.rt_addr.addr.v.a.addr.v6 =
845 			    ((struct sockaddr_in6 *)resp->ai_addr)->
846 			    sin6_addr;
847 		else
848 			errx(1, "Unknown address family %d", kill.af);
849 
850 		if (pfctl_kill_states(dev, &kill, &newkilled))
851 			err(1, "DIOCKILLSTATES");
852 		killed += newkilled;
853 	}
854 
855 	freeaddrinfo(res);
856 
857 	if ((opts & PF_OPT_QUIET) == 0)
858 		fprintf(stderr, "killed %d states\n", killed);
859 	return (0);
860 }
861 
862 int
863 pfctl_label_kill_states(int dev, const char *iface, int opts)
864 {
865 	struct pfctl_kill kill;
866 	unsigned int killed;
867 
868 	if (state_killers != 2 || (strlen(state_kill[1]) == 0)) {
869 		warnx("no label specified");
870 		usage();
871 	}
872 	memset(&kill, 0, sizeof(kill));
873 	if (iface != NULL && strlcpy(kill.ifname, iface,
874 	    sizeof(kill.ifname)) >= sizeof(kill.ifname))
875 		errx(1, "invalid interface: %s", iface);
876 
877 	if (opts & PF_OPT_KILLMATCH)
878 		kill.kill_match = true;
879 
880 	if (strlcpy(kill.label, state_kill[1], sizeof(kill.label)) >=
881 	    sizeof(kill.label))
882 		errx(1, "label too long: %s", state_kill[1]);
883 
884 	if (pfctl_kill_states(dev, &kill, &killed))
885 		err(1, "DIOCKILLSTATES");
886 
887 	if ((opts & PF_OPT_QUIET) == 0)
888 		fprintf(stderr, "killed %d states\n", killed);
889 
890 	return (0);
891 }
892 
893 int
894 pfctl_id_kill_states(int dev, const char *iface, int opts)
895 {
896 	struct pfctl_kill kill;
897 	unsigned int killed;
898 
899 	if (state_killers != 2 || (strlen(state_kill[1]) == 0)) {
900 		warnx("no id specified");
901 		usage();
902 	}
903 
904 	memset(&kill, 0, sizeof(kill));
905 
906 	if (opts & PF_OPT_KILLMATCH)
907 		kill.kill_match = true;
908 
909 	if ((sscanf(state_kill[1], "%jx/%x",
910 	    &kill.cmp.id, &kill.cmp.creatorid)) == 2) {
911 	}
912 	else if ((sscanf(state_kill[1], "%jx", &kill.cmp.id)) == 1) {
913 		kill.cmp.creatorid = 0;
914 	} else {
915 		warnx("wrong id format specified");
916 		usage();
917 	}
918 	if (kill.cmp.id == 0) {
919 		warnx("cannot kill id 0");
920 		usage();
921 	}
922 
923 	if (pfctl_kill_states(dev, &kill, &killed))
924 		err(1, "DIOCKILLSTATES");
925 
926 	if ((opts & PF_OPT_QUIET) == 0)
927 		fprintf(stderr, "killed %d states\n", killed);
928 
929 	return (0);
930 }
931 
932 int
933 pfctl_get_pool(int dev, struct pfctl_pool *pool, u_int32_t nr,
934     u_int32_t ticket, int r_action, char *anchorname)
935 {
936 	struct pfioc_pooladdr pp;
937 	struct pf_pooladdr *pa;
938 	u_int32_t pnr, mpnr;
939 
940 	memset(&pp, 0, sizeof(pp));
941 	memcpy(pp.anchor, anchorname, sizeof(pp.anchor));
942 	pp.r_action = r_action;
943 	pp.r_num = nr;
944 	pp.ticket = ticket;
945 	if (ioctl(dev, DIOCGETADDRS, &pp)) {
946 		warn("DIOCGETADDRS");
947 		return (-1);
948 	}
949 	mpnr = pp.nr;
950 	TAILQ_INIT(&pool->list);
951 	for (pnr = 0; pnr < mpnr; ++pnr) {
952 		pp.nr = pnr;
953 		if (ioctl(dev, DIOCGETADDR, &pp)) {
954 			warn("DIOCGETADDR");
955 			return (-1);
956 		}
957 		pa = calloc(1, sizeof(struct pf_pooladdr));
958 		if (pa == NULL)
959 			err(1, "calloc");
960 		bcopy(&pp.addr, pa, sizeof(struct pf_pooladdr));
961 		TAILQ_INSERT_TAIL(&pool->list, pa, entries);
962 	}
963 
964 	return (0);
965 }
966 
967 void
968 pfctl_move_pool(struct pfctl_pool *src, struct pfctl_pool *dst)
969 {
970 	struct pf_pooladdr *pa;
971 
972 	while ((pa = TAILQ_FIRST(&src->list)) != NULL) {
973 		TAILQ_REMOVE(&src->list, pa, entries);
974 		TAILQ_INSERT_TAIL(&dst->list, pa, entries);
975 	}
976 }
977 
978 void
979 pfctl_clear_pool(struct pfctl_pool *pool)
980 {
981 	struct pf_pooladdr *pa;
982 
983 	while ((pa = TAILQ_FIRST(&pool->list)) != NULL) {
984 		TAILQ_REMOVE(&pool->list, pa, entries);
985 		free(pa);
986 	}
987 }
988 
989 void
990 pfctl_print_rule_counters(struct pfctl_rule *rule, int opts)
991 {
992 	if (opts & PF_OPT_DEBUG) {
993 		const char *t[PF_SKIP_COUNT] = { "i", "d", "f",
994 		    "p", "sa", "sp", "da", "dp" };
995 		int i;
996 
997 		printf("  [ Skip steps: ");
998 		for (i = 0; i < PF_SKIP_COUNT; ++i) {
999 			if (rule->skip[i].nr == rule->nr + 1)
1000 				continue;
1001 			printf("%s=", t[i]);
1002 			if (rule->skip[i].nr == -1)
1003 				printf("end ");
1004 			else
1005 				printf("%u ", rule->skip[i].nr);
1006 		}
1007 		printf("]\n");
1008 
1009 		printf("  [ queue: qname=%s qid=%u pqname=%s pqid=%u ]\n",
1010 		    rule->qname, rule->qid, rule->pqname, rule->pqid);
1011 	}
1012 	if (opts & PF_OPT_VERBOSE) {
1013 		printf("  [ Evaluations: %-8llu  Packets: %-8llu  "
1014 			    "Bytes: %-10llu  States: %-6ju]\n",
1015 			    (unsigned long long)rule->evaluations,
1016 			    (unsigned long long)(rule->packets[0] +
1017 			    rule->packets[1]),
1018 			    (unsigned long long)(rule->bytes[0] +
1019 			    rule->bytes[1]), (uintmax_t)rule->states_cur);
1020 		if (!(opts & PF_OPT_DEBUG))
1021 			printf("  [ Inserted: uid %u pid %u "
1022 			    "State Creations: %-6ju]\n",
1023 			    (unsigned)rule->cuid, (unsigned)rule->cpid,
1024 			    (uintmax_t)rule->states_tot);
1025 	}
1026 }
1027 
1028 void
1029 pfctl_print_title(char *title)
1030 {
1031 	if (!first_title)
1032 		printf("\n");
1033 	first_title = 0;
1034 	printf("%s\n", title);
1035 }
1036 
1037 int
1038 pfctl_show_rules(int dev, char *path, int opts, enum pfctl_show format,
1039     char *anchorname, int depth)
1040 {
1041 	struct pfioc_rule pr;
1042 	struct pfctl_rule rule;
1043 	u_int32_t nr, mnr, header = 0;
1044 	int rule_numbers = opts & (PF_OPT_VERBOSE2 | PF_OPT_DEBUG);
1045 	int numeric = opts & PF_OPT_NUMERIC;
1046 	int len = strlen(path);
1047 	int brace;
1048 	char *p;
1049 
1050 	if (path[0])
1051 		snprintf(&path[len], MAXPATHLEN - len, "/%s", anchorname);
1052 	else
1053 		snprintf(&path[len], MAXPATHLEN - len, "%s", anchorname);
1054 
1055 	memset(&pr, 0, sizeof(pr));
1056 	memcpy(pr.anchor, path, sizeof(pr.anchor));
1057 	if (opts & PF_OPT_SHOWALL) {
1058 		pr.rule.action = PF_PASS;
1059 		if (ioctl(dev, DIOCGETRULES, &pr)) {
1060 			warn("DIOCGETRULES");
1061 			goto error;
1062 		}
1063 		header++;
1064 	}
1065 	pr.rule.action = PF_SCRUB;
1066 	if (ioctl(dev, DIOCGETRULES, &pr)) {
1067 		warn("DIOCGETRULES");
1068 		goto error;
1069 	}
1070 	if (opts & PF_OPT_SHOWALL) {
1071 		if (format == PFCTL_SHOW_RULES && (pr.nr > 0 || header))
1072 			pfctl_print_title("FILTER RULES:");
1073 		else if (format == PFCTL_SHOW_LABELS && labels)
1074 			pfctl_print_title("LABEL COUNTERS:");
1075 	}
1076 	mnr = pr.nr;
1077 
1078 	for (nr = 0; nr < mnr; ++nr) {
1079 		pr.nr = nr;
1080 		if (pfctl_get_clear_rule(dev, nr, pr.ticket, path, PF_SCRUB,
1081 		    &rule, pr.anchor_call, opts & PF_OPT_CLRRULECTRS)) {
1082 			warn("DIOCGETRULENV");
1083 			goto error;
1084 		}
1085 
1086 		if (pfctl_get_pool(dev, &rule.rpool,
1087 		    nr, pr.ticket, PF_SCRUB, path) != 0)
1088 			goto error;
1089 
1090 		switch (format) {
1091 		case PFCTL_SHOW_LABELS:
1092 			break;
1093 		case PFCTL_SHOW_RULES:
1094 			if (rule.label[0] && (opts & PF_OPT_SHOWALL))
1095 				labels = 1;
1096 			print_rule(&rule, pr.anchor_call, rule_numbers, numeric);
1097 			printf("\n");
1098 			pfctl_print_rule_counters(&rule, opts);
1099 			break;
1100 		case PFCTL_SHOW_NOTHING:
1101 			break;
1102 		}
1103 		pfctl_clear_pool(&rule.rpool);
1104 	}
1105 	pr.rule.action = PF_PASS;
1106 	if (ioctl(dev, DIOCGETRULES, &pr)) {
1107 		warn("DIOCGETRULES");
1108 		goto error;
1109 	}
1110 	mnr = pr.nr;
1111 	for (nr = 0; nr < mnr; ++nr) {
1112 		pr.nr = nr;
1113 		if (pfctl_get_clear_rule(dev, nr, pr.ticket, path, PF_PASS,
1114 		    &rule, pr.anchor_call, opts & PF_OPT_CLRRULECTRS)) {
1115 			warn("DIOCGETRULE");
1116 			goto error;
1117 		}
1118 
1119 		if (pfctl_get_pool(dev, &rule.rpool,
1120 		    nr, pr.ticket, PF_PASS, path) != 0)
1121 			goto error;
1122 
1123 		switch (format) {
1124 		case PFCTL_SHOW_LABELS: {
1125 			bool show = false;
1126 			int i = 0;
1127 
1128 			while (rule.label[i][0]) {
1129 				printf("%s ", rule.label[i++]);
1130 				show = true;
1131 			}
1132 
1133 			if (show) {
1134 				printf("%llu %llu %llu %llu"
1135 				    " %llu %llu %llu %ju\n",
1136 				    (unsigned long long)rule.evaluations,
1137 				    (unsigned long long)(rule.packets[0] +
1138 				    rule.packets[1]),
1139 				    (unsigned long long)(rule.bytes[0] +
1140 				    rule.bytes[1]),
1141 				    (unsigned long long)rule.packets[0],
1142 				    (unsigned long long)rule.bytes[0],
1143 				    (unsigned long long)rule.packets[1],
1144 				    (unsigned long long)rule.bytes[1],
1145 				    (uintmax_t)rule.states_tot);
1146 			}
1147 			break;
1148 		}
1149 		case PFCTL_SHOW_RULES:
1150 			brace = 0;
1151 			if (rule.label[0] && (opts & PF_OPT_SHOWALL))
1152 				labels = 1;
1153 			INDENT(depth, !(opts & PF_OPT_VERBOSE));
1154 			if (pr.anchor_call[0] &&
1155 			   ((((p = strrchr(pr.anchor_call, '_')) != NULL) &&
1156 			   ((void *)p == (void *)pr.anchor_call ||
1157 			   *(--p) == '/')) || (opts & PF_OPT_RECURSE))) {
1158 				brace++;
1159 				if ((p = strrchr(pr.anchor_call, '/')) !=
1160 				    NULL)
1161 					p++;
1162 				else
1163 					p = &pr.anchor_call[0];
1164 			} else
1165 				p = &pr.anchor_call[0];
1166 
1167 			print_rule(&rule, p, rule_numbers, numeric);
1168 			if (brace)
1169 				printf(" {\n");
1170 			else
1171 				printf("\n");
1172 			pfctl_print_rule_counters(&rule, opts);
1173 			if (brace) {
1174 				pfctl_show_rules(dev, path, opts, format,
1175 				    p, depth + 1);
1176 				INDENT(depth, !(opts & PF_OPT_VERBOSE));
1177 				printf("}\n");
1178 			}
1179 			break;
1180 		case PFCTL_SHOW_NOTHING:
1181 			break;
1182 		}
1183 		pfctl_clear_pool(&rule.rpool);
1184 	}
1185 	path[len] = '\0';
1186 	return (0);
1187 
1188  error:
1189 	path[len] = '\0';
1190 	return (-1);
1191 }
1192 
1193 int
1194 pfctl_show_nat(int dev, int opts, char *anchorname)
1195 {
1196 	struct pfioc_rule pr;
1197 	struct pfctl_rule rule;
1198 	u_int32_t mnr, nr;
1199 	static int nattype[3] = { PF_NAT, PF_RDR, PF_BINAT };
1200 	int i, dotitle = opts & PF_OPT_SHOWALL;
1201 
1202 	memset(&pr, 0, sizeof(pr));
1203 	memcpy(pr.anchor, anchorname, sizeof(pr.anchor));
1204 	for (i = 0; i < 3; i++) {
1205 		pr.rule.action = nattype[i];
1206 		if (ioctl(dev, DIOCGETRULES, &pr)) {
1207 			warn("DIOCGETRULES");
1208 			return (-1);
1209 		}
1210 		mnr = pr.nr;
1211 		for (nr = 0; nr < mnr; ++nr) {
1212 			pr.nr = nr;
1213 			if (pfctl_get_rule(dev, nr, pr.ticket, anchorname,
1214 			    nattype[i], &rule, pr.anchor_call)) {
1215 				warn("DIOCGETRULE");
1216 				return (-1);
1217 			}
1218 			if (pfctl_get_pool(dev, &rule.rpool, nr,
1219 			    pr.ticket, nattype[i], anchorname) != 0)
1220 				return (-1);
1221 			if (dotitle) {
1222 				pfctl_print_title("TRANSLATION RULES:");
1223 				dotitle = 0;
1224 			}
1225 			print_rule(&rule, pr.anchor_call,
1226 			    opts & PF_OPT_VERBOSE2, opts & PF_OPT_NUMERIC);
1227 			printf("\n");
1228 			pfctl_print_rule_counters(&rule, opts);
1229 			pfctl_clear_pool(&rule.rpool);
1230 		}
1231 	}
1232 	return (0);
1233 }
1234 
1235 int
1236 pfctl_show_src_nodes(int dev, int opts)
1237 {
1238 	struct pfioc_src_nodes psn;
1239 	struct pf_src_node *p;
1240 	char *inbuf = NULL, *newinbuf = NULL;
1241 	unsigned int len = 0;
1242 	int i;
1243 
1244 	memset(&psn, 0, sizeof(psn));
1245 	for (;;) {
1246 		psn.psn_len = len;
1247 		if (len) {
1248 			newinbuf = realloc(inbuf, len);
1249 			if (newinbuf == NULL)
1250 				err(1, "realloc");
1251 			psn.psn_buf = inbuf = newinbuf;
1252 		}
1253 		if (ioctl(dev, DIOCGETSRCNODES, &psn) < 0) {
1254 			warn("DIOCGETSRCNODES");
1255 			free(inbuf);
1256 			return (-1);
1257 		}
1258 		if (psn.psn_len + sizeof(struct pfioc_src_nodes) < len)
1259 			break;
1260 		if (len == 0 && psn.psn_len == 0)
1261 			goto done;
1262 		if (len == 0 && psn.psn_len != 0)
1263 			len = psn.psn_len;
1264 		if (psn.psn_len == 0)
1265 			goto done;	/* no src_nodes */
1266 		len *= 2;
1267 	}
1268 	p = psn.psn_src_nodes;
1269 	if (psn.psn_len > 0 && (opts & PF_OPT_SHOWALL))
1270 		pfctl_print_title("SOURCE TRACKING NODES:");
1271 	for (i = 0; i < psn.psn_len; i += sizeof(*p)) {
1272 		print_src_node(p, opts);
1273 		p++;
1274 	}
1275 done:
1276 	free(inbuf);
1277 	return (0);
1278 }
1279 
1280 int
1281 pfctl_show_states(int dev, const char *iface, int opts)
1282 {
1283 	struct pfctl_states states;
1284 	struct pfctl_state *s;
1285 	int dotitle = (opts & PF_OPT_SHOWALL);
1286 
1287 	memset(&states, 0, sizeof(states));
1288 
1289 	if (pfctl_get_states(dev, &states))
1290 		return (-1);
1291 
1292 	TAILQ_FOREACH(s, &states.states, entry) {
1293 		if (iface != NULL && strcmp(s->ifname, iface))
1294 			continue;
1295 		if (dotitle) {
1296 			pfctl_print_title("STATES:");
1297 			dotitle = 0;
1298 		}
1299 		print_state(s, opts);
1300 	}
1301 
1302 	pfctl_free_states(&states);
1303 
1304 	return (0);
1305 }
1306 
1307 int
1308 pfctl_show_status(int dev, int opts)
1309 {
1310 	struct pf_status	status;
1311 	struct pfctl_syncookies	cookies;
1312 
1313 	if (ioctl(dev, DIOCGETSTATUS, &status)) {
1314 		warn("DIOCGETSTATUS");
1315 		return (-1);
1316 	}
1317 	if (pfctl_get_syncookies(dev, &cookies)) {
1318 		warn("DIOCGETSYNCOOKIES");
1319 		return (-1);
1320 	}
1321 	if (opts & PF_OPT_SHOWALL)
1322 		pfctl_print_title("INFO:");
1323 	print_status(&status, &cookies, opts);
1324 	return (0);
1325 }
1326 
1327 int
1328 pfctl_show_running(int dev)
1329 {
1330 	struct pf_status status;
1331 
1332 	if (ioctl(dev, DIOCGETSTATUS, &status)) {
1333 		warn("DIOCGETSTATUS");
1334 		return (-1);
1335 	}
1336 
1337 	print_running(&status);
1338 	return (!status.running);
1339 }
1340 
1341 int
1342 pfctl_show_timeouts(int dev, int opts)
1343 {
1344 	struct pfioc_tm pt;
1345 	int i;
1346 
1347 	if (opts & PF_OPT_SHOWALL)
1348 		pfctl_print_title("TIMEOUTS:");
1349 	memset(&pt, 0, sizeof(pt));
1350 	for (i = 0; pf_timeouts[i].name; i++) {
1351 		pt.timeout = pf_timeouts[i].timeout;
1352 		if (ioctl(dev, DIOCGETTIMEOUT, &pt))
1353 			err(1, "DIOCGETTIMEOUT");
1354 		printf("%-20s %10d", pf_timeouts[i].name, pt.seconds);
1355 		if (pf_timeouts[i].timeout >= PFTM_ADAPTIVE_START &&
1356 		    pf_timeouts[i].timeout <= PFTM_ADAPTIVE_END)
1357 			printf(" states");
1358 		else
1359 			printf("s");
1360 		printf("\n");
1361 	}
1362 	return (0);
1363 
1364 }
1365 
1366 int
1367 pfctl_show_limits(int dev, int opts)
1368 {
1369 	struct pfioc_limit pl;
1370 	int i;
1371 
1372 	if (opts & PF_OPT_SHOWALL)
1373 		pfctl_print_title("LIMITS:");
1374 	memset(&pl, 0, sizeof(pl));
1375 	for (i = 0; pf_limits[i].name; i++) {
1376 		pl.index = pf_limits[i].index;
1377 		if (ioctl(dev, DIOCGETLIMIT, &pl))
1378 			err(1, "DIOCGETLIMIT");
1379 		printf("%-13s ", pf_limits[i].name);
1380 		if (pl.limit == UINT_MAX)
1381 			printf("unlimited\n");
1382 		else
1383 			printf("hard limit %8u\n", pl.limit);
1384 	}
1385 	return (0);
1386 }
1387 
1388 /* callbacks for rule/nat/rdr/addr */
1389 int
1390 pfctl_add_pool(struct pfctl *pf, struct pfctl_pool *p, sa_family_t af)
1391 {
1392 	struct pf_pooladdr *pa;
1393 
1394 	if ((pf->opts & PF_OPT_NOACTION) == 0) {
1395 		if (ioctl(pf->dev, DIOCBEGINADDRS, &pf->paddr))
1396 			err(1, "DIOCBEGINADDRS");
1397 	}
1398 
1399 	pf->paddr.af = af;
1400 	TAILQ_FOREACH(pa, &p->list, entries) {
1401 		memcpy(&pf->paddr.addr, pa, sizeof(struct pf_pooladdr));
1402 		if ((pf->opts & PF_OPT_NOACTION) == 0) {
1403 			if (ioctl(pf->dev, DIOCADDADDR, &pf->paddr))
1404 				err(1, "DIOCADDADDR");
1405 		}
1406 	}
1407 	return (0);
1408 }
1409 
1410 int
1411 pfctl_append_rule(struct pfctl *pf, struct pfctl_rule *r,
1412     const char *anchor_call)
1413 {
1414 	u_int8_t		rs_num;
1415 	struct pfctl_rule	*rule;
1416 	struct pfctl_ruleset	*rs;
1417 	char 			*p;
1418 
1419 	rs_num = pf_get_ruleset_number(r->action);
1420 	if (rs_num == PF_RULESET_MAX)
1421 		errx(1, "Invalid rule type %d", r->action);
1422 
1423 	rs = &pf->anchor->ruleset;
1424 
1425 	if (anchor_call[0] && r->anchor == NULL) {
1426 		/*
1427 		 * Don't make non-brace anchors part of the main anchor pool.
1428 		 */
1429 		if ((r->anchor = calloc(1, sizeof(*r->anchor))) == NULL)
1430 			err(1, "pfctl_append_rule: calloc");
1431 
1432 		pf_init_ruleset(&r->anchor->ruleset);
1433 		r->anchor->ruleset.anchor = r->anchor;
1434 		if (strlcpy(r->anchor->path, anchor_call,
1435 		    sizeof(rule->anchor->path)) >= sizeof(rule->anchor->path))
1436 			errx(1, "pfctl_append_rule: strlcpy");
1437 		if ((p = strrchr(anchor_call, '/')) != NULL) {
1438 			if (!strlen(p))
1439 				err(1, "pfctl_append_rule: bad anchor name %s",
1440 				    anchor_call);
1441 		} else
1442 			p = (char *)anchor_call;
1443 		if (strlcpy(r->anchor->name, p,
1444 		    sizeof(rule->anchor->name)) >= sizeof(rule->anchor->name))
1445 			errx(1, "pfctl_append_rule: strlcpy");
1446 	}
1447 
1448 	if ((rule = calloc(1, sizeof(*rule))) == NULL)
1449 		err(1, "calloc");
1450 	bcopy(r, rule, sizeof(*rule));
1451 	TAILQ_INIT(&rule->rpool.list);
1452 	pfctl_move_pool(&r->rpool, &rule->rpool);
1453 
1454 	TAILQ_INSERT_TAIL(rs->rules[rs_num].active.ptr, rule, entries);
1455 	return (0);
1456 }
1457 
1458 int
1459 pfctl_ruleset_trans(struct pfctl *pf, char *path, struct pfctl_anchor *a)
1460 {
1461 	int osize = pf->trans->pfrb_size;
1462 
1463 	if ((pf->loadopt & PFCTL_FLAG_NAT) != 0) {
1464 		if (pfctl_add_trans(pf->trans, PF_RULESET_NAT, path) ||
1465 		    pfctl_add_trans(pf->trans, PF_RULESET_BINAT, path) ||
1466 		    pfctl_add_trans(pf->trans, PF_RULESET_RDR, path))
1467 			return (1);
1468 	}
1469 	if (a == pf->astack[0] && ((altqsupport &&
1470 	    (pf->loadopt & PFCTL_FLAG_ALTQ) != 0))) {
1471 		if (pfctl_add_trans(pf->trans, PF_RULESET_ALTQ, path))
1472 			return (2);
1473 	}
1474 	if ((pf->loadopt & PFCTL_FLAG_FILTER) != 0) {
1475 		if (pfctl_add_trans(pf->trans, PF_RULESET_SCRUB, path) ||
1476 		    pfctl_add_trans(pf->trans, PF_RULESET_FILTER, path))
1477 			return (3);
1478 	}
1479 	if (pf->loadopt & PFCTL_FLAG_TABLE)
1480 		if (pfctl_add_trans(pf->trans, PF_RULESET_TABLE, path))
1481 			return (4);
1482 	if (pfctl_trans(pf->dev, pf->trans, DIOCXBEGIN, osize))
1483 		return (5);
1484 
1485 	return (0);
1486 }
1487 
1488 int
1489 pfctl_load_ruleset(struct pfctl *pf, char *path, struct pfctl_ruleset *rs,
1490     int rs_num, int depth)
1491 {
1492 	struct pfctl_rule *r;
1493 	int		error, len = strlen(path);
1494 	int		brace = 0;
1495 
1496 	pf->anchor = rs->anchor;
1497 
1498 	if (path[0])
1499 		snprintf(&path[len], MAXPATHLEN - len, "/%s", pf->anchor->name);
1500 	else
1501 		snprintf(&path[len], MAXPATHLEN - len, "%s", pf->anchor->name);
1502 
1503 	if (depth) {
1504 		if (TAILQ_FIRST(rs->rules[rs_num].active.ptr) != NULL) {
1505 			brace++;
1506 			if (pf->opts & PF_OPT_VERBOSE)
1507 				printf(" {\n");
1508 			if ((pf->opts & PF_OPT_NOACTION) == 0 &&
1509 			    (error = pfctl_ruleset_trans(pf,
1510 			    path, rs->anchor))) {
1511 				printf("pfctl_load_rulesets: "
1512 				    "pfctl_ruleset_trans %d\n", error);
1513 				goto error;
1514 			}
1515 		} else if (pf->opts & PF_OPT_VERBOSE)
1516 			printf("\n");
1517 
1518 	}
1519 
1520 	if (pf->optimize && rs_num == PF_RULESET_FILTER)
1521 		pfctl_optimize_ruleset(pf, rs);
1522 
1523 	while ((r = TAILQ_FIRST(rs->rules[rs_num].active.ptr)) != NULL) {
1524 		TAILQ_REMOVE(rs->rules[rs_num].active.ptr, r, entries);
1525 		if ((error = pfctl_load_rule(pf, path, r, depth)))
1526 			goto error;
1527 		if (r->anchor) {
1528 			if ((error = pfctl_load_ruleset(pf, path,
1529 			    &r->anchor->ruleset, rs_num, depth + 1)))
1530 				goto error;
1531 		} else if (pf->opts & PF_OPT_VERBOSE)
1532 			printf("\n");
1533 		free(r);
1534 	}
1535 	if (brace && pf->opts & PF_OPT_VERBOSE) {
1536 		INDENT(depth - 1, (pf->opts & PF_OPT_VERBOSE));
1537 		printf("}\n");
1538 	}
1539 	path[len] = '\0';
1540 	return (0);
1541 
1542  error:
1543 	path[len] = '\0';
1544 	return (error);
1545 
1546 }
1547 
1548 int
1549 pfctl_load_rule(struct pfctl *pf, char *path, struct pfctl_rule *r, int depth)
1550 {
1551 	u_int8_t		rs_num = pf_get_ruleset_number(r->action);
1552 	char			*name;
1553 	u_int32_t		ticket;
1554 	char			anchor[PF_ANCHOR_NAME_SIZE];
1555 	int			len = strlen(path);
1556 
1557 	/* set up anchor before adding to path for anchor_call */
1558 	if ((pf->opts & PF_OPT_NOACTION) == 0)
1559 		ticket = pfctl_get_ticket(pf->trans, rs_num, path);
1560 	if (strlcpy(anchor, path, sizeof(anchor)) >= sizeof(anchor))
1561 		errx(1, "pfctl_load_rule: strlcpy");
1562 
1563 	if (r->anchor) {
1564 		if (r->anchor->match) {
1565 			if (path[0])
1566 				snprintf(&path[len], MAXPATHLEN - len,
1567 				    "/%s", r->anchor->name);
1568 			else
1569 				snprintf(&path[len], MAXPATHLEN - len,
1570 				    "%s", r->anchor->name);
1571 			name = r->anchor->name;
1572 		} else
1573 			name = r->anchor->path;
1574 	} else
1575 		name = "";
1576 
1577 	if ((pf->opts & PF_OPT_NOACTION) == 0) {
1578 		if (pfctl_add_pool(pf, &r->rpool, r->af))
1579 			return (1);
1580 		if (pfctl_add_rule(pf->dev, r, anchor, name, ticket,
1581 		    pf->paddr.ticket))
1582 			err(1, "DIOCADDRULENV");
1583 	}
1584 
1585 	if (pf->opts & PF_OPT_VERBOSE) {
1586 		INDENT(depth, !(pf->opts & PF_OPT_VERBOSE2));
1587 		print_rule(r, r->anchor ? r->anchor->name : "",
1588 		    pf->opts & PF_OPT_VERBOSE2,
1589 		    pf->opts & PF_OPT_NUMERIC);
1590 	}
1591 	path[len] = '\0';
1592 	pfctl_clear_pool(&r->rpool);
1593 	return (0);
1594 }
1595 
1596 int
1597 pfctl_add_altq(struct pfctl *pf, struct pf_altq *a)
1598 {
1599 	if (altqsupport &&
1600 	    (loadopt & PFCTL_FLAG_ALTQ) != 0) {
1601 		memcpy(&pf->paltq->altq, a, sizeof(struct pf_altq));
1602 		if ((pf->opts & PF_OPT_NOACTION) == 0) {
1603 			if (ioctl(pf->dev, DIOCADDALTQ, pf->paltq)) {
1604 				if (errno == ENXIO)
1605 					errx(1, "qtype not configured");
1606 				else if (errno == ENODEV)
1607 					errx(1, "%s: driver does not support "
1608 					    "altq", a->ifname);
1609 				else
1610 					err(1, "DIOCADDALTQ");
1611 			}
1612 		}
1613 		pfaltq_store(&pf->paltq->altq);
1614 	}
1615 	return (0);
1616 }
1617 
1618 int
1619 pfctl_rules(int dev, char *filename, int opts, int optimize,
1620     char *anchorname, struct pfr_buffer *trans)
1621 {
1622 #define ERR(x) do { warn(x); goto _error; } while(0)
1623 #define ERRX(x) do { warnx(x); goto _error; } while(0)
1624 
1625 	struct pfr_buffer	*t, buf;
1626 	struct pfioc_altq	 pa;
1627 	struct pfctl		 pf;
1628 	struct pfctl_ruleset	*rs;
1629 	struct pfr_table	 trs;
1630 	char			*path;
1631 	int			 osize;
1632 
1633 	RB_INIT(&pf_anchors);
1634 	memset(&pf_main_anchor, 0, sizeof(pf_main_anchor));
1635 	pf_init_ruleset(&pf_main_anchor.ruleset);
1636 	pf_main_anchor.ruleset.anchor = &pf_main_anchor;
1637 	if (trans == NULL) {
1638 		bzero(&buf, sizeof(buf));
1639 		buf.pfrb_type = PFRB_TRANS;
1640 		t = &buf;
1641 		osize = 0;
1642 	} else {
1643 		t = trans;
1644 		osize = t->pfrb_size;
1645 	}
1646 
1647 	memset(&pa, 0, sizeof(pa));
1648 	pa.version = PFIOC_ALTQ_VERSION;
1649 	memset(&pf, 0, sizeof(pf));
1650 	memset(&trs, 0, sizeof(trs));
1651 	if ((path = calloc(1, MAXPATHLEN)) == NULL)
1652 		ERRX("pfctl_rules: calloc");
1653 	if (strlcpy(trs.pfrt_anchor, anchorname,
1654 	    sizeof(trs.pfrt_anchor)) >= sizeof(trs.pfrt_anchor))
1655 		ERRX("pfctl_rules: strlcpy");
1656 	pf.dev = dev;
1657 	pf.opts = opts;
1658 	pf.optimize = optimize;
1659 	pf.loadopt = loadopt;
1660 
1661 	/* non-brace anchor, create without resolving the path */
1662 	if ((pf.anchor = calloc(1, sizeof(*pf.anchor))) == NULL)
1663 		ERRX("pfctl_rules: calloc");
1664 	rs = &pf.anchor->ruleset;
1665 	pf_init_ruleset(rs);
1666 	rs->anchor = pf.anchor;
1667 	if (strlcpy(pf.anchor->path, anchorname,
1668 	    sizeof(pf.anchor->path)) >= sizeof(pf.anchor->path))
1669 		errx(1, "pfctl_add_rule: strlcpy");
1670 	if (strlcpy(pf.anchor->name, anchorname,
1671 	    sizeof(pf.anchor->name)) >= sizeof(pf.anchor->name))
1672 		errx(1, "pfctl_add_rule: strlcpy");
1673 
1674 
1675 	pf.astack[0] = pf.anchor;
1676 	pf.asd = 0;
1677 	if (anchorname[0])
1678 		pf.loadopt &= ~PFCTL_FLAG_ALTQ;
1679 	pf.paltq = &pa;
1680 	pf.trans = t;
1681 	pfctl_init_options(&pf);
1682 
1683 	if ((opts & PF_OPT_NOACTION) == 0) {
1684 		/*
1685 		 * XXX For the time being we need to open transactions for
1686 		 * the main ruleset before parsing, because tables are still
1687 		 * loaded at parse time.
1688 		 */
1689 		if (pfctl_ruleset_trans(&pf, anchorname, pf.anchor))
1690 			ERRX("pfctl_rules");
1691 		if (altqsupport && (pf.loadopt & PFCTL_FLAG_ALTQ))
1692 			pa.ticket =
1693 			    pfctl_get_ticket(t, PF_RULESET_ALTQ, anchorname);
1694 		if (pf.loadopt & PFCTL_FLAG_TABLE)
1695 			pf.astack[0]->ruleset.tticket =
1696 			    pfctl_get_ticket(t, PF_RULESET_TABLE, anchorname);
1697 	}
1698 
1699 	if (parse_config(filename, &pf) < 0) {
1700 		if ((opts & PF_OPT_NOACTION) == 0)
1701 			ERRX("Syntax error in config file: "
1702 			    "pf rules not loaded");
1703 		else
1704 			goto _error;
1705 	}
1706 	if (loadopt & PFCTL_FLAG_OPTION)
1707 		pfctl_adjust_skip_ifaces(&pf);
1708 
1709 	if ((pf.loadopt & PFCTL_FLAG_FILTER &&
1710 	    (pfctl_load_ruleset(&pf, path, rs, PF_RULESET_SCRUB, 0))) ||
1711 	    (pf.loadopt & PFCTL_FLAG_NAT &&
1712 	    (pfctl_load_ruleset(&pf, path, rs, PF_RULESET_NAT, 0) ||
1713 	    pfctl_load_ruleset(&pf, path, rs, PF_RULESET_RDR, 0) ||
1714 	    pfctl_load_ruleset(&pf, path, rs, PF_RULESET_BINAT, 0))) ||
1715 	    (pf.loadopt & PFCTL_FLAG_FILTER &&
1716 	    pfctl_load_ruleset(&pf, path, rs, PF_RULESET_FILTER, 0))) {
1717 		if ((opts & PF_OPT_NOACTION) == 0)
1718 			ERRX("Unable to load rules into kernel");
1719 		else
1720 			goto _error;
1721 	}
1722 
1723 	if ((altqsupport && (pf.loadopt & PFCTL_FLAG_ALTQ) != 0))
1724 		if (check_commit_altq(dev, opts) != 0)
1725 			ERRX("errors in altq config");
1726 
1727 	/* process "load anchor" directives */
1728 	if (!anchorname[0])
1729 		if (pfctl_load_anchors(dev, &pf, t) == -1)
1730 			ERRX("load anchors");
1731 
1732 	if (trans == NULL && (opts & PF_OPT_NOACTION) == 0) {
1733 		if (!anchorname[0])
1734 			if (pfctl_load_options(&pf))
1735 				goto _error;
1736 		if (pfctl_trans(dev, t, DIOCXCOMMIT, osize))
1737 			ERR("DIOCXCOMMIT");
1738 	}
1739 	free(path);
1740 	return (0);
1741 
1742 _error:
1743 	if (trans == NULL) {	/* main ruleset */
1744 		if ((opts & PF_OPT_NOACTION) == 0)
1745 			if (pfctl_trans(dev, t, DIOCXROLLBACK, osize))
1746 				err(1, "DIOCXROLLBACK");
1747 		exit(1);
1748 	} else {		/* sub ruleset */
1749 		free(path);
1750 		return (-1);
1751 	}
1752 
1753 #undef ERR
1754 #undef ERRX
1755 }
1756 
1757 FILE *
1758 pfctl_fopen(const char *name, const char *mode)
1759 {
1760 	struct stat	 st;
1761 	FILE		*fp;
1762 
1763 	fp = fopen(name, mode);
1764 	if (fp == NULL)
1765 		return (NULL);
1766 	if (fstat(fileno(fp), &st)) {
1767 		fclose(fp);
1768 		return (NULL);
1769 	}
1770 	if (S_ISDIR(st.st_mode)) {
1771 		fclose(fp);
1772 		errno = EISDIR;
1773 		return (NULL);
1774 	}
1775 	return (fp);
1776 }
1777 
1778 void
1779 pfctl_init_options(struct pfctl *pf)
1780 {
1781 
1782 	pf->timeout[PFTM_TCP_FIRST_PACKET] = PFTM_TCP_FIRST_PACKET_VAL;
1783 	pf->timeout[PFTM_TCP_OPENING] = PFTM_TCP_OPENING_VAL;
1784 	pf->timeout[PFTM_TCP_ESTABLISHED] = PFTM_TCP_ESTABLISHED_VAL;
1785 	pf->timeout[PFTM_TCP_CLOSING] = PFTM_TCP_CLOSING_VAL;
1786 	pf->timeout[PFTM_TCP_FIN_WAIT] = PFTM_TCP_FIN_WAIT_VAL;
1787 	pf->timeout[PFTM_TCP_CLOSED] = PFTM_TCP_CLOSED_VAL;
1788 	pf->timeout[PFTM_UDP_FIRST_PACKET] = PFTM_UDP_FIRST_PACKET_VAL;
1789 	pf->timeout[PFTM_UDP_SINGLE] = PFTM_UDP_SINGLE_VAL;
1790 	pf->timeout[PFTM_UDP_MULTIPLE] = PFTM_UDP_MULTIPLE_VAL;
1791 	pf->timeout[PFTM_ICMP_FIRST_PACKET] = PFTM_ICMP_FIRST_PACKET_VAL;
1792 	pf->timeout[PFTM_ICMP_ERROR_REPLY] = PFTM_ICMP_ERROR_REPLY_VAL;
1793 	pf->timeout[PFTM_OTHER_FIRST_PACKET] = PFTM_OTHER_FIRST_PACKET_VAL;
1794 	pf->timeout[PFTM_OTHER_SINGLE] = PFTM_OTHER_SINGLE_VAL;
1795 	pf->timeout[PFTM_OTHER_MULTIPLE] = PFTM_OTHER_MULTIPLE_VAL;
1796 	pf->timeout[PFTM_FRAG] = PFTM_FRAG_VAL;
1797 	pf->timeout[PFTM_INTERVAL] = PFTM_INTERVAL_VAL;
1798 	pf->timeout[PFTM_SRC_NODE] = PFTM_SRC_NODE_VAL;
1799 	pf->timeout[PFTM_TS_DIFF] = PFTM_TS_DIFF_VAL;
1800 	pf->timeout[PFTM_ADAPTIVE_START] = PFSTATE_ADAPT_START;
1801 	pf->timeout[PFTM_ADAPTIVE_END] = PFSTATE_ADAPT_END;
1802 
1803 	pf->limit[PF_LIMIT_STATES] = PFSTATE_HIWAT;
1804 	pf->limit[PF_LIMIT_FRAGS] = PFFRAG_FRENT_HIWAT;
1805 	pf->limit[PF_LIMIT_SRC_NODES] = PFSNODE_HIWAT;
1806 	pf->limit[PF_LIMIT_TABLE_ENTRIES] = PFR_KENTRY_HIWAT;
1807 
1808 	pf->debug = PF_DEBUG_URGENT;
1809 }
1810 
1811 int
1812 pfctl_load_options(struct pfctl *pf)
1813 {
1814 	int i, error = 0;
1815 
1816 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
1817 		return (0);
1818 
1819 	/* load limits */
1820 	for (i = 0; i < PF_LIMIT_MAX; i++) {
1821 		if ((pf->opts & PF_OPT_MERGE) && !pf->limit_set[i])
1822 			continue;
1823 		if (pfctl_load_limit(pf, i, pf->limit[i]))
1824 			error = 1;
1825 	}
1826 
1827 	/*
1828 	 * If we've set the limit, but haven't explicitly set adaptive
1829 	 * timeouts, do it now with a start of 60% and end of 120%.
1830 	 */
1831 	if (pf->limit_set[PF_LIMIT_STATES] &&
1832 	    !pf->timeout_set[PFTM_ADAPTIVE_START] &&
1833 	    !pf->timeout_set[PFTM_ADAPTIVE_END]) {
1834 		pf->timeout[PFTM_ADAPTIVE_START] =
1835 			(pf->limit[PF_LIMIT_STATES] / 10) * 6;
1836 		pf->timeout_set[PFTM_ADAPTIVE_START] = 1;
1837 		pf->timeout[PFTM_ADAPTIVE_END] =
1838 			(pf->limit[PF_LIMIT_STATES] / 10) * 12;
1839 		pf->timeout_set[PFTM_ADAPTIVE_END] = 1;
1840 	}
1841 
1842 	/* load timeouts */
1843 	for (i = 0; i < PFTM_MAX; i++) {
1844 		if ((pf->opts & PF_OPT_MERGE) && !pf->timeout_set[i])
1845 			continue;
1846 		if (pfctl_load_timeout(pf, i, pf->timeout[i]))
1847 			error = 1;
1848 	}
1849 
1850 	/* load debug */
1851 	if (!(pf->opts & PF_OPT_MERGE) || pf->debug_set)
1852 		if (pfctl_load_debug(pf, pf->debug))
1853 			error = 1;
1854 
1855 	/* load logif */
1856 	if (!(pf->opts & PF_OPT_MERGE) || pf->ifname_set)
1857 		if (pfctl_load_logif(pf, pf->ifname))
1858 			error = 1;
1859 
1860 	/* load hostid */
1861 	if (!(pf->opts & PF_OPT_MERGE) || pf->hostid_set)
1862 		if (pfctl_load_hostid(pf, pf->hostid))
1863 			error = 1;
1864 
1865 	/* load keepcounters */
1866 	if (pfctl_set_keepcounters(pf->dev, pf->keep_counters))
1867 		error = 1;
1868 
1869 	/* load syncookies settings */
1870 	if (pfctl_load_syncookies(pf, pf->syncookies))
1871 		error = 1;
1872 
1873 	return (error);
1874 }
1875 
1876 int
1877 pfctl_set_limit(struct pfctl *pf, const char *opt, unsigned int limit)
1878 {
1879 	int i;
1880 
1881 
1882 	for (i = 0; pf_limits[i].name; i++) {
1883 		if (strcasecmp(opt, pf_limits[i].name) == 0) {
1884 			pf->limit[pf_limits[i].index] = limit;
1885 			pf->limit_set[pf_limits[i].index] = 1;
1886 			break;
1887 		}
1888 	}
1889 	if (pf_limits[i].name == NULL) {
1890 		warnx("Bad pool name.");
1891 		return (1);
1892 	}
1893 
1894 	if (pf->opts & PF_OPT_VERBOSE)
1895 		printf("set limit %s %d\n", opt, limit);
1896 
1897 	return (0);
1898 }
1899 
1900 int
1901 pfctl_load_limit(struct pfctl *pf, unsigned int index, unsigned int limit)
1902 {
1903 	struct pfioc_limit pl;
1904 
1905 	memset(&pl, 0, sizeof(pl));
1906 	pl.index = index;
1907 	pl.limit = limit;
1908 	if (ioctl(pf->dev, DIOCSETLIMIT, &pl)) {
1909 		if (errno == EBUSY)
1910 			warnx("Current pool size exceeds requested hard limit");
1911 		else
1912 			warnx("DIOCSETLIMIT");
1913 		return (1);
1914 	}
1915 	return (0);
1916 }
1917 
1918 int
1919 pfctl_set_timeout(struct pfctl *pf, const char *opt, int seconds, int quiet)
1920 {
1921 	int i;
1922 
1923 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
1924 		return (0);
1925 
1926 	for (i = 0; pf_timeouts[i].name; i++) {
1927 		if (strcasecmp(opt, pf_timeouts[i].name) == 0) {
1928 			pf->timeout[pf_timeouts[i].timeout] = seconds;
1929 			pf->timeout_set[pf_timeouts[i].timeout] = 1;
1930 			break;
1931 		}
1932 	}
1933 
1934 	if (pf_timeouts[i].name == NULL) {
1935 		warnx("Bad timeout name.");
1936 		return (1);
1937 	}
1938 
1939 
1940 	if (pf->opts & PF_OPT_VERBOSE && ! quiet)
1941 		printf("set timeout %s %d\n", opt, seconds);
1942 
1943 	return (0);
1944 }
1945 
1946 int
1947 pfctl_load_timeout(struct pfctl *pf, unsigned int timeout, unsigned int seconds)
1948 {
1949 	struct pfioc_tm pt;
1950 
1951 	memset(&pt, 0, sizeof(pt));
1952 	pt.timeout = timeout;
1953 	pt.seconds = seconds;
1954 	if (ioctl(pf->dev, DIOCSETTIMEOUT, &pt)) {
1955 		warnx("DIOCSETTIMEOUT");
1956 		return (1);
1957 	}
1958 	return (0);
1959 }
1960 
1961 int
1962 pfctl_set_optimization(struct pfctl *pf, const char *opt)
1963 {
1964 	const struct pf_hint *hint;
1965 	int i, r;
1966 
1967 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
1968 		return (0);
1969 
1970 	for (i = 0; pf_hints[i].name; i++)
1971 		if (strcasecmp(opt, pf_hints[i].name) == 0)
1972 			break;
1973 
1974 	hint = pf_hints[i].hint;
1975 	if (hint == NULL) {
1976 		warnx("invalid state timeouts optimization");
1977 		return (1);
1978 	}
1979 
1980 	for (i = 0; hint[i].name; i++)
1981 		if ((r = pfctl_set_timeout(pf, hint[i].name,
1982 		    hint[i].timeout, 1)))
1983 			return (r);
1984 
1985 	if (pf->opts & PF_OPT_VERBOSE)
1986 		printf("set optimization %s\n", opt);
1987 
1988 	return (0);
1989 }
1990 
1991 int
1992 pfctl_set_logif(struct pfctl *pf, char *ifname)
1993 {
1994 
1995 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
1996 		return (0);
1997 
1998 	if (!strcmp(ifname, "none")) {
1999 		free(pf->ifname);
2000 		pf->ifname = NULL;
2001 	} else {
2002 		pf->ifname = strdup(ifname);
2003 		if (!pf->ifname)
2004 			errx(1, "pfctl_set_logif: strdup");
2005 	}
2006 	pf->ifname_set = 1;
2007 
2008 	if (pf->opts & PF_OPT_VERBOSE)
2009 		printf("set loginterface %s\n", ifname);
2010 
2011 	return (0);
2012 }
2013 
2014 int
2015 pfctl_load_logif(struct pfctl *pf, char *ifname)
2016 {
2017 	struct pfioc_if pi;
2018 
2019 	memset(&pi, 0, sizeof(pi));
2020 	if (ifname && strlcpy(pi.ifname, ifname,
2021 	    sizeof(pi.ifname)) >= sizeof(pi.ifname)) {
2022 		warnx("pfctl_load_logif: strlcpy");
2023 		return (1);
2024 	}
2025 	if (ioctl(pf->dev, DIOCSETSTATUSIF, &pi)) {
2026 		warnx("DIOCSETSTATUSIF");
2027 		return (1);
2028 	}
2029 	return (0);
2030 }
2031 
2032 int
2033 pfctl_set_hostid(struct pfctl *pf, u_int32_t hostid)
2034 {
2035 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
2036 		return (0);
2037 
2038 	HTONL(hostid);
2039 
2040 	pf->hostid = hostid;
2041 	pf->hostid_set = 1;
2042 
2043 	if (pf->opts & PF_OPT_VERBOSE)
2044 		printf("set hostid 0x%08x\n", ntohl(hostid));
2045 
2046 	return (0);
2047 }
2048 
2049 int
2050 pfctl_load_hostid(struct pfctl *pf, u_int32_t hostid)
2051 {
2052 	if (ioctl(dev, DIOCSETHOSTID, &hostid)) {
2053 		warnx("DIOCSETHOSTID");
2054 		return (1);
2055 	}
2056 	return (0);
2057 }
2058 
2059 int
2060 pfctl_load_syncookies(struct pfctl *pf, u_int8_t val)
2061 {
2062 	struct pfctl_syncookies	cookies;
2063 
2064 	bzero(&cookies, sizeof(cookies));
2065 
2066 	cookies.mode = val ? PFCTL_SYNCOOKIES_ALWAYS : PFCTL_SYNCOOKIES_NEVER;
2067 
2068 	if (pfctl_set_syncookies(dev, &cookies)) {
2069 		warnx("DIOCSETSYNCOOKIES");
2070 		return (1);
2071 	}
2072 	return (0);
2073 }
2074 
2075 int
2076 pfctl_set_debug(struct pfctl *pf, char *d)
2077 {
2078 	u_int32_t	level;
2079 
2080 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
2081 		return (0);
2082 
2083 	if (!strcmp(d, "none"))
2084 		pf->debug = PF_DEBUG_NONE;
2085 	else if (!strcmp(d, "urgent"))
2086 		pf->debug = PF_DEBUG_URGENT;
2087 	else if (!strcmp(d, "misc"))
2088 		pf->debug = PF_DEBUG_MISC;
2089 	else if (!strcmp(d, "loud"))
2090 		pf->debug = PF_DEBUG_NOISY;
2091 	else {
2092 		warnx("unknown debug level \"%s\"", d);
2093 		return (-1);
2094 	}
2095 
2096 	pf->debug_set = 1;
2097 	level = pf->debug;
2098 
2099 	if ((pf->opts & PF_OPT_NOACTION) == 0)
2100 		if (ioctl(dev, DIOCSETDEBUG, &level))
2101 			err(1, "DIOCSETDEBUG");
2102 
2103 	if (pf->opts & PF_OPT_VERBOSE)
2104 		printf("set debug %s\n", d);
2105 
2106 	return (0);
2107 }
2108 
2109 int
2110 pfctl_load_debug(struct pfctl *pf, unsigned int level)
2111 {
2112 	if (ioctl(pf->dev, DIOCSETDEBUG, &level)) {
2113 		warnx("DIOCSETDEBUG");
2114 		return (1);
2115 	}
2116 	return (0);
2117 }
2118 
2119 int
2120 pfctl_set_interface_flags(struct pfctl *pf, char *ifname, int flags, int how)
2121 {
2122 	struct pfioc_iface	pi;
2123 	struct node_host	*h = NULL, *n = NULL;
2124 
2125 	if ((loadopt & PFCTL_FLAG_OPTION) == 0)
2126 		return (0);
2127 
2128 	bzero(&pi, sizeof(pi));
2129 
2130 	pi.pfiio_flags = flags;
2131 
2132 	/* Make sure our cache matches the kernel. If we set or clear the flag
2133 	 * for a group this applies to all members. */
2134 	h = ifa_grouplookup(ifname, 0);
2135 	for (n = h; n != NULL; n = n->next)
2136 		pfctl_set_interface_flags(pf, n->ifname, flags, how);
2137 
2138 	if (strlcpy(pi.pfiio_name, ifname, sizeof(pi.pfiio_name)) >=
2139 	    sizeof(pi.pfiio_name))
2140 		errx(1, "pfctl_set_interface_flags: strlcpy");
2141 
2142 	if ((pf->opts & PF_OPT_NOACTION) == 0) {
2143 		if (how == 0) {
2144 			if (ioctl(pf->dev, DIOCCLRIFFLAG, &pi))
2145 				err(1, "DIOCCLRIFFLAG");
2146 		} else {
2147 			if (ioctl(pf->dev, DIOCSETIFFLAG, &pi))
2148 				err(1, "DIOCSETIFFLAG");
2149 			pfctl_check_skip_ifaces(ifname);
2150 		}
2151 	}
2152 	return (0);
2153 }
2154 
2155 void
2156 pfctl_debug(int dev, u_int32_t level, int opts)
2157 {
2158 	if (ioctl(dev, DIOCSETDEBUG, &level))
2159 		err(1, "DIOCSETDEBUG");
2160 	if ((opts & PF_OPT_QUIET) == 0) {
2161 		fprintf(stderr, "debug level set to '");
2162 		switch (level) {
2163 		case PF_DEBUG_NONE:
2164 			fprintf(stderr, "none");
2165 			break;
2166 		case PF_DEBUG_URGENT:
2167 			fprintf(stderr, "urgent");
2168 			break;
2169 		case PF_DEBUG_MISC:
2170 			fprintf(stderr, "misc");
2171 			break;
2172 		case PF_DEBUG_NOISY:
2173 			fprintf(stderr, "loud");
2174 			break;
2175 		default:
2176 			fprintf(stderr, "<invalid>");
2177 			break;
2178 		}
2179 		fprintf(stderr, "'\n");
2180 	}
2181 }
2182 
2183 int
2184 pfctl_test_altqsupport(int dev, int opts)
2185 {
2186 	struct pfioc_altq pa;
2187 
2188 	pa.version = PFIOC_ALTQ_VERSION;
2189 	if (ioctl(dev, DIOCGETALTQS, &pa)) {
2190 		if (errno == ENODEV) {
2191 			if (opts & PF_OPT_VERBOSE)
2192 				fprintf(stderr, "No ALTQ support in kernel\n"
2193 				    "ALTQ related functions disabled\n");
2194 			return (0);
2195 		} else
2196 			err(1, "DIOCGETALTQS");
2197 	}
2198 	return (1);
2199 }
2200 
2201 int
2202 pfctl_show_anchors(int dev, int opts, char *anchorname)
2203 {
2204 	struct pfioc_ruleset	 pr;
2205 	u_int32_t		 mnr, nr;
2206 
2207 	memset(&pr, 0, sizeof(pr));
2208 	memcpy(pr.path, anchorname, sizeof(pr.path));
2209 	if (ioctl(dev, DIOCGETRULESETS, &pr)) {
2210 		if (errno == EINVAL)
2211 			fprintf(stderr, "Anchor '%s' not found.\n",
2212 			    anchorname);
2213 		else
2214 			err(1, "DIOCGETRULESETS");
2215 		return (-1);
2216 	}
2217 	mnr = pr.nr;
2218 	for (nr = 0; nr < mnr; ++nr) {
2219 		char sub[MAXPATHLEN];
2220 
2221 		pr.nr = nr;
2222 		if (ioctl(dev, DIOCGETRULESET, &pr))
2223 			err(1, "DIOCGETRULESET");
2224 		if (!strcmp(pr.name, PF_RESERVED_ANCHOR))
2225 			continue;
2226 		sub[0] = 0;
2227 		if (pr.path[0]) {
2228 			strlcat(sub, pr.path, sizeof(sub));
2229 			strlcat(sub, "/", sizeof(sub));
2230 		}
2231 		strlcat(sub, pr.name, sizeof(sub));
2232 		if (sub[0] != '_' || (opts & PF_OPT_VERBOSE))
2233 			printf("  %s\n", sub);
2234 		if ((opts & PF_OPT_VERBOSE) && pfctl_show_anchors(dev, opts, sub))
2235 			return (-1);
2236 	}
2237 	return (0);
2238 }
2239 
2240 const char *
2241 pfctl_lookup_option(char *cmd, const char * const *list)
2242 {
2243 	if (cmd != NULL && *cmd)
2244 		for (; *list; list++)
2245 			if (!strncmp(cmd, *list, strlen(cmd)))
2246 				return (*list);
2247 	return (NULL);
2248 }
2249 
2250 int
2251 main(int argc, char *argv[])
2252 {
2253 	int	 error = 0;
2254 	int	 ch;
2255 	int	 mode = O_RDONLY;
2256 	int	 opts = 0;
2257 	int	 optimize = PF_OPTIMIZE_BASIC;
2258 	char	 anchorname[MAXPATHLEN];
2259 	char	*path;
2260 
2261 	if (argc < 2)
2262 		usage();
2263 
2264 	while ((ch = getopt(argc, argv,
2265 	    "a:AdD:eqf:F:ghi:k:K:mMnNOo:Pp:rRs:t:T:vx:z")) != -1) {
2266 		switch (ch) {
2267 		case 'a':
2268 			anchoropt = optarg;
2269 			break;
2270 		case 'd':
2271 			opts |= PF_OPT_DISABLE;
2272 			mode = O_RDWR;
2273 			break;
2274 		case 'D':
2275 			if (pfctl_cmdline_symset(optarg) < 0)
2276 				warnx("could not parse macro definition %s",
2277 				    optarg);
2278 			break;
2279 		case 'e':
2280 			opts |= PF_OPT_ENABLE;
2281 			mode = O_RDWR;
2282 			break;
2283 		case 'q':
2284 			opts |= PF_OPT_QUIET;
2285 			break;
2286 		case 'F':
2287 			clearopt = pfctl_lookup_option(optarg, clearopt_list);
2288 			if (clearopt == NULL) {
2289 				warnx("Unknown flush modifier '%s'", optarg);
2290 				usage();
2291 			}
2292 			mode = O_RDWR;
2293 			break;
2294 		case 'i':
2295 			ifaceopt = optarg;
2296 			break;
2297 		case 'k':
2298 			if (state_killers >= 2) {
2299 				warnx("can only specify -k twice");
2300 				usage();
2301 				/* NOTREACHED */
2302 			}
2303 			state_kill[state_killers++] = optarg;
2304 			mode = O_RDWR;
2305 			break;
2306 		case 'K':
2307 			if (src_node_killers >= 2) {
2308 				warnx("can only specify -K twice");
2309 				usage();
2310 				/* NOTREACHED */
2311 			}
2312 			src_node_kill[src_node_killers++] = optarg;
2313 			mode = O_RDWR;
2314 			break;
2315 		case 'm':
2316 			opts |= PF_OPT_MERGE;
2317 			break;
2318 		case 'M':
2319 			opts |= PF_OPT_KILLMATCH;
2320 			break;
2321 		case 'n':
2322 			opts |= PF_OPT_NOACTION;
2323 			break;
2324 		case 'N':
2325 			loadopt |= PFCTL_FLAG_NAT;
2326 			break;
2327 		case 'r':
2328 			opts |= PF_OPT_USEDNS;
2329 			break;
2330 		case 'f':
2331 			rulesopt = optarg;
2332 			mode = O_RDWR;
2333 			break;
2334 		case 'g':
2335 			opts |= PF_OPT_DEBUG;
2336 			break;
2337 		case 'A':
2338 			loadopt |= PFCTL_FLAG_ALTQ;
2339 			break;
2340 		case 'R':
2341 			loadopt |= PFCTL_FLAG_FILTER;
2342 			break;
2343 		case 'o':
2344 			optiopt = pfctl_lookup_option(optarg, optiopt_list);
2345 			if (optiopt == NULL) {
2346 				warnx("Unknown optimization '%s'", optarg);
2347 				usage();
2348 			}
2349 			opts |= PF_OPT_OPTIMIZE;
2350 			break;
2351 		case 'O':
2352 			loadopt |= PFCTL_FLAG_OPTION;
2353 			break;
2354 		case 'p':
2355 			pf_device = optarg;
2356 			break;
2357 		case 'P':
2358 			opts |= PF_OPT_NUMERIC;
2359 			break;
2360 		case 's':
2361 			showopt = pfctl_lookup_option(optarg, showopt_list);
2362 			if (showopt == NULL) {
2363 				warnx("Unknown show modifier '%s'", optarg);
2364 				usage();
2365 			}
2366 			break;
2367 		case 't':
2368 			tableopt = optarg;
2369 			break;
2370 		case 'T':
2371 			tblcmdopt = pfctl_lookup_option(optarg, tblcmdopt_list);
2372 			if (tblcmdopt == NULL) {
2373 				warnx("Unknown table command '%s'", optarg);
2374 				usage();
2375 			}
2376 			break;
2377 		case 'v':
2378 			if (opts & PF_OPT_VERBOSE)
2379 				opts |= PF_OPT_VERBOSE2;
2380 			opts |= PF_OPT_VERBOSE;
2381 			break;
2382 		case 'x':
2383 			debugopt = pfctl_lookup_option(optarg, debugopt_list);
2384 			if (debugopt == NULL) {
2385 				warnx("Unknown debug level '%s'", optarg);
2386 				usage();
2387 			}
2388 			mode = O_RDWR;
2389 			break;
2390 		case 'z':
2391 			opts |= PF_OPT_CLRRULECTRS;
2392 			mode = O_RDWR;
2393 			break;
2394 		case 'h':
2395 			/* FALLTHROUGH */
2396 		default:
2397 			usage();
2398 			/* NOTREACHED */
2399 		}
2400 	}
2401 
2402 	if (tblcmdopt != NULL) {
2403 		argc -= optind;
2404 		argv += optind;
2405 		ch = *tblcmdopt;
2406 		if (ch == 'l') {
2407 			loadopt |= PFCTL_FLAG_TABLE;
2408 			tblcmdopt = NULL;
2409 		} else
2410 			mode = strchr("acdefkrz", ch) ? O_RDWR : O_RDONLY;
2411 	} else if (argc != optind) {
2412 		warnx("unknown command line argument: %s ...", argv[optind]);
2413 		usage();
2414 		/* NOTREACHED */
2415 	}
2416 	if (loadopt == 0)
2417 		loadopt = ~0;
2418 
2419 	if ((path = calloc(1, MAXPATHLEN)) == NULL)
2420 		errx(1, "pfctl: calloc");
2421 	memset(anchorname, 0, sizeof(anchorname));
2422 	if (anchoropt != NULL) {
2423 		int len = strlen(anchoropt);
2424 
2425 		if (anchoropt[len - 1] == '*') {
2426 			if (len >= 2 && anchoropt[len - 2] == '/')
2427 				anchoropt[len - 2] = '\0';
2428 			else
2429 				anchoropt[len - 1] = '\0';
2430 			opts |= PF_OPT_RECURSE;
2431 		}
2432 		if (strlcpy(anchorname, anchoropt,
2433 		    sizeof(anchorname)) >= sizeof(anchorname))
2434 			errx(1, "anchor name '%s' too long",
2435 			    anchoropt);
2436 		loadopt &= PFCTL_FLAG_FILTER|PFCTL_FLAG_NAT|PFCTL_FLAG_TABLE;
2437 	}
2438 
2439 	if ((opts & PF_OPT_NOACTION) == 0) {
2440 		dev = open(pf_device, mode);
2441 		if (dev == -1)
2442 			err(1, "%s", pf_device);
2443 		altqsupport = pfctl_test_altqsupport(dev, opts);
2444 	} else {
2445 		dev = open(pf_device, O_RDONLY);
2446 		if (dev >= 0)
2447 			opts |= PF_OPT_DUMMYACTION;
2448 		/* turn off options */
2449 		opts &= ~ (PF_OPT_DISABLE | PF_OPT_ENABLE);
2450 		clearopt = showopt = debugopt = NULL;
2451 #if !defined(ENABLE_ALTQ)
2452 		altqsupport = 0;
2453 #else
2454 		altqsupport = 1;
2455 #endif
2456 	}
2457 
2458 	if (opts & PF_OPT_DISABLE)
2459 		if (pfctl_disable(dev, opts))
2460 			error = 1;
2461 
2462 	if (showopt != NULL) {
2463 		switch (*showopt) {
2464 		case 'A':
2465 			pfctl_show_anchors(dev, opts, anchorname);
2466 			break;
2467 		case 'r':
2468 			pfctl_load_fingerprints(dev, opts);
2469 			pfctl_show_rules(dev, path, opts, PFCTL_SHOW_RULES,
2470 			    anchorname, 0);
2471 			break;
2472 		case 'l':
2473 			pfctl_load_fingerprints(dev, opts);
2474 			pfctl_show_rules(dev, path, opts, PFCTL_SHOW_LABELS,
2475 			    anchorname, 0);
2476 			break;
2477 		case 'n':
2478 			pfctl_load_fingerprints(dev, opts);
2479 			pfctl_show_nat(dev, opts, anchorname);
2480 			break;
2481 		case 'q':
2482 			pfctl_show_altq(dev, ifaceopt, opts,
2483 			    opts & PF_OPT_VERBOSE2);
2484 			break;
2485 		case 's':
2486 			pfctl_show_states(dev, ifaceopt, opts);
2487 			break;
2488 		case 'S':
2489 			pfctl_show_src_nodes(dev, opts);
2490 			break;
2491 		case 'i':
2492 			pfctl_show_status(dev, opts);
2493 			break;
2494 		case 'R':
2495 			error = pfctl_show_running(dev);
2496 			break;
2497 		case 't':
2498 			pfctl_show_timeouts(dev, opts);
2499 			break;
2500 		case 'm':
2501 			pfctl_show_limits(dev, opts);
2502 			break;
2503 		case 'a':
2504 			opts |= PF_OPT_SHOWALL;
2505 			pfctl_load_fingerprints(dev, opts);
2506 
2507 			pfctl_show_nat(dev, opts, anchorname);
2508 			pfctl_show_rules(dev, path, opts, 0, anchorname, 0);
2509 			pfctl_show_altq(dev, ifaceopt, opts, 0);
2510 			pfctl_show_states(dev, ifaceopt, opts);
2511 			pfctl_show_src_nodes(dev, opts);
2512 			pfctl_show_status(dev, opts);
2513 			pfctl_show_rules(dev, path, opts, 1, anchorname, 0);
2514 			pfctl_show_timeouts(dev, opts);
2515 			pfctl_show_limits(dev, opts);
2516 			pfctl_show_tables(anchorname, opts);
2517 			pfctl_show_fingerprints(opts);
2518 			break;
2519 		case 'T':
2520 			pfctl_show_tables(anchorname, opts);
2521 			break;
2522 		case 'o':
2523 			pfctl_load_fingerprints(dev, opts);
2524 			pfctl_show_fingerprints(opts);
2525 			break;
2526 		case 'I':
2527 			pfctl_show_ifaces(ifaceopt, opts);
2528 			break;
2529 		}
2530 	}
2531 
2532 	if ((opts & PF_OPT_CLRRULECTRS) && showopt == NULL)
2533 		pfctl_show_rules(dev, path, opts, PFCTL_SHOW_NOTHING,
2534 		    anchorname, 0);
2535 
2536 	if (clearopt != NULL) {
2537 		if (anchorname[0] == '_' || strstr(anchorname, "/_") != NULL)
2538 			errx(1, "anchor names beginning with '_' cannot "
2539 			    "be modified from the command line");
2540 
2541 		switch (*clearopt) {
2542 		case 'r':
2543 			pfctl_clear_rules(dev, opts, anchorname);
2544 			break;
2545 		case 'n':
2546 			pfctl_clear_nat(dev, opts, anchorname);
2547 			break;
2548 		case 'q':
2549 			pfctl_clear_altq(dev, opts);
2550 			break;
2551 		case 's':
2552 			pfctl_clear_iface_states(dev, ifaceopt, opts);
2553 			break;
2554 		case 'S':
2555 			pfctl_clear_src_nodes(dev, opts);
2556 			break;
2557 		case 'i':
2558 			pfctl_clear_stats(dev, opts);
2559 			break;
2560 		case 'a':
2561 			pfctl_clear_rules(dev, opts, anchorname);
2562 			pfctl_clear_nat(dev, opts, anchorname);
2563 			pfctl_clear_tables(anchorname, opts);
2564 			if (!*anchorname) {
2565 				pfctl_clear_altq(dev, opts);
2566 				pfctl_clear_iface_states(dev, ifaceopt, opts);
2567 				pfctl_clear_src_nodes(dev, opts);
2568 				pfctl_clear_stats(dev, opts);
2569 				pfctl_clear_fingerprints(dev, opts);
2570 				pfctl_clear_interface_flags(dev, opts);
2571 			}
2572 			break;
2573 		case 'o':
2574 			pfctl_clear_fingerprints(dev, opts);
2575 			break;
2576 		case 'T':
2577 			pfctl_clear_tables(anchorname, opts);
2578 			break;
2579 		}
2580 	}
2581 	if (state_killers) {
2582 		if (!strcmp(state_kill[0], "label"))
2583 			pfctl_label_kill_states(dev, ifaceopt, opts);
2584 		else if (!strcmp(state_kill[0], "id"))
2585 			pfctl_id_kill_states(dev, ifaceopt, opts);
2586 		else if (!strcmp(state_kill[0], "gateway"))
2587 			pfctl_gateway_kill_states(dev, ifaceopt, opts);
2588 		else
2589 			pfctl_net_kill_states(dev, ifaceopt, opts);
2590 	}
2591 
2592 	if (src_node_killers)
2593 		pfctl_kill_src_nodes(dev, ifaceopt, opts);
2594 
2595 	if (tblcmdopt != NULL) {
2596 		error = pfctl_command_tables(argc, argv, tableopt,
2597 		    tblcmdopt, rulesopt, anchorname, opts);
2598 		rulesopt = NULL;
2599 	}
2600 	if (optiopt != NULL) {
2601 		switch (*optiopt) {
2602 		case 'n':
2603 			optimize = 0;
2604 			break;
2605 		case 'b':
2606 			optimize |= PF_OPTIMIZE_BASIC;
2607 			break;
2608 		case 'o':
2609 		case 'p':
2610 			optimize |= PF_OPTIMIZE_PROFILE;
2611 			break;
2612 		}
2613 	}
2614 
2615 	if ((rulesopt != NULL) && (loadopt & PFCTL_FLAG_OPTION) &&
2616 	    !anchorname[0] && !(opts & PF_OPT_NOACTION))
2617 		if (pfctl_get_skip_ifaces())
2618 			error = 1;
2619 
2620 	if (rulesopt != NULL && !(opts & (PF_OPT_MERGE|PF_OPT_NOACTION)) &&
2621 	    !anchorname[0] && (loadopt & PFCTL_FLAG_OPTION))
2622 		if (pfctl_file_fingerprints(dev, opts, PF_OSFP_FILE))
2623 			error = 1;
2624 
2625 	if (rulesopt != NULL) {
2626 		if (anchorname[0] == '_' || strstr(anchorname, "/_") != NULL)
2627 			errx(1, "anchor names beginning with '_' cannot "
2628 			    "be modified from the command line");
2629 		if (pfctl_rules(dev, rulesopt, opts, optimize,
2630 		    anchorname, NULL))
2631 			error = 1;
2632 		else if (!(opts & PF_OPT_NOACTION) &&
2633 		    (loadopt & PFCTL_FLAG_TABLE))
2634 			warn_namespace_collision(NULL);
2635 	}
2636 
2637 	if (opts & PF_OPT_ENABLE)
2638 		if (pfctl_enable(dev, opts))
2639 			error = 1;
2640 
2641 	if (debugopt != NULL) {
2642 		switch (*debugopt) {
2643 		case 'n':
2644 			pfctl_debug(dev, PF_DEBUG_NONE, opts);
2645 			break;
2646 		case 'u':
2647 			pfctl_debug(dev, PF_DEBUG_URGENT, opts);
2648 			break;
2649 		case 'm':
2650 			pfctl_debug(dev, PF_DEBUG_MISC, opts);
2651 			break;
2652 		case 'l':
2653 			pfctl_debug(dev, PF_DEBUG_NOISY, opts);
2654 			break;
2655 		}
2656 	}
2657 
2658 	exit(error);
2659 }
2660