xref: /freebsd/sbin/pfctl/pfctl_parser.c (revision 13464e4a44fc58490a03bb8bfc7e3c972e9c30b2)
1 /*	$OpenBSD: pfctl_parser.c,v 1.240 2008/06/10 20:55:02 mcbride Exp $ */
2 
3 /*
4  * Copyright (c) 2001 Daniel Hartmeier
5  * Copyright (c) 2002,2003 Henning Brauer
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 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/socket.h>
40 #include <sys/param.h>
41 #include <sys/proc.h>
42 #include <net/if.h>
43 #include <netinet/in.h>
44 #include <netinet/in_systm.h>
45 #include <netinet/ip.h>
46 #include <netinet/ip_icmp.h>
47 #include <netinet/icmp6.h>
48 #include <net/pfvar.h>
49 #include <arpa/inet.h>
50 
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <ctype.h>
55 #include <netdb.h>
56 #include <stdarg.h>
57 #include <errno.h>
58 #include <err.h>
59 #include <ifaddrs.h>
60 #include <unistd.h>
61 
62 #include "pfctl_parser.h"
63 #include "pfctl.h"
64 
65 void		 print_op (u_int8_t, const char *, const char *);
66 void		 print_port (u_int8_t, u_int16_t, u_int16_t, const char *, int);
67 void		 print_ugid (u_int8_t, unsigned, unsigned, const char *, unsigned);
68 void		 print_flags (u_int8_t);
69 void		 print_fromto(struct pf_rule_addr *, pf_osfp_t,
70 		    struct pf_rule_addr *, u_int8_t, u_int8_t, int, int);
71 int		 ifa_skip_if(const char *filter, struct node_host *p);
72 
73 struct node_host	*ifa_grouplookup(const char *, int);
74 struct node_host	*host_if(const char *, int);
75 struct node_host	*host_v4(const char *, int);
76 struct node_host	*host_v6(const char *, int);
77 struct node_host	*host_dns(const char *, int, int);
78 
79 const char * const tcpflags = "FSRPAUEW";
80 
81 static const struct icmptypeent icmp_type[] = {
82 	{ "echoreq",	ICMP_ECHO },
83 	{ "echorep",	ICMP_ECHOREPLY },
84 	{ "unreach",	ICMP_UNREACH },
85 	{ "squench",	ICMP_SOURCEQUENCH },
86 	{ "redir",	ICMP_REDIRECT },
87 	{ "althost",	ICMP_ALTHOSTADDR },
88 	{ "routeradv",	ICMP_ROUTERADVERT },
89 	{ "routersol",	ICMP_ROUTERSOLICIT },
90 	{ "timex",	ICMP_TIMXCEED },
91 	{ "paramprob",	ICMP_PARAMPROB },
92 	{ "timereq",	ICMP_TSTAMP },
93 	{ "timerep",	ICMP_TSTAMPREPLY },
94 	{ "inforeq",	ICMP_IREQ },
95 	{ "inforep",	ICMP_IREQREPLY },
96 	{ "maskreq",	ICMP_MASKREQ },
97 	{ "maskrep",	ICMP_MASKREPLY },
98 	{ "trace",	ICMP_TRACEROUTE },
99 	{ "dataconv",	ICMP_DATACONVERR },
100 	{ "mobredir",	ICMP_MOBILE_REDIRECT },
101 	{ "ipv6-where",	ICMP_IPV6_WHEREAREYOU },
102 	{ "ipv6-here",	ICMP_IPV6_IAMHERE },
103 	{ "mobregreq",	ICMP_MOBILE_REGREQUEST },
104 	{ "mobregrep",	ICMP_MOBILE_REGREPLY },
105 	{ "skip",	ICMP_SKIP },
106 	{ "photuris",	ICMP_PHOTURIS }
107 };
108 
109 static const struct icmptypeent icmp6_type[] = {
110 	{ "unreach",	ICMP6_DST_UNREACH },
111 	{ "toobig",	ICMP6_PACKET_TOO_BIG },
112 	{ "timex",	ICMP6_TIME_EXCEEDED },
113 	{ "paramprob",	ICMP6_PARAM_PROB },
114 	{ "echoreq",	ICMP6_ECHO_REQUEST },
115 	{ "echorep",	ICMP6_ECHO_REPLY },
116 	{ "groupqry",	ICMP6_MEMBERSHIP_QUERY },
117 	{ "listqry",	MLD_LISTENER_QUERY },
118 	{ "grouprep",	ICMP6_MEMBERSHIP_REPORT },
119 	{ "listenrep",	MLD_LISTENER_REPORT },
120 	{ "groupterm",	ICMP6_MEMBERSHIP_REDUCTION },
121 	{ "listendone", MLD_LISTENER_DONE },
122 	{ "routersol",	ND_ROUTER_SOLICIT },
123 	{ "routeradv",	ND_ROUTER_ADVERT },
124 	{ "neighbrsol", ND_NEIGHBOR_SOLICIT },
125 	{ "neighbradv", ND_NEIGHBOR_ADVERT },
126 	{ "redir",	ND_REDIRECT },
127 	{ "routrrenum", ICMP6_ROUTER_RENUMBERING },
128 	{ "wrureq",	ICMP6_WRUREQUEST },
129 	{ "wrurep",	ICMP6_WRUREPLY },
130 	{ "fqdnreq",	ICMP6_FQDN_QUERY },
131 	{ "fqdnrep",	ICMP6_FQDN_REPLY },
132 	{ "niqry",	ICMP6_NI_QUERY },
133 	{ "nirep",	ICMP6_NI_REPLY },
134 	{ "mtraceresp",	MLD_MTRACE_RESP },
135 	{ "mtrace",	MLD_MTRACE }
136 };
137 
138 static const struct icmpcodeent icmp_code[] = {
139 	{ "net-unr",		ICMP_UNREACH,	ICMP_UNREACH_NET },
140 	{ "host-unr",		ICMP_UNREACH,	ICMP_UNREACH_HOST },
141 	{ "proto-unr",		ICMP_UNREACH,	ICMP_UNREACH_PROTOCOL },
142 	{ "port-unr",		ICMP_UNREACH,	ICMP_UNREACH_PORT },
143 	{ "needfrag",		ICMP_UNREACH,	ICMP_UNREACH_NEEDFRAG },
144 	{ "srcfail",		ICMP_UNREACH,	ICMP_UNREACH_SRCFAIL },
145 	{ "net-unk",		ICMP_UNREACH,	ICMP_UNREACH_NET_UNKNOWN },
146 	{ "host-unk",		ICMP_UNREACH,	ICMP_UNREACH_HOST_UNKNOWN },
147 	{ "isolate",		ICMP_UNREACH,	ICMP_UNREACH_ISOLATED },
148 	{ "net-prohib",		ICMP_UNREACH,	ICMP_UNREACH_NET_PROHIB },
149 	{ "host-prohib",	ICMP_UNREACH,	ICMP_UNREACH_HOST_PROHIB },
150 	{ "net-tos",		ICMP_UNREACH,	ICMP_UNREACH_TOSNET },
151 	{ "host-tos",		ICMP_UNREACH,	ICMP_UNREACH_TOSHOST },
152 	{ "filter-prohib",	ICMP_UNREACH,	ICMP_UNREACH_FILTER_PROHIB },
153 	{ "host-preced",	ICMP_UNREACH,	ICMP_UNREACH_HOST_PRECEDENCE },
154 	{ "cutoff-preced",	ICMP_UNREACH,	ICMP_UNREACH_PRECEDENCE_CUTOFF },
155 	{ "redir-net",		ICMP_REDIRECT,	ICMP_REDIRECT_NET },
156 	{ "redir-host",		ICMP_REDIRECT,	ICMP_REDIRECT_HOST },
157 	{ "redir-tos-net",	ICMP_REDIRECT,	ICMP_REDIRECT_TOSNET },
158 	{ "redir-tos-host",	ICMP_REDIRECT,	ICMP_REDIRECT_TOSHOST },
159 	{ "normal-adv",		ICMP_ROUTERADVERT, ICMP_ROUTERADVERT_NORMAL },
160 	{ "common-adv",		ICMP_ROUTERADVERT, ICMP_ROUTERADVERT_NOROUTE_COMMON },
161 	{ "transit",		ICMP_TIMXCEED,	ICMP_TIMXCEED_INTRANS },
162 	{ "reassemb",		ICMP_TIMXCEED,	ICMP_TIMXCEED_REASS },
163 	{ "badhead",		ICMP_PARAMPROB,	ICMP_PARAMPROB_ERRATPTR },
164 	{ "optmiss",		ICMP_PARAMPROB,	ICMP_PARAMPROB_OPTABSENT },
165 	{ "badlen",		ICMP_PARAMPROB,	ICMP_PARAMPROB_LENGTH },
166 	{ "unknown-ind",	ICMP_PHOTURIS,	ICMP_PHOTURIS_UNKNOWN_INDEX },
167 	{ "auth-fail",		ICMP_PHOTURIS,	ICMP_PHOTURIS_AUTH_FAILED },
168 	{ "decrypt-fail",	ICMP_PHOTURIS,	ICMP_PHOTURIS_DECRYPT_FAILED }
169 };
170 
171 static const struct icmpcodeent icmp6_code[] = {
172 	{ "admin-unr", ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_ADMIN },
173 	{ "noroute-unr", ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOROUTE },
174 	{ "notnbr-unr",	ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOTNEIGHBOR },
175 	{ "beyond-unr", ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_BEYONDSCOPE },
176 	{ "addr-unr", ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_ADDR },
177 	{ "port-unr", ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT },
178 	{ "transit", ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT },
179 	{ "reassemb", ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_REASSEMBLY },
180 	{ "badhead", ICMP6_PARAM_PROB, ICMP6_PARAMPROB_HEADER },
181 	{ "nxthdr", ICMP6_PARAM_PROB, ICMP6_PARAMPROB_NEXTHEADER },
182 	{ "redironlink", ND_REDIRECT, ND_REDIRECT_ONLINK },
183 	{ "redirrouter", ND_REDIRECT, ND_REDIRECT_ROUTER }
184 };
185 
186 const struct pf_timeout pf_timeouts[] = {
187 	{ "tcp.first",		PFTM_TCP_FIRST_PACKET },
188 	{ "tcp.opening",	PFTM_TCP_OPENING },
189 	{ "tcp.established",	PFTM_TCP_ESTABLISHED },
190 	{ "tcp.closing",	PFTM_TCP_CLOSING },
191 	{ "tcp.finwait",	PFTM_TCP_FIN_WAIT },
192 	{ "tcp.closed",		PFTM_TCP_CLOSED },
193 	{ "tcp.tsdiff",		PFTM_TS_DIFF },
194 	{ "udp.first",		PFTM_UDP_FIRST_PACKET },
195 	{ "udp.single",		PFTM_UDP_SINGLE },
196 	{ "udp.multiple",	PFTM_UDP_MULTIPLE },
197 	{ "icmp.first",		PFTM_ICMP_FIRST_PACKET },
198 	{ "icmp.error",		PFTM_ICMP_ERROR_REPLY },
199 	{ "other.first",	PFTM_OTHER_FIRST_PACKET },
200 	{ "other.single",	PFTM_OTHER_SINGLE },
201 	{ "other.multiple",	PFTM_OTHER_MULTIPLE },
202 	{ "frag",		PFTM_FRAG },
203 	{ "interval",		PFTM_INTERVAL },
204 	{ "adaptive.start",	PFTM_ADAPTIVE_START },
205 	{ "adaptive.end",	PFTM_ADAPTIVE_END },
206 	{ "src.track",		PFTM_SRC_NODE },
207 	{ NULL,			0 }
208 };
209 
210 const struct icmptypeent *
211 geticmptypebynumber(u_int8_t type, sa_family_t af)
212 {
213 	unsigned int	i;
214 
215 	if (af != AF_INET6) {
216 		for (i=0; i < nitems(icmp_type); i++) {
217 			if (type == icmp_type[i].type)
218 				return (&icmp_type[i]);
219 		}
220 	} else {
221 		for (i=0; i < nitems(icmp6_type); i++) {
222 			if (type == icmp6_type[i].type)
223 				 return (&icmp6_type[i]);
224 		}
225 	}
226 	return (NULL);
227 }
228 
229 const struct icmptypeent *
230 geticmptypebyname(char *w, sa_family_t af)
231 {
232 	unsigned int	i;
233 
234 	if (af != AF_INET6) {
235 		for (i=0; i < nitems(icmp_type); i++) {
236 			if (!strcmp(w, icmp_type[i].name))
237 				return (&icmp_type[i]);
238 		}
239 	} else {
240 		for (i=0; i < nitems(icmp6_type); i++) {
241 			if (!strcmp(w, icmp6_type[i].name))
242 				return (&icmp6_type[i]);
243 		}
244 	}
245 	return (NULL);
246 }
247 
248 const struct icmpcodeent *
249 geticmpcodebynumber(u_int8_t type, u_int8_t code, sa_family_t af)
250 {
251 	unsigned int	i;
252 
253 	if (af != AF_INET6) {
254 		for (i=0; i < nitems(icmp_code); i++) {
255 			if (type == icmp_code[i].type &&
256 			    code == icmp_code[i].code)
257 				return (&icmp_code[i]);
258 		}
259 	} else {
260 		for (i=0; i < nitems(icmp6_code); i++) {
261 			if (type == icmp6_code[i].type &&
262 			    code == icmp6_code[i].code)
263 				return (&icmp6_code[i]);
264 		}
265 	}
266 	return (NULL);
267 }
268 
269 const struct icmpcodeent *
270 geticmpcodebyname(u_long type, char *w, sa_family_t af)
271 {
272 	unsigned int	i;
273 
274 	if (af != AF_INET6) {
275 		for (i=0; i < nitems(icmp_code); i++) {
276 			if (type == icmp_code[i].type &&
277 			    !strcmp(w, icmp_code[i].name))
278 				return (&icmp_code[i]);
279 		}
280 	} else {
281 		for (i=0; i < nitems(icmp6_code); i++) {
282 			if (type == icmp6_code[i].type &&
283 			    !strcmp(w, icmp6_code[i].name))
284 				return (&icmp6_code[i]);
285 		}
286 	}
287 	return (NULL);
288 }
289 
290 void
291 print_op(u_int8_t op, const char *a1, const char *a2)
292 {
293 	if (op == PF_OP_IRG)
294 		printf(" %s >< %s", a1, a2);
295 	else if (op == PF_OP_XRG)
296 		printf(" %s <> %s", a1, a2);
297 	else if (op == PF_OP_EQ)
298 		printf(" = %s", a1);
299 	else if (op == PF_OP_NE)
300 		printf(" != %s", a1);
301 	else if (op == PF_OP_LT)
302 		printf(" < %s", a1);
303 	else if (op == PF_OP_LE)
304 		printf(" <= %s", a1);
305 	else if (op == PF_OP_GT)
306 		printf(" > %s", a1);
307 	else if (op == PF_OP_GE)
308 		printf(" >= %s", a1);
309 	else if (op == PF_OP_RRG)
310 		printf(" %s:%s", a1, a2);
311 }
312 
313 void
314 print_port(u_int8_t op, u_int16_t p1, u_int16_t p2, const char *proto, int numeric)
315 {
316 	char		 a1[6], a2[6];
317 	struct servent	*s;
318 
319 	if (!numeric)
320 		s = getservbyport(p1, proto);
321 	else
322 		s = NULL;
323 	p1 = ntohs(p1);
324 	p2 = ntohs(p2);
325 	snprintf(a1, sizeof(a1), "%u", p1);
326 	snprintf(a2, sizeof(a2), "%u", p2);
327 	printf(" port");
328 	if (s != NULL && (op == PF_OP_EQ || op == PF_OP_NE))
329 		print_op(op, s->s_name, a2);
330 	else
331 		print_op(op, a1, a2);
332 }
333 
334 void
335 print_ugid(u_int8_t op, unsigned u1, unsigned u2, const char *t, unsigned umax)
336 {
337 	char	a1[11], a2[11];
338 
339 	snprintf(a1, sizeof(a1), "%u", u1);
340 	snprintf(a2, sizeof(a2), "%u", u2);
341 	printf(" %s", t);
342 	if (u1 == umax && (op == PF_OP_EQ || op == PF_OP_NE))
343 		print_op(op, "unknown", a2);
344 	else
345 		print_op(op, a1, a2);
346 }
347 
348 void
349 print_flags(u_int8_t f)
350 {
351 	int	i;
352 
353 	for (i = 0; tcpflags[i]; ++i)
354 		if (f & (1 << i))
355 			printf("%c", tcpflags[i]);
356 }
357 
358 void
359 print_fromto(struct pf_rule_addr *src, pf_osfp_t osfp, struct pf_rule_addr *dst,
360     sa_family_t af, u_int8_t proto, int verbose, int numeric)
361 {
362 	char buf[PF_OSFP_LEN*3];
363 	if (src->addr.type == PF_ADDR_ADDRMASK &&
364 	    dst->addr.type == PF_ADDR_ADDRMASK &&
365 	    PF_AZERO(&src->addr.v.a.addr, AF_INET6) &&
366 	    PF_AZERO(&src->addr.v.a.mask, AF_INET6) &&
367 	    PF_AZERO(&dst->addr.v.a.addr, AF_INET6) &&
368 	    PF_AZERO(&dst->addr.v.a.mask, AF_INET6) &&
369 	    !src->neg && !dst->neg &&
370 	    !src->port_op && !dst->port_op &&
371 	    osfp == PF_OSFP_ANY)
372 		printf(" all");
373 	else {
374 		printf(" from ");
375 		if (src->neg)
376 			printf("! ");
377 		print_addr(&src->addr, af, verbose);
378 		if (src->port_op)
379 			print_port(src->port_op, src->port[0],
380 			    src->port[1],
381 			    proto == IPPROTO_TCP ? "tcp" : "udp",
382 			    numeric);
383 		if (osfp != PF_OSFP_ANY)
384 			printf(" os \"%s\"", pfctl_lookup_fingerprint(osfp, buf,
385 			    sizeof(buf)));
386 
387 		printf(" to ");
388 		if (dst->neg)
389 			printf("! ");
390 		print_addr(&dst->addr, af, verbose);
391 		if (dst->port_op)
392 			print_port(dst->port_op, dst->port[0],
393 			    dst->port[1],
394 			    proto == IPPROTO_TCP ? "tcp" : "udp",
395 			    numeric);
396 	}
397 }
398 
399 void
400 print_pool(struct pf_pool *pool, u_int16_t p1, u_int16_t p2,
401     sa_family_t af, int id)
402 {
403 	struct pf_pooladdr	*pooladdr;
404 
405 	if ((TAILQ_FIRST(&pool->list) != NULL) &&
406 	    TAILQ_NEXT(TAILQ_FIRST(&pool->list), entries) != NULL)
407 		printf("{ ");
408 	TAILQ_FOREACH(pooladdr, &pool->list, entries){
409 		switch (id) {
410 		case PF_NAT:
411 		case PF_RDR:
412 		case PF_BINAT:
413 			print_addr(&pooladdr->addr, af, 0);
414 			break;
415 		case PF_PASS:
416 			if (PF_AZERO(&pooladdr->addr.v.a.addr, af))
417 				printf("%s", pooladdr->ifname);
418 			else {
419 				printf("(%s ", pooladdr->ifname);
420 				print_addr(&pooladdr->addr, af, 0);
421 				printf(")");
422 			}
423 			break;
424 		default:
425 			break;
426 		}
427 		if (TAILQ_NEXT(pooladdr, entries) != NULL)
428 			printf(", ");
429 		else if (TAILQ_NEXT(TAILQ_FIRST(&pool->list), entries) != NULL)
430 			printf(" }");
431 	}
432 	switch (id) {
433 	case PF_NAT:
434 		if ((p1 != PF_NAT_PROXY_PORT_LOW ||
435 		    p2 != PF_NAT_PROXY_PORT_HIGH) && (p1 != 0 || p2 != 0)) {
436 			if (p1 == p2)
437 				printf(" port %u", p1);
438 			else
439 				printf(" port %u:%u", p1, p2);
440 		}
441 		break;
442 	case PF_RDR:
443 		if (p1) {
444 			printf(" port %u", p1);
445 			if (p2 && (p2 != p1))
446 				printf(":%u", p2);
447 		}
448 		break;
449 	default:
450 		break;
451 	}
452 	switch (pool->opts & PF_POOL_TYPEMASK) {
453 	case PF_POOL_NONE:
454 		break;
455 	case PF_POOL_BITMASK:
456 		printf(" bitmask");
457 		break;
458 	case PF_POOL_RANDOM:
459 		printf(" random");
460 		break;
461 	case PF_POOL_SRCHASH:
462 		printf(" source-hash 0x%08x%08x%08x%08x",
463 		    pool->key.key32[0], pool->key.key32[1],
464 		    pool->key.key32[2], pool->key.key32[3]);
465 		break;
466 	case PF_POOL_ROUNDROBIN:
467 		printf(" round-robin");
468 		break;
469 	}
470 	if (pool->opts & PF_POOL_STICKYADDR)
471 		printf(" sticky-address");
472 	if (id == PF_NAT && p1 == 0 && p2 == 0)
473 		printf(" static-port");
474 }
475 
476 const char	* const pf_reasons[PFRES_MAX+1] = PFRES_NAMES;
477 const char	* const pf_lcounters[LCNT_MAX+1] = LCNT_NAMES;
478 const char	* const pf_fcounters[FCNT_MAX+1] = FCNT_NAMES;
479 const char	* const pf_scounters[FCNT_MAX+1] = FCNT_NAMES;
480 
481 void
482 print_status(struct pf_status *s, int opts)
483 {
484 	char			statline[80], *running;
485 	time_t			runtime;
486 	int			i;
487 	char			buf[PF_MD5_DIGEST_LENGTH * 2 + 1];
488 	static const char	hex[] = "0123456789abcdef";
489 
490 	runtime = time(NULL) - s->since;
491 	running = s->running ? "Enabled" : "Disabled";
492 
493 	if (s->since) {
494 		unsigned int	sec, min, hrs, day = runtime;
495 
496 		sec = day % 60;
497 		day /= 60;
498 		min = day % 60;
499 		day /= 60;
500 		hrs = day % 24;
501 		day /= 24;
502 		snprintf(statline, sizeof(statline),
503 		    "Status: %s for %u days %.2u:%.2u:%.2u",
504 		    running, day, hrs, min, sec);
505 	} else
506 		snprintf(statline, sizeof(statline), "Status: %s", running);
507 	printf("%-44s", statline);
508 	switch (s->debug) {
509 	case PF_DEBUG_NONE:
510 		printf("%15s\n\n", "Debug: None");
511 		break;
512 	case PF_DEBUG_URGENT:
513 		printf("%15s\n\n", "Debug: Urgent");
514 		break;
515 	case PF_DEBUG_MISC:
516 		printf("%15s\n\n", "Debug: Misc");
517 		break;
518 	case PF_DEBUG_NOISY:
519 		printf("%15s\n\n", "Debug: Loud");
520 		break;
521 	}
522 
523 	if (opts & PF_OPT_VERBOSE) {
524 		printf("Hostid:   0x%08x\n", ntohl(s->hostid));
525 
526 		for (i = 0; i < PF_MD5_DIGEST_LENGTH; i++) {
527 			buf[i + i] = hex[s->pf_chksum[i] >> 4];
528 			buf[i + i + 1] = hex[s->pf_chksum[i] & 0x0f];
529 		}
530 		buf[i + i] = '\0';
531 		printf("Checksum: 0x%s\n\n", buf);
532 	}
533 
534 	if (s->ifname[0] != 0) {
535 		printf("Interface Stats for %-16s %5s %16s\n",
536 		    s->ifname, "IPv4", "IPv6");
537 		printf("  %-25s %14llu %16llu\n", "Bytes In",
538 		    (unsigned long long)s->bcounters[0][0],
539 		    (unsigned long long)s->bcounters[1][0]);
540 		printf("  %-25s %14llu %16llu\n", "Bytes Out",
541 		    (unsigned long long)s->bcounters[0][1],
542 		    (unsigned long long)s->bcounters[1][1]);
543 		printf("  Packets In\n");
544 		printf("    %-23s %14llu %16llu\n", "Passed",
545 		    (unsigned long long)s->pcounters[0][0][PF_PASS],
546 		    (unsigned long long)s->pcounters[1][0][PF_PASS]);
547 		printf("    %-23s %14llu %16llu\n", "Blocked",
548 		    (unsigned long long)s->pcounters[0][0][PF_DROP],
549 		    (unsigned long long)s->pcounters[1][0][PF_DROP]);
550 		printf("  Packets Out\n");
551 		printf("    %-23s %14llu %16llu\n", "Passed",
552 		    (unsigned long long)s->pcounters[0][1][PF_PASS],
553 		    (unsigned long long)s->pcounters[1][1][PF_PASS]);
554 		printf("    %-23s %14llu %16llu\n\n", "Blocked",
555 		    (unsigned long long)s->pcounters[0][1][PF_DROP],
556 		    (unsigned long long)s->pcounters[1][1][PF_DROP]);
557 	}
558 	printf("%-27s %14s %16s\n", "State Table", "Total", "Rate");
559 	printf("  %-25s %14u %14s\n", "current entries", s->states, "");
560 	for (i = 0; i < FCNT_MAX; i++) {
561 		printf("  %-25s %14llu ", pf_fcounters[i],
562 			    (unsigned long long)s->fcounters[i]);
563 		if (runtime > 0)
564 			printf("%14.1f/s\n",
565 			    (double)s->fcounters[i] / (double)runtime);
566 		else
567 			printf("%14s\n", "");
568 	}
569 	if (opts & PF_OPT_VERBOSE) {
570 		printf("Source Tracking Table\n");
571 		printf("  %-25s %14u %14s\n", "current entries",
572 		    s->src_nodes, "");
573 		for (i = 0; i < SCNT_MAX; i++) {
574 			printf("  %-25s %14lld ", pf_scounters[i],
575 #ifdef __FreeBSD__
576 				    (long long)s->scounters[i]);
577 #else
578 				    s->scounters[i]);
579 #endif
580 			if (runtime > 0)
581 				printf("%14.1f/s\n",
582 				    (double)s->scounters[i] / (double)runtime);
583 			else
584 				printf("%14s\n", "");
585 		}
586 	}
587 	printf("Counters\n");
588 	for (i = 0; i < PFRES_MAX; i++) {
589 		printf("  %-25s %14llu ", pf_reasons[i],
590 		    (unsigned long long)s->counters[i]);
591 		if (runtime > 0)
592 			printf("%14.1f/s\n",
593 			    (double)s->counters[i] / (double)runtime);
594 		else
595 			printf("%14s\n", "");
596 	}
597 	if (opts & PF_OPT_VERBOSE) {
598 		printf("Limit Counters\n");
599 		for (i = 0; i < LCNT_MAX; i++) {
600 			printf("  %-25s %14lld ", pf_lcounters[i],
601 #ifdef __FreeBSD__
602 				    (unsigned long long)s->lcounters[i]);
603 #else
604 				    s->lcounters[i]);
605 #endif
606 			if (runtime > 0)
607 				printf("%14.1f/s\n",
608 				    (double)s->lcounters[i] / (double)runtime);
609 			else
610 				printf("%14s\n", "");
611 		}
612 	}
613 }
614 
615 void
616 print_src_node(struct pf_src_node *sn, int opts)
617 {
618 	struct pf_addr_wrap aw;
619 	int min, sec;
620 
621 	memset(&aw, 0, sizeof(aw));
622 	if (sn->af == AF_INET)
623 		aw.v.a.mask.addr32[0] = 0xffffffff;
624 	else
625 		memset(&aw.v.a.mask, 0xff, sizeof(aw.v.a.mask));
626 
627 	aw.v.a.addr = sn->addr;
628 	print_addr(&aw, sn->af, opts & PF_OPT_VERBOSE2);
629 	printf(" -> ");
630 	aw.v.a.addr = sn->raddr;
631 	print_addr(&aw, sn->af, opts & PF_OPT_VERBOSE2);
632 	printf(" ( states %u, connections %u, rate %u.%u/%us )\n", sn->states,
633 	    sn->conn, sn->conn_rate.count / 1000,
634 	    (sn->conn_rate.count % 1000) / 100, sn->conn_rate.seconds);
635 	if (opts & PF_OPT_VERBOSE) {
636 		sec = sn->creation % 60;
637 		sn->creation /= 60;
638 		min = sn->creation % 60;
639 		sn->creation /= 60;
640 		printf("   age %.2u:%.2u:%.2u", sn->creation, min, sec);
641 		if (sn->states == 0) {
642 			sec = sn->expire % 60;
643 			sn->expire /= 60;
644 			min = sn->expire % 60;
645 			sn->expire /= 60;
646 			printf(", expires in %.2u:%.2u:%.2u",
647 			    sn->expire, min, sec);
648 		}
649 		printf(", %llu pkts, %llu bytes",
650 #ifdef __FreeBSD__
651 		    (unsigned long long)(sn->packets[0] + sn->packets[1]),
652 		    (unsigned long long)(sn->bytes[0] + sn->bytes[1]));
653 #else
654 		    sn->packets[0] + sn->packets[1],
655 		    sn->bytes[0] + sn->bytes[1]);
656 #endif
657 		switch (sn->ruletype) {
658 		case PF_NAT:
659 			if (sn->rule.nr != -1)
660 				printf(", nat rule %u", sn->rule.nr);
661 			break;
662 		case PF_RDR:
663 			if (sn->rule.nr != -1)
664 				printf(", rdr rule %u", sn->rule.nr);
665 			break;
666 		case PF_PASS:
667 			if (sn->rule.nr != -1)
668 				printf(", filter rule %u", sn->rule.nr);
669 			break;
670 		}
671 		printf("\n");
672 	}
673 }
674 
675 void
676 print_rule(struct pf_rule *r, const char *anchor_call, int verbose, int numeric)
677 {
678 	static const char *actiontypes[] = { "pass", "block", "scrub",
679 	    "no scrub", "nat", "no nat", "binat", "no binat", "rdr", "no rdr" };
680 	static const char *anchortypes[] = { "anchor", "anchor", "anchor",
681 	    "anchor", "nat-anchor", "nat-anchor", "binat-anchor",
682 	    "binat-anchor", "rdr-anchor", "rdr-anchor" };
683 	int	i, opts;
684 
685 	if (verbose)
686 		printf("@%d ", r->nr);
687 	if (r->action > PF_NORDR)
688 		printf("action(%d)", r->action);
689 	else if (anchor_call[0]) {
690 		if (anchor_call[0] == '_') {
691 			printf("%s", anchortypes[r->action]);
692 		} else
693 			printf("%s \"%s\"", anchortypes[r->action],
694 			    anchor_call);
695 	} else {
696 		printf("%s", actiontypes[r->action]);
697 		if (r->natpass)
698 			printf(" pass");
699 	}
700 	if (r->action == PF_DROP) {
701 		if (r->rule_flag & PFRULE_RETURN)
702 			printf(" return");
703 		else if (r->rule_flag & PFRULE_RETURNRST) {
704 			if (!r->return_ttl)
705 				printf(" return-rst");
706 			else
707 				printf(" return-rst(ttl %d)", r->return_ttl);
708 		} else if (r->rule_flag & PFRULE_RETURNICMP) {
709 			const struct icmpcodeent	*ic, *ic6;
710 
711 			ic = geticmpcodebynumber(r->return_icmp >> 8,
712 			    r->return_icmp & 255, AF_INET);
713 			ic6 = geticmpcodebynumber(r->return_icmp6 >> 8,
714 			    r->return_icmp6 & 255, AF_INET6);
715 
716 			switch (r->af) {
717 			case AF_INET:
718 				printf(" return-icmp");
719 				if (ic == NULL)
720 					printf("(%u)", r->return_icmp & 255);
721 				else
722 					printf("(%s)", ic->name);
723 				break;
724 			case AF_INET6:
725 				printf(" return-icmp6");
726 				if (ic6 == NULL)
727 					printf("(%u)", r->return_icmp6 & 255);
728 				else
729 					printf("(%s)", ic6->name);
730 				break;
731 			default:
732 				printf(" return-icmp");
733 				if (ic == NULL)
734 					printf("(%u, ", r->return_icmp & 255);
735 				else
736 					printf("(%s, ", ic->name);
737 				if (ic6 == NULL)
738 					printf("%u)", r->return_icmp6 & 255);
739 				else
740 					printf("%s)", ic6->name);
741 				break;
742 			}
743 		} else
744 			printf(" drop");
745 	}
746 	if (r->direction == PF_IN)
747 		printf(" in");
748 	else if (r->direction == PF_OUT)
749 		printf(" out");
750 	if (r->log) {
751 		printf(" log");
752 		if (r->log & ~PF_LOG || r->logif) {
753 			int count = 0;
754 
755 			printf(" (");
756 			if (r->log & PF_LOG_ALL)
757 				printf("%sall", count++ ? ", " : "");
758 			if (r->log & PF_LOG_SOCKET_LOOKUP)
759 				printf("%suser", count++ ? ", " : "");
760 			if (r->logif)
761 				printf("%sto pflog%u", count++ ? ", " : "",
762 				    r->logif);
763 			printf(")");
764 		}
765 	}
766 	if (r->quick)
767 		printf(" quick");
768 	if (r->ifname[0]) {
769 		if (r->ifnot)
770 			printf(" on ! %s", r->ifname);
771 		else
772 			printf(" on %s", r->ifname);
773 	}
774 	if (r->rt) {
775 		if (r->rt == PF_ROUTETO)
776 			printf(" route-to");
777 		else if (r->rt == PF_REPLYTO)
778 			printf(" reply-to");
779 		else if (r->rt == PF_DUPTO)
780 			printf(" dup-to");
781 		printf(" ");
782 		print_pool(&r->rpool, 0, 0, r->af, PF_PASS);
783 	}
784 	if (r->af) {
785 		if (r->af == AF_INET)
786 			printf(" inet");
787 		else
788 			printf(" inet6");
789 	}
790 	if (r->proto) {
791 		struct protoent	*p;
792 
793 		if ((p = getprotobynumber(r->proto)) != NULL)
794 			printf(" proto %s", p->p_name);
795 		else
796 			printf(" proto %u", r->proto);
797 	}
798 	print_fromto(&r->src, r->os_fingerprint, &r->dst, r->af, r->proto,
799 	    verbose, numeric);
800 	if (r->uid.op)
801 		print_ugid(r->uid.op, r->uid.uid[0], r->uid.uid[1], "user",
802 		    UID_MAX);
803 	if (r->gid.op)
804 		print_ugid(r->gid.op, r->gid.gid[0], r->gid.gid[1], "group",
805 		    GID_MAX);
806 	if (r->flags || r->flagset) {
807 		printf(" flags ");
808 		print_flags(r->flags);
809 		printf("/");
810 		print_flags(r->flagset);
811 	} else if (r->action == PF_PASS &&
812 	    (!r->proto || r->proto == IPPROTO_TCP) &&
813 	    !(r->rule_flag & PFRULE_FRAGMENT) &&
814 	    !anchor_call[0] && r->keep_state)
815 		printf(" flags any");
816 	if (r->type) {
817 		const struct icmptypeent	*it;
818 
819 		it = geticmptypebynumber(r->type-1, r->af);
820 		if (r->af != AF_INET6)
821 			printf(" icmp-type");
822 		else
823 			printf(" icmp6-type");
824 		if (it != NULL)
825 			printf(" %s", it->name);
826 		else
827 			printf(" %u", r->type-1);
828 		if (r->code) {
829 			const struct icmpcodeent	*ic;
830 
831 			ic = geticmpcodebynumber(r->type-1, r->code-1, r->af);
832 			if (ic != NULL)
833 				printf(" code %s", ic->name);
834 			else
835 				printf(" code %u", r->code-1);
836 		}
837 	}
838 	if (r->tos)
839 		printf(" tos 0x%2.2x", r->tos);
840 	if (r->prio)
841 		printf(" prio %u", r->prio == PF_PRIO_ZERO ? 0 : r->prio);
842 	if (r->scrub_flags & PFSTATE_SETMASK) {
843 		char *comma = "";
844 		printf(" set (");
845 		if (r->scrub_flags & PFSTATE_SETPRIO) {
846 			if (r->set_prio[0] == r->set_prio[1])
847 				printf("%s prio %u", comma, r->set_prio[0]);
848 			else
849 				printf("%s prio(%u, %u)", comma, r->set_prio[0],
850 				    r->set_prio[1]);
851 			comma = ",";
852 		}
853 		printf(" )");
854 	}
855 	if (!r->keep_state && r->action == PF_PASS && !anchor_call[0])
856 		printf(" no state");
857 	else if (r->keep_state == PF_STATE_NORMAL)
858 		printf(" keep state");
859 	else if (r->keep_state == PF_STATE_MODULATE)
860 		printf(" modulate state");
861 	else if (r->keep_state == PF_STATE_SYNPROXY)
862 		printf(" synproxy state");
863 	if (r->prob) {
864 		char	buf[20];
865 
866 		snprintf(buf, sizeof(buf), "%f", r->prob*100.0/(UINT_MAX+1.0));
867 		for (i = strlen(buf)-1; i > 0; i--) {
868 			if (buf[i] == '0')
869 				buf[i] = '\0';
870 			else {
871 				if (buf[i] == '.')
872 					buf[i] = '\0';
873 				break;
874 			}
875 		}
876 		printf(" probability %s%%", buf);
877 	}
878 	opts = 0;
879 	if (r->max_states || r->max_src_nodes || r->max_src_states)
880 		opts = 1;
881 	if (r->rule_flag & PFRULE_NOSYNC)
882 		opts = 1;
883 	if (r->rule_flag & PFRULE_SRCTRACK)
884 		opts = 1;
885 	if (r->rule_flag & PFRULE_IFBOUND)
886 		opts = 1;
887 	if (r->rule_flag & PFRULE_STATESLOPPY)
888 		opts = 1;
889 	for (i = 0; !opts && i < PFTM_MAX; ++i)
890 		if (r->timeout[i])
891 			opts = 1;
892 	if (opts) {
893 		printf(" (");
894 		if (r->max_states) {
895 			printf("max %u", r->max_states);
896 			opts = 0;
897 		}
898 		if (r->rule_flag & PFRULE_NOSYNC) {
899 			if (!opts)
900 				printf(", ");
901 			printf("no-sync");
902 			opts = 0;
903 		}
904 		if (r->rule_flag & PFRULE_SRCTRACK) {
905 			if (!opts)
906 				printf(", ");
907 			printf("source-track");
908 			if (r->rule_flag & PFRULE_RULESRCTRACK)
909 				printf(" rule");
910 			else
911 				printf(" global");
912 			opts = 0;
913 		}
914 		if (r->max_src_states) {
915 			if (!opts)
916 				printf(", ");
917 			printf("max-src-states %u", r->max_src_states);
918 			opts = 0;
919 		}
920 		if (r->max_src_conn) {
921 			if (!opts)
922 				printf(", ");
923 			printf("max-src-conn %u", r->max_src_conn);
924 			opts = 0;
925 		}
926 		if (r->max_src_conn_rate.limit) {
927 			if (!opts)
928 				printf(", ");
929 			printf("max-src-conn-rate %u/%u",
930 			    r->max_src_conn_rate.limit,
931 			    r->max_src_conn_rate.seconds);
932 			opts = 0;
933 		}
934 		if (r->max_src_nodes) {
935 			if (!opts)
936 				printf(", ");
937 			printf("max-src-nodes %u", r->max_src_nodes);
938 			opts = 0;
939 		}
940 		if (r->overload_tblname[0]) {
941 			if (!opts)
942 				printf(", ");
943 			printf("overload <%s>", r->overload_tblname);
944 			if (r->flush)
945 				printf(" flush");
946 			if (r->flush & PF_FLUSH_GLOBAL)
947 				printf(" global");
948 		}
949 		if (r->rule_flag & PFRULE_IFBOUND) {
950 			if (!opts)
951 				printf(", ");
952 			printf("if-bound");
953 			opts = 0;
954 		}
955 		if (r->rule_flag & PFRULE_STATESLOPPY) {
956 			if (!opts)
957 				printf(", ");
958 			printf("sloppy");
959 			opts = 0;
960 		}
961 		for (i = 0; i < PFTM_MAX; ++i)
962 			if (r->timeout[i]) {
963 				int j;
964 
965 				if (!opts)
966 					printf(", ");
967 				opts = 0;
968 				for (j = 0; pf_timeouts[j].name != NULL;
969 				    ++j)
970 					if (pf_timeouts[j].timeout == i)
971 						break;
972 				printf("%s %u", pf_timeouts[j].name == NULL ?
973 				    "inv.timeout" : pf_timeouts[j].name,
974 				    r->timeout[i]);
975 			}
976 		printf(")");
977 	}
978 	if (r->rule_flag & PFRULE_FRAGMENT)
979 		printf(" fragment");
980 	if (r->rule_flag & PFRULE_NODF)
981 		printf(" no-df");
982 	if (r->rule_flag & PFRULE_RANDOMID)
983 		printf(" random-id");
984 	if (r->min_ttl)
985 		printf(" min-ttl %d", r->min_ttl);
986 	if (r->max_mss)
987 		printf(" max-mss %d", r->max_mss);
988 	if (r->rule_flag & PFRULE_SET_TOS)
989 		printf(" set-tos 0x%2.2x", r->set_tos);
990 	if (r->allow_opts)
991 		printf(" allow-opts");
992 	if (r->action == PF_SCRUB) {
993 		if (r->rule_flag & PFRULE_REASSEMBLE_TCP)
994 			printf(" reassemble tcp");
995 
996 		printf(" fragment reassemble");
997 	}
998 	if (r->label[0])
999 		printf(" label \"%s\"", r->label);
1000 	if (r->qname[0] && r->pqname[0])
1001 		printf(" queue(%s, %s)", r->qname, r->pqname);
1002 	else if (r->qname[0])
1003 		printf(" queue %s", r->qname);
1004 	if (r->tagname[0])
1005 		printf(" tag %s", r->tagname);
1006 	if (r->match_tagname[0]) {
1007 		if (r->match_tag_not)
1008 			printf(" !");
1009 		printf(" tagged %s", r->match_tagname);
1010 	}
1011 	if (r->rtableid != -1)
1012 		printf(" rtable %u", r->rtableid);
1013 	if (r->divert.port) {
1014 #ifdef __FreeBSD__
1015 		printf(" divert-to %u", ntohs(r->divert.port));
1016 #else
1017 		if (PF_AZERO(&r->divert.addr, r->af)) {
1018 			printf(" divert-reply");
1019 		} else {
1020 			/* XXX cut&paste from print_addr */
1021 			char buf[48];
1022 
1023 			printf(" divert-to ");
1024 			if (inet_ntop(r->af, &r->divert.addr, buf,
1025 			    sizeof(buf)) == NULL)
1026 				printf("?");
1027 			else
1028 				printf("%s", buf);
1029 			printf(" port %u", ntohs(r->divert.port));
1030 		}
1031 #endif
1032 	}
1033 	if (!anchor_call[0] && (r->action == PF_NAT ||
1034 	    r->action == PF_BINAT || r->action == PF_RDR)) {
1035 		printf(" -> ");
1036 		print_pool(&r->rpool, r->rpool.proxy_port[0],
1037 		    r->rpool.proxy_port[1], r->af, r->action);
1038 	}
1039 }
1040 
1041 void
1042 print_tabledef(const char *name, int flags, int addrs,
1043     struct node_tinithead *nodes)
1044 {
1045 	struct node_tinit	*ti, *nti;
1046 	struct node_host	*h;
1047 
1048 	printf("table <%s>", name);
1049 	if (flags & PFR_TFLAG_CONST)
1050 		printf(" const");
1051 	if (flags & PFR_TFLAG_PERSIST)
1052 		printf(" persist");
1053 	if (flags & PFR_TFLAG_COUNTERS)
1054 		printf(" counters");
1055 	SIMPLEQ_FOREACH(ti, nodes, entries) {
1056 		if (ti->file) {
1057 			printf(" file \"%s\"", ti->file);
1058 			continue;
1059 		}
1060 		printf(" {");
1061 		for (;;) {
1062 			for (h = ti->host; h != NULL; h = h->next) {
1063 				printf(h->not ? " !" : " ");
1064 				print_addr(&h->addr, h->af, 0);
1065 			}
1066 			nti = SIMPLEQ_NEXT(ti, entries);
1067 			if (nti != NULL && nti->file == NULL)
1068 				ti = nti;	/* merge lists */
1069 			else
1070 				break;
1071 		}
1072 		printf(" }");
1073 	}
1074 	if (addrs && SIMPLEQ_EMPTY(nodes))
1075 		printf(" { }");
1076 	printf("\n");
1077 }
1078 
1079 int
1080 parse_flags(char *s)
1081 {
1082 	char		*p, *q;
1083 	u_int8_t	 f = 0;
1084 
1085 	for (p = s; *p; p++) {
1086 		if ((q = strchr(tcpflags, *p)) == NULL)
1087 			return -1;
1088 		else
1089 			f |= 1 << (q - tcpflags);
1090 	}
1091 	return (f ? f : PF_TH_ALL);
1092 }
1093 
1094 void
1095 set_ipmask(struct node_host *h, u_int8_t b)
1096 {
1097 	struct pf_addr	*m, *n;
1098 	int		 i, j = 0;
1099 
1100 	m = &h->addr.v.a.mask;
1101 	memset(m, 0, sizeof(*m));
1102 
1103 	while (b >= 32) {
1104 		m->addr32[j++] = 0xffffffff;
1105 		b -= 32;
1106 	}
1107 	for (i = 31; i > 31-b; --i)
1108 		m->addr32[j] |= (1 << i);
1109 	if (b)
1110 		m->addr32[j] = htonl(m->addr32[j]);
1111 
1112 	/* Mask off bits of the address that will never be used. */
1113 	n = &h->addr.v.a.addr;
1114 	if (h->addr.type == PF_ADDR_ADDRMASK)
1115 		for (i = 0; i < 4; i++)
1116 			n->addr32[i] = n->addr32[i] & m->addr32[i];
1117 }
1118 
1119 int
1120 check_netmask(struct node_host *h, sa_family_t af)
1121 {
1122 	struct node_host	*n = NULL;
1123 	struct pf_addr	*m;
1124 
1125 	for (n = h; n != NULL; n = n->next) {
1126 		if (h->addr.type == PF_ADDR_TABLE)
1127 			continue;
1128 		m = &h->addr.v.a.mask;
1129 		/* fix up netmask for dynaddr */
1130 		if (af == AF_INET && h->addr.type == PF_ADDR_DYNIFTL &&
1131 		    unmask(m, AF_INET6) > 32)
1132 			set_ipmask(n, 32);
1133 		/* netmasks > 32 bit are invalid on v4 */
1134 		if (af == AF_INET &&
1135 		    (m->addr32[1] || m->addr32[2] || m->addr32[3])) {
1136 			fprintf(stderr, "netmask %u invalid for IPv4 address\n",
1137 			    unmask(m, AF_INET6));
1138 			return (1);
1139 		}
1140 	}
1141 	return (0);
1142 }
1143 
1144 /* interface lookup routines */
1145 
1146 static struct node_host	*iftab;
1147 
1148 void
1149 ifa_load(void)
1150 {
1151 	struct ifaddrs		*ifap, *ifa;
1152 	struct node_host	*n = NULL, *h = NULL;
1153 
1154 	if (getifaddrs(&ifap) < 0)
1155 		err(1, "getifaddrs");
1156 
1157 	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1158 		if (!(ifa->ifa_addr->sa_family == AF_INET ||
1159 		    ifa->ifa_addr->sa_family == AF_INET6 ||
1160 		    ifa->ifa_addr->sa_family == AF_LINK))
1161 				continue;
1162 		n = calloc(1, sizeof(struct node_host));
1163 		if (n == NULL)
1164 			err(1, "address: calloc");
1165 		n->af = ifa->ifa_addr->sa_family;
1166 		n->ifa_flags = ifa->ifa_flags;
1167 #ifdef __KAME__
1168 		if (n->af == AF_INET6 &&
1169 		    IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6 *)
1170 		    ifa->ifa_addr)->sin6_addr) &&
1171 		    ((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_scope_id ==
1172 		    0) {
1173 			struct sockaddr_in6	*sin6;
1174 
1175 			sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1176 			sin6->sin6_scope_id = sin6->sin6_addr.s6_addr[2] << 8 |
1177 			    sin6->sin6_addr.s6_addr[3];
1178 			sin6->sin6_addr.s6_addr[2] = 0;
1179 			sin6->sin6_addr.s6_addr[3] = 0;
1180 		}
1181 #endif
1182 		n->ifindex = 0;
1183 		if (n->af == AF_INET) {
1184 			memcpy(&n->addr.v.a.addr, &((struct sockaddr_in *)
1185 			    ifa->ifa_addr)->sin_addr.s_addr,
1186 			    sizeof(struct in_addr));
1187 			memcpy(&n->addr.v.a.mask, &((struct sockaddr_in *)
1188 			    ifa->ifa_netmask)->sin_addr.s_addr,
1189 			    sizeof(struct in_addr));
1190 			if (ifa->ifa_broadaddr != NULL)
1191 				memcpy(&n->bcast, &((struct sockaddr_in *)
1192 				    ifa->ifa_broadaddr)->sin_addr.s_addr,
1193 				    sizeof(struct in_addr));
1194 			if (ifa->ifa_dstaddr != NULL)
1195 				memcpy(&n->peer, &((struct sockaddr_in *)
1196 				    ifa->ifa_dstaddr)->sin_addr.s_addr,
1197 				    sizeof(struct in_addr));
1198 		} else if (n->af == AF_INET6) {
1199 			memcpy(&n->addr.v.a.addr, &((struct sockaddr_in6 *)
1200 			    ifa->ifa_addr)->sin6_addr.s6_addr,
1201 			    sizeof(struct in6_addr));
1202 			memcpy(&n->addr.v.a.mask, &((struct sockaddr_in6 *)
1203 			    ifa->ifa_netmask)->sin6_addr.s6_addr,
1204 			    sizeof(struct in6_addr));
1205 			if (ifa->ifa_broadaddr != NULL)
1206 				memcpy(&n->bcast, &((struct sockaddr_in6 *)
1207 				    ifa->ifa_broadaddr)->sin6_addr.s6_addr,
1208 				    sizeof(struct in6_addr));
1209 			if (ifa->ifa_dstaddr != NULL)
1210 				 memcpy(&n->peer, &((struct sockaddr_in6 *)
1211 				    ifa->ifa_dstaddr)->sin6_addr.s6_addr,
1212 				    sizeof(struct in6_addr));
1213 			n->ifindex = ((struct sockaddr_in6 *)
1214 			    ifa->ifa_addr)->sin6_scope_id;
1215 		}
1216 		if ((n->ifname = strdup(ifa->ifa_name)) == NULL)
1217 			err(1, "ifa_load: strdup");
1218 		n->next = NULL;
1219 		n->tail = n;
1220 		if (h == NULL)
1221 			h = n;
1222 		else {
1223 			h->tail->next = n;
1224 			h->tail = n;
1225 		}
1226 	}
1227 
1228 	iftab = h;
1229 	freeifaddrs(ifap);
1230 }
1231 
1232 int
1233 get_socket_domain(void)
1234 {
1235 	int sdom;
1236 
1237 	sdom = AF_UNSPEC;
1238 #ifdef WITH_INET6
1239 	if (sdom == AF_UNSPEC && feature_present("inet6"))
1240 		sdom = AF_INET6;
1241 #endif
1242 #ifdef WITH_INET
1243 	if (sdom == AF_UNSPEC && feature_present("inet"))
1244 		sdom = AF_INET;
1245 #endif
1246 	if (sdom == AF_UNSPEC)
1247 		sdom = AF_LINK;
1248 
1249 	return (sdom);
1250 }
1251 
1252 struct node_host *
1253 ifa_exists(const char *ifa_name)
1254 {
1255 	struct node_host	*n;
1256 	struct ifgroupreq	ifgr;
1257 	int			s;
1258 
1259 	if (iftab == NULL)
1260 		ifa_load();
1261 
1262 	/* check wether this is a group */
1263 	if ((s = socket(get_socket_domain(), SOCK_DGRAM, 0)) == -1)
1264 		err(1, "socket");
1265 	bzero(&ifgr, sizeof(ifgr));
1266 	strlcpy(ifgr.ifgr_name, ifa_name, sizeof(ifgr.ifgr_name));
1267 	if (ioctl(s, SIOCGIFGMEMB, (caddr_t)&ifgr) == 0) {
1268 		/* fake a node_host */
1269 		if ((n = calloc(1, sizeof(*n))) == NULL)
1270 			err(1, "calloc");
1271 		if ((n->ifname = strdup(ifa_name)) == NULL)
1272 			err(1, "strdup");
1273 		close(s);
1274 		return (n);
1275 	}
1276 	close(s);
1277 
1278 	for (n = iftab; n; n = n->next) {
1279 		if (n->af == AF_LINK && !strncmp(n->ifname, ifa_name, IFNAMSIZ))
1280 			return (n);
1281 	}
1282 
1283 	return (NULL);
1284 }
1285 
1286 struct node_host *
1287 ifa_grouplookup(const char *ifa_name, int flags)
1288 {
1289 	struct ifg_req		*ifg;
1290 	struct ifgroupreq	 ifgr;
1291 	int			 s, len;
1292 	struct node_host	*n, *h = NULL;
1293 
1294 	if ((s = socket(get_socket_domain(), SOCK_DGRAM, 0)) == -1)
1295 		err(1, "socket");
1296 	bzero(&ifgr, sizeof(ifgr));
1297 	strlcpy(ifgr.ifgr_name, ifa_name, sizeof(ifgr.ifgr_name));
1298 	if (ioctl(s, SIOCGIFGMEMB, (caddr_t)&ifgr) == -1) {
1299 		close(s);
1300 		return (NULL);
1301 	}
1302 
1303 	len = ifgr.ifgr_len;
1304 	if ((ifgr.ifgr_groups = calloc(1, len)) == NULL)
1305 		err(1, "calloc");
1306 	if (ioctl(s, SIOCGIFGMEMB, (caddr_t)&ifgr) == -1)
1307 		err(1, "SIOCGIFGMEMB");
1308 
1309 	for (ifg = ifgr.ifgr_groups; ifg && len >= sizeof(struct ifg_req);
1310 	    ifg++) {
1311 		len -= sizeof(struct ifg_req);
1312 		if ((n = ifa_lookup(ifg->ifgrq_member, flags)) == NULL)
1313 			continue;
1314 		if (h == NULL)
1315 			h = n;
1316 		else {
1317 			h->tail->next = n;
1318 			h->tail = n->tail;
1319 		}
1320 	}
1321 	free(ifgr.ifgr_groups);
1322 	close(s);
1323 
1324 	return (h);
1325 }
1326 
1327 struct node_host *
1328 ifa_lookup(const char *ifa_name, int flags)
1329 {
1330 	struct node_host	*p = NULL, *h = NULL, *n = NULL;
1331 	int			 got4 = 0, got6 = 0;
1332 	const char		 *last_if = NULL;
1333 
1334 	if ((h = ifa_grouplookup(ifa_name, flags)) != NULL)
1335 		return (h);
1336 
1337 	if (!strncmp(ifa_name, "self", IFNAMSIZ))
1338 		ifa_name = NULL;
1339 
1340 	if (iftab == NULL)
1341 		ifa_load();
1342 
1343 	for (p = iftab; p; p = p->next) {
1344 		if (ifa_skip_if(ifa_name, p))
1345 			continue;
1346 		if ((flags & PFI_AFLAG_BROADCAST) && p->af != AF_INET)
1347 			continue;
1348 		if ((flags & PFI_AFLAG_BROADCAST) &&
1349 		    !(p->ifa_flags & IFF_BROADCAST))
1350 			continue;
1351 		if ((flags & PFI_AFLAG_PEER) &&
1352 		    !(p->ifa_flags & IFF_POINTOPOINT))
1353 			continue;
1354 		if ((flags & PFI_AFLAG_NETWORK) && p->ifindex > 0)
1355 			continue;
1356 		if (last_if == NULL || strcmp(last_if, p->ifname))
1357 			got4 = got6 = 0;
1358 		last_if = p->ifname;
1359 		if ((flags & PFI_AFLAG_NOALIAS) && p->af == AF_INET && got4)
1360 			continue;
1361 		if ((flags & PFI_AFLAG_NOALIAS) && p->af == AF_INET6 && got6)
1362 			continue;
1363 		if (p->af == AF_INET)
1364 			got4 = 1;
1365 		else
1366 			got6 = 1;
1367 		n = calloc(1, sizeof(struct node_host));
1368 		if (n == NULL)
1369 			err(1, "address: calloc");
1370 		n->af = p->af;
1371 		if (flags & PFI_AFLAG_BROADCAST)
1372 			memcpy(&n->addr.v.a.addr, &p->bcast,
1373 			    sizeof(struct pf_addr));
1374 		else if (flags & PFI_AFLAG_PEER)
1375 			memcpy(&n->addr.v.a.addr, &p->peer,
1376 			    sizeof(struct pf_addr));
1377 		else
1378 			memcpy(&n->addr.v.a.addr, &p->addr.v.a.addr,
1379 			    sizeof(struct pf_addr));
1380 		if (flags & PFI_AFLAG_NETWORK)
1381 			set_ipmask(n, unmask(&p->addr.v.a.mask, n->af));
1382 		else {
1383 			if (n->af == AF_INET) {
1384 				if (p->ifa_flags & IFF_LOOPBACK &&
1385 				    p->ifa_flags & IFF_LINK1)
1386 					memcpy(&n->addr.v.a.mask,
1387 					    &p->addr.v.a.mask,
1388 					    sizeof(struct pf_addr));
1389 				else
1390 					set_ipmask(n, 32);
1391 			} else
1392 				set_ipmask(n, 128);
1393 		}
1394 		n->ifindex = p->ifindex;
1395 
1396 		n->next = NULL;
1397 		n->tail = n;
1398 		if (h == NULL)
1399 			h = n;
1400 		else {
1401 			h->tail->next = n;
1402 			h->tail = n;
1403 		}
1404 	}
1405 	return (h);
1406 }
1407 
1408 int
1409 ifa_skip_if(const char *filter, struct node_host *p)
1410 {
1411 	int	n;
1412 
1413 	if (p->af != AF_INET && p->af != AF_INET6)
1414 		return (1);
1415 	if (filter == NULL || !*filter)
1416 		return (0);
1417 	if (!strcmp(p->ifname, filter))
1418 		return (0);	/* exact match */
1419 	n = strlen(filter);
1420 	if (n < 1 || n >= IFNAMSIZ)
1421 		return (1);	/* sanity check */
1422 	if (filter[n-1] >= '0' && filter[n-1] <= '9')
1423 		return (1);	/* only do exact match in that case */
1424 	if (strncmp(p->ifname, filter, n))
1425 		return (1);	/* prefix doesn't match */
1426 	return (p->ifname[n] < '0' || p->ifname[n] > '9');
1427 }
1428 
1429 
1430 struct node_host *
1431 host(const char *s)
1432 {
1433 	struct node_host	*h = NULL;
1434 	int			 mask, v4mask, v6mask, cont = 1;
1435 	char			*p, *q, *ps;
1436 
1437 	if ((p = strrchr(s, '/')) != NULL) {
1438 		mask = strtol(p+1, &q, 0);
1439 		if (!q || *q || mask > 128 || q == (p+1)) {
1440 			fprintf(stderr, "invalid netmask '%s'\n", p);
1441 			return (NULL);
1442 		}
1443 		if ((ps = malloc(strlen(s) - strlen(p) + 1)) == NULL)
1444 			err(1, "host: malloc");
1445 		strlcpy(ps, s, strlen(s) - strlen(p) + 1);
1446 		v4mask = v6mask = mask;
1447 	} else {
1448 		if ((ps = strdup(s)) == NULL)
1449 			err(1, "host: strdup");
1450 		v4mask = 32;
1451 		v6mask = 128;
1452 		mask = -1;
1453 	}
1454 
1455 	/* interface with this name exists? */
1456 	if (cont && (h = host_if(ps, mask)) != NULL)
1457 		cont = 0;
1458 
1459 	/* IPv4 address? */
1460 	if (cont && (h = host_v4(s, mask)) != NULL)
1461 		cont = 0;
1462 
1463 	/* IPv6 address? */
1464 	if (cont && (h = host_v6(ps, v6mask)) != NULL)
1465 		cont = 0;
1466 
1467 	/* dns lookup */
1468 	if (cont && (h = host_dns(ps, v4mask, v6mask)) != NULL)
1469 		cont = 0;
1470 	free(ps);
1471 
1472 	if (h == NULL || cont == 1) {
1473 		fprintf(stderr, "no IP address found for %s\n", s);
1474 		return (NULL);
1475 	}
1476 	return (h);
1477 }
1478 
1479 struct node_host *
1480 host_if(const char *s, int mask)
1481 {
1482 	struct node_host	*n, *h = NULL;
1483 	char			*p, *ps;
1484 	int			 flags = 0;
1485 
1486 	if ((ps = strdup(s)) == NULL)
1487 		err(1, "host_if: strdup");
1488 	while ((p = strrchr(ps, ':')) != NULL) {
1489 		if (!strcmp(p+1, "network"))
1490 			flags |= PFI_AFLAG_NETWORK;
1491 		else if (!strcmp(p+1, "broadcast"))
1492 			flags |= PFI_AFLAG_BROADCAST;
1493 		else if (!strcmp(p+1, "peer"))
1494 			flags |= PFI_AFLAG_PEER;
1495 		else if (!strcmp(p+1, "0"))
1496 			flags |= PFI_AFLAG_NOALIAS;
1497 		else {
1498 			free(ps);
1499 			return (NULL);
1500 		}
1501 		*p = '\0';
1502 	}
1503 	if (flags & (flags - 1) & PFI_AFLAG_MODEMASK) { /* Yep! */
1504 		fprintf(stderr, "illegal combination of interface modifiers\n");
1505 		free(ps);
1506 		return (NULL);
1507 	}
1508 	if ((flags & (PFI_AFLAG_NETWORK|PFI_AFLAG_BROADCAST)) && mask > -1) {
1509 		fprintf(stderr, "network or broadcast lookup, but "
1510 		    "extra netmask given\n");
1511 		free(ps);
1512 		return (NULL);
1513 	}
1514 	if (ifa_exists(ps) || !strncmp(ps, "self", IFNAMSIZ)) {
1515 		/* interface with this name exists */
1516 		h = ifa_lookup(ps, flags);
1517 		for (n = h; n != NULL && mask > -1; n = n->next)
1518 			set_ipmask(n, mask);
1519 	}
1520 
1521 	free(ps);
1522 	return (h);
1523 }
1524 
1525 struct node_host *
1526 host_v4(const char *s, int mask)
1527 {
1528 	struct node_host	*h = NULL;
1529 	struct in_addr		 ina;
1530 	int			 bits = 32;
1531 
1532 	memset(&ina, 0, sizeof(struct in_addr));
1533 	if (strrchr(s, '/') != NULL) {
1534 		if ((bits = inet_net_pton(AF_INET, s, &ina, sizeof(ina))) == -1)
1535 			return (NULL);
1536 	} else {
1537 		if (inet_pton(AF_INET, s, &ina) != 1)
1538 			return (NULL);
1539 	}
1540 
1541 	h = calloc(1, sizeof(struct node_host));
1542 	if (h == NULL)
1543 		err(1, "address: calloc");
1544 	h->ifname = NULL;
1545 	h->af = AF_INET;
1546 	h->addr.v.a.addr.addr32[0] = ina.s_addr;
1547 	set_ipmask(h, bits);
1548 	h->next = NULL;
1549 	h->tail = h;
1550 
1551 	return (h);
1552 }
1553 
1554 struct node_host *
1555 host_v6(const char *s, int mask)
1556 {
1557 	struct addrinfo		 hints, *res;
1558 	struct node_host	*h = NULL;
1559 
1560 	memset(&hints, 0, sizeof(hints));
1561 	hints.ai_family = AF_INET6;
1562 	hints.ai_socktype = SOCK_DGRAM; /*dummy*/
1563 	hints.ai_flags = AI_NUMERICHOST;
1564 	if (getaddrinfo(s, "0", &hints, &res) == 0) {
1565 		h = calloc(1, sizeof(struct node_host));
1566 		if (h == NULL)
1567 			err(1, "address: calloc");
1568 		h->ifname = NULL;
1569 		h->af = AF_INET6;
1570 		memcpy(&h->addr.v.a.addr,
1571 		    &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr,
1572 		    sizeof(h->addr.v.a.addr));
1573 		h->ifindex =
1574 		    ((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id;
1575 		set_ipmask(h, mask);
1576 		freeaddrinfo(res);
1577 		h->next = NULL;
1578 		h->tail = h;
1579 	}
1580 
1581 	return (h);
1582 }
1583 
1584 struct node_host *
1585 host_dns(const char *s, int v4mask, int v6mask)
1586 {
1587 	struct addrinfo		 hints, *res0, *res;
1588 	struct node_host	*n, *h = NULL;
1589 	int			 error, noalias = 0;
1590 	int			 got4 = 0, got6 = 0;
1591 	char			*p, *ps;
1592 
1593 	if ((ps = strdup(s)) == NULL)
1594 		err(1, "host_dns: strdup");
1595 	if ((p = strrchr(ps, ':')) != NULL && !strcmp(p, ":0")) {
1596 		noalias = 1;
1597 		*p = '\0';
1598 	}
1599 	memset(&hints, 0, sizeof(hints));
1600 	hints.ai_family = PF_UNSPEC;
1601 	hints.ai_socktype = SOCK_STREAM; /* DUMMY */
1602 	error = getaddrinfo(ps, NULL, &hints, &res0);
1603 	if (error) {
1604 		free(ps);
1605 		return (h);
1606 	}
1607 
1608 	for (res = res0; res; res = res->ai_next) {
1609 		if (res->ai_family != AF_INET &&
1610 		    res->ai_family != AF_INET6)
1611 			continue;
1612 		if (noalias) {
1613 			if (res->ai_family == AF_INET) {
1614 				if (got4)
1615 					continue;
1616 				got4 = 1;
1617 			} else {
1618 				if (got6)
1619 					continue;
1620 				got6 = 1;
1621 			}
1622 		}
1623 		n = calloc(1, sizeof(struct node_host));
1624 		if (n == NULL)
1625 			err(1, "host_dns: calloc");
1626 		n->ifname = NULL;
1627 		n->af = res->ai_family;
1628 		if (res->ai_family == AF_INET) {
1629 			memcpy(&n->addr.v.a.addr,
1630 			    &((struct sockaddr_in *)
1631 			    res->ai_addr)->sin_addr.s_addr,
1632 			    sizeof(struct in_addr));
1633 			set_ipmask(n, v4mask);
1634 		} else {
1635 			memcpy(&n->addr.v.a.addr,
1636 			    &((struct sockaddr_in6 *)
1637 			    res->ai_addr)->sin6_addr.s6_addr,
1638 			    sizeof(struct in6_addr));
1639 			n->ifindex =
1640 			    ((struct sockaddr_in6 *)
1641 			    res->ai_addr)->sin6_scope_id;
1642 			set_ipmask(n, v6mask);
1643 		}
1644 		n->next = NULL;
1645 		n->tail = n;
1646 		if (h == NULL)
1647 			h = n;
1648 		else {
1649 			h->tail->next = n;
1650 			h->tail = n;
1651 		}
1652 	}
1653 	freeaddrinfo(res0);
1654 	free(ps);
1655 
1656 	return (h);
1657 }
1658 
1659 /*
1660  * convert a hostname to a list of addresses and put them in the given buffer.
1661  * test:
1662  *	if set to 1, only simple addresses are accepted (no netblock, no "!").
1663  */
1664 int
1665 append_addr(struct pfr_buffer *b, char *s, int test)
1666 {
1667 	char			 *r;
1668 	struct node_host	*h, *n;
1669 	int			 rv, not = 0;
1670 
1671 	for (r = s; *r == '!'; r++)
1672 		not = !not;
1673 	if ((n = host(r)) == NULL) {
1674 		errno = 0;
1675 		return (-1);
1676 	}
1677 	rv = append_addr_host(b, n, test, not);
1678 	do {
1679 		h = n;
1680 		n = n->next;
1681 		free(h);
1682 	} while (n != NULL);
1683 	return (rv);
1684 }
1685 
1686 /*
1687  * same as previous function, but with a pre-parsed input and the ability
1688  * to "negate" the result. Does not free the node_host list.
1689  * not:
1690  *      setting it to 1 is equivalent to adding "!" in front of parameter s.
1691  */
1692 int
1693 append_addr_host(struct pfr_buffer *b, struct node_host *n, int test, int not)
1694 {
1695 	int			 bits;
1696 	struct pfr_addr		 addr;
1697 
1698 	do {
1699 		bzero(&addr, sizeof(addr));
1700 		addr.pfra_not = n->not ^ not;
1701 		addr.pfra_af = n->af;
1702 		addr.pfra_net = unmask(&n->addr.v.a.mask, n->af);
1703 		switch (n->af) {
1704 		case AF_INET:
1705 			addr.pfra_ip4addr.s_addr = n->addr.v.a.addr.addr32[0];
1706 			bits = 32;
1707 			break;
1708 		case AF_INET6:
1709 			memcpy(&addr.pfra_ip6addr, &n->addr.v.a.addr.v6,
1710 			    sizeof(struct in6_addr));
1711 			bits = 128;
1712 			break;
1713 		default:
1714 			errno = EINVAL;
1715 			return (-1);
1716 		}
1717 		if ((test && (not || addr.pfra_net != bits)) ||
1718 		    addr.pfra_net > bits) {
1719 			errno = EINVAL;
1720 			return (-1);
1721 		}
1722 		if (pfr_buf_add(b, &addr))
1723 			return (-1);
1724 	} while ((n = n->next) != NULL);
1725 
1726 	return (0);
1727 }
1728 
1729 int
1730 pfctl_add_trans(struct pfr_buffer *buf, int rs_num, const char *anchor)
1731 {
1732 	struct pfioc_trans_e trans;
1733 
1734 	bzero(&trans, sizeof(trans));
1735 	trans.rs_num = rs_num;
1736 	if (strlcpy(trans.anchor, anchor,
1737 	    sizeof(trans.anchor)) >= sizeof(trans.anchor))
1738 		errx(1, "pfctl_add_trans: strlcpy");
1739 
1740 	return pfr_buf_add(buf, &trans);
1741 }
1742 
1743 u_int32_t
1744 pfctl_get_ticket(struct pfr_buffer *buf, int rs_num, const char *anchor)
1745 {
1746 	struct pfioc_trans_e *p;
1747 
1748 	PFRB_FOREACH(p, buf)
1749 		if (rs_num == p->rs_num && !strcmp(anchor, p->anchor))
1750 			return (p->ticket);
1751 	errx(1, "pfctl_get_ticket: assertion failed");
1752 }
1753 
1754 int
1755 pfctl_trans(int dev, struct pfr_buffer *buf, u_long cmd, int from)
1756 {
1757 	struct pfioc_trans trans;
1758 
1759 	bzero(&trans, sizeof(trans));
1760 	trans.size = buf->pfrb_size - from;
1761 	trans.esize = sizeof(struct pfioc_trans_e);
1762 	trans.array = ((struct pfioc_trans_e *)buf->pfrb_caddr) + from;
1763 	return ioctl(dev, cmd, &trans);
1764 }
1765