xref: /freebsd/sys/net/pfvar.h (revision 4ba91fa0736bb0672d475b6b56d9e7b06e78ff69)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2001 Daniel Hartmeier
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  *    - Redistributions of source code must retain the above copyright
12  *      notice, this list of conditions and the following disclaimer.
13  *    - Redistributions in binary form must reproduce the above
14  *      copyright notice, this list of conditions and the following
15  *      disclaimer in the documentation and/or other materials provided
16  *      with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  *
31  *	$OpenBSD: pfvar.h,v 1.282 2009/01/29 15:12:28 pyr Exp $
32  *	$FreeBSD$
33  */
34 
35 #ifndef _NET_PFVAR_H_
36 #define _NET_PFVAR_H_
37 
38 #include <sys/param.h>
39 #include <sys/queue.h>
40 #include <sys/counter.h>
41 #include <sys/cpuset.h>
42 #include <sys/malloc.h>
43 #include <sys/nv.h>
44 #include <sys/refcount.h>
45 #include <sys/sysctl.h>
46 #include <sys/lock.h>
47 #include <sys/rmlock.h>
48 #include <sys/tree.h>
49 #include <vm/uma.h>
50 
51 #include <net/radix.h>
52 #include <netinet/in.h>
53 
54 #include <netpfil/pf/pf.h>
55 #include <netpfil/pf/pf_altq.h>
56 #include <netpfil/pf/pf_mtag.h>
57 
58 #ifdef _KERNEL
59 
60 SYSCTL_DECL(_net_pf);
61 MALLOC_DECLARE(M_PFHASH);
62 
63 struct pfi_dynaddr {
64 	TAILQ_ENTRY(pfi_dynaddr)	 entry;
65 	struct pf_addr			 pfid_addr4;
66 	struct pf_addr			 pfid_mask4;
67 	struct pf_addr			 pfid_addr6;
68 	struct pf_addr			 pfid_mask6;
69 	struct pfr_ktable		*pfid_kt;
70 	struct pfi_kkif			*pfid_kif;
71 	int				 pfid_net;	/* mask or 128 */
72 	int				 pfid_acnt4;	/* address count IPv4 */
73 	int				 pfid_acnt6;	/* address count IPv6 */
74 	sa_family_t			 pfid_af;	/* rule af */
75 	u_int8_t			 pfid_iflags;	/* PFI_AFLAG_* */
76 };
77 
78 /*
79  * Address manipulation macros
80  */
81 #define	HTONL(x)	(x) = htonl((__uint32_t)(x))
82 #define	HTONS(x)	(x) = htons((__uint16_t)(x))
83 #define	NTOHL(x)	(x) = ntohl((__uint32_t)(x))
84 #define	NTOHS(x)	(x) = ntohs((__uint16_t)(x))
85 
86 #define	PF_NAME		"pf"
87 
88 #define	PF_HASHROW_ASSERT(h)	mtx_assert(&(h)->lock, MA_OWNED)
89 #define	PF_HASHROW_LOCK(h)	mtx_lock(&(h)->lock)
90 #define	PF_HASHROW_UNLOCK(h)	mtx_unlock(&(h)->lock)
91 
92 #define	PF_STATE_LOCK(s)						\
93 	do {								\
94 		struct pf_idhash *_ih = &V_pf_idhash[PF_IDHASH(s)];	\
95 		PF_HASHROW_LOCK(_ih);					\
96 	} while (0)
97 
98 #define	PF_STATE_UNLOCK(s)						\
99 	do {								\
100 		struct pf_idhash *_ih = &V_pf_idhash[PF_IDHASH((s))];	\
101 		PF_HASHROW_UNLOCK(_ih);					\
102 	} while (0)
103 
104 #ifdef INVARIANTS
105 #define	PF_STATE_LOCK_ASSERT(s)						\
106 	do {								\
107 		struct pf_idhash *_ih = &V_pf_idhash[PF_IDHASH(s)];	\
108 		PF_HASHROW_ASSERT(_ih);					\
109 	} while (0)
110 #else /* !INVARIANTS */
111 #define	PF_STATE_LOCK_ASSERT(s)		do {} while (0)
112 #endif /* INVARIANTS */
113 
114 extern struct mtx pf_unlnkdrules_mtx;
115 #define	PF_UNLNKDRULES_LOCK()	mtx_lock(&pf_unlnkdrules_mtx)
116 #define	PF_UNLNKDRULES_UNLOCK()	mtx_unlock(&pf_unlnkdrules_mtx)
117 
118 extern struct rmlock pf_rules_lock;
119 #define	PF_RULES_RLOCK_TRACKER	struct rm_priotracker _pf_rules_tracker
120 #define	PF_RULES_RLOCK()	rm_rlock(&pf_rules_lock, &_pf_rules_tracker)
121 #define	PF_RULES_RUNLOCK()	rm_runlock(&pf_rules_lock, &_pf_rules_tracker)
122 #define	PF_RULES_WLOCK()	rm_wlock(&pf_rules_lock)
123 #define	PF_RULES_WUNLOCK()	rm_wunlock(&pf_rules_lock)
124 #define	PF_RULES_ASSERT()	rm_assert(&pf_rules_lock, RA_LOCKED)
125 #define	PF_RULES_RASSERT()	rm_assert(&pf_rules_lock, RA_RLOCKED)
126 #define	PF_RULES_WASSERT()	rm_assert(&pf_rules_lock, RA_WLOCKED)
127 
128 extern struct sx pf_end_lock;
129 
130 #define	PF_MODVER	1
131 #define	PFLOG_MODVER	1
132 #define	PFSYNC_MODVER	1
133 
134 #define	PFLOG_MINVER	1
135 #define	PFLOG_PREFVER	PFLOG_MODVER
136 #define	PFLOG_MAXVER	1
137 #define	PFSYNC_MINVER	1
138 #define	PFSYNC_PREFVER	PFSYNC_MODVER
139 #define	PFSYNC_MAXVER	1
140 
141 #ifdef INET
142 #ifndef INET6
143 #define	PF_INET_ONLY
144 #endif /* ! INET6 */
145 #endif /* INET */
146 
147 #ifdef INET6
148 #ifndef INET
149 #define	PF_INET6_ONLY
150 #endif /* ! INET */
151 #endif /* INET6 */
152 
153 #ifdef INET
154 #ifdef INET6
155 #define	PF_INET_INET6
156 #endif /* INET6 */
157 #endif /* INET */
158 
159 #else
160 
161 #define	PF_INET_INET6
162 
163 #endif /* _KERNEL */
164 
165 /* Both IPv4 and IPv6 */
166 #ifdef PF_INET_INET6
167 
168 #define PF_AEQ(a, b, c) \
169 	((c == AF_INET && (a)->addr32[0] == (b)->addr32[0]) || \
170 	(c == AF_INET6 && (a)->addr32[3] == (b)->addr32[3] && \
171 	(a)->addr32[2] == (b)->addr32[2] && \
172 	(a)->addr32[1] == (b)->addr32[1] && \
173 	(a)->addr32[0] == (b)->addr32[0])) \
174 
175 #define PF_ANEQ(a, b, c) \
176 	((c == AF_INET && (a)->addr32[0] != (b)->addr32[0]) || \
177 	(c == AF_INET6 && ((a)->addr32[0] != (b)->addr32[0] || \
178 	(a)->addr32[1] != (b)->addr32[1] || \
179 	(a)->addr32[2] != (b)->addr32[2] || \
180 	(a)->addr32[3] != (b)->addr32[3]))) \
181 
182 #define PF_AZERO(a, c) \
183 	((c == AF_INET && !(a)->addr32[0]) || \
184 	(c == AF_INET6 && !(a)->addr32[0] && !(a)->addr32[1] && \
185 	!(a)->addr32[2] && !(a)->addr32[3] )) \
186 
187 #define PF_MATCHA(n, a, m, b, f) \
188 	pf_match_addr(n, a, m, b, f)
189 
190 #define PF_ACPY(a, b, f) \
191 	pf_addrcpy(a, b, f)
192 
193 #define PF_AINC(a, f) \
194 	pf_addr_inc(a, f)
195 
196 #define PF_POOLMASK(a, b, c, d, f) \
197 	pf_poolmask(a, b, c, d, f)
198 
199 #else
200 
201 /* Just IPv6 */
202 
203 #ifdef PF_INET6_ONLY
204 
205 #define PF_AEQ(a, b, c) \
206 	((a)->addr32[3] == (b)->addr32[3] && \
207 	(a)->addr32[2] == (b)->addr32[2] && \
208 	(a)->addr32[1] == (b)->addr32[1] && \
209 	(a)->addr32[0] == (b)->addr32[0]) \
210 
211 #define PF_ANEQ(a, b, c) \
212 	((a)->addr32[3] != (b)->addr32[3] || \
213 	(a)->addr32[2] != (b)->addr32[2] || \
214 	(a)->addr32[1] != (b)->addr32[1] || \
215 	(a)->addr32[0] != (b)->addr32[0]) \
216 
217 #define PF_AZERO(a, c) \
218 	(!(a)->addr32[0] && \
219 	!(a)->addr32[1] && \
220 	!(a)->addr32[2] && \
221 	!(a)->addr32[3] ) \
222 
223 #define PF_MATCHA(n, a, m, b, f) \
224 	pf_match_addr(n, a, m, b, f)
225 
226 #define PF_ACPY(a, b, f) \
227 	pf_addrcpy(a, b, f)
228 
229 #define PF_AINC(a, f) \
230 	pf_addr_inc(a, f)
231 
232 #define PF_POOLMASK(a, b, c, d, f) \
233 	pf_poolmask(a, b, c, d, f)
234 
235 #else
236 
237 /* Just IPv4 */
238 #ifdef PF_INET_ONLY
239 
240 #define PF_AEQ(a, b, c) \
241 	((a)->addr32[0] == (b)->addr32[0])
242 
243 #define PF_ANEQ(a, b, c) \
244 	((a)->addr32[0] != (b)->addr32[0])
245 
246 #define PF_AZERO(a, c) \
247 	(!(a)->addr32[0])
248 
249 #define PF_MATCHA(n, a, m, b, f) \
250 	pf_match_addr(n, a, m, b, f)
251 
252 #define PF_ACPY(a, b, f) \
253 	(a)->v4.s_addr = (b)->v4.s_addr
254 
255 #define PF_AINC(a, f) \
256 	do { \
257 		(a)->addr32[0] = htonl(ntohl((a)->addr32[0]) + 1); \
258 	} while (0)
259 
260 #define PF_POOLMASK(a, b, c, d, f) \
261 	do { \
262 		(a)->addr32[0] = ((b)->addr32[0] & (c)->addr32[0]) | \
263 		(((c)->addr32[0] ^ 0xffffffff ) & (d)->addr32[0]); \
264 	} while (0)
265 
266 #endif /* PF_INET_ONLY */
267 #endif /* PF_INET6_ONLY */
268 #endif /* PF_INET_INET6 */
269 
270 /*
271  * XXX callers not FIB-aware in our version of pf yet.
272  * OpenBSD fixed it later it seems, 2010/05/07 13:33:16 claudio.
273  */
274 #define	PF_MISMATCHAW(aw, x, af, neg, ifp, rtid)			\
275 	(								\
276 		(((aw)->type == PF_ADDR_NOROUTE &&			\
277 		    pf_routable((x), (af), NULL, (rtid))) ||		\
278 		(((aw)->type == PF_ADDR_URPFFAILED && (ifp) != NULL &&	\
279 		    pf_routable((x), (af), (ifp), (rtid))) ||		\
280 		((aw)->type == PF_ADDR_TABLE &&				\
281 		    !pfr_match_addr((aw)->p.tbl, (x), (af))) ||		\
282 		((aw)->type == PF_ADDR_DYNIFTL &&			\
283 		    !pfi_match_addr((aw)->p.dyn, (x), (af))) ||		\
284 		((aw)->type == PF_ADDR_RANGE &&				\
285 		    !pf_match_addr_range(&(aw)->v.a.addr,		\
286 		    &(aw)->v.a.mask, (x), (af))) ||			\
287 		((aw)->type == PF_ADDR_ADDRMASK &&			\
288 		    !PF_AZERO(&(aw)->v.a.mask, (af)) &&			\
289 		    !PF_MATCHA(0, &(aw)->v.a.addr,			\
290 		    &(aw)->v.a.mask, (x), (af))))) !=			\
291 		(neg)							\
292 	)
293 
294 #define PF_ALGNMNT(off) (((off) % 2) == 0)
295 
296 #ifdef _KERNEL
297 
298 struct pf_kpooladdr {
299 	struct pf_addr_wrap		 addr;
300 	TAILQ_ENTRY(pf_kpooladdr)	 entries;
301 	char				 ifname[IFNAMSIZ];
302 	struct pfi_kkif			*kif;
303 };
304 
305 TAILQ_HEAD(pf_kpalist, pf_kpooladdr);
306 
307 struct pf_kpool {
308 	struct pf_kpalist	 list;
309 	struct pf_kpooladdr	*cur;
310 	struct pf_poolhashkey	 key;
311 	struct pf_addr		 counter;
312 	struct pf_mape_portset	 mape;
313 	int			 tblidx;
314 	u_int16_t		 proxy_port[2];
315 	u_int8_t		 opts;
316 };
317 
318 union pf_krule_ptr {
319 	struct pf_krule		*ptr;
320 	u_int32_t		 nr;
321 };
322 
323 struct pf_krule {
324 	struct pf_rule_addr	 src;
325 	struct pf_rule_addr	 dst;
326 	union pf_krule_ptr	 skip[PF_SKIP_COUNT];
327 	char			 label[PF_RULE_LABEL_SIZE];
328 	char			 ifname[IFNAMSIZ];
329 	char			 qname[PF_QNAME_SIZE];
330 	char			 pqname[PF_QNAME_SIZE];
331 	char			 tagname[PF_TAG_NAME_SIZE];
332 	char			 match_tagname[PF_TAG_NAME_SIZE];
333 
334 	char			 overload_tblname[PF_TABLE_NAME_SIZE];
335 
336 	TAILQ_ENTRY(pf_krule)	 entries;
337 	struct pf_kpool		 rpool;
338 
339 	counter_u64_t		 evaluations;
340 	counter_u64_t		 packets[2];
341 	counter_u64_t		 bytes[2];
342 
343 	struct pfi_kkif		*kif;
344 	struct pf_kanchor	*anchor;
345 	struct pfr_ktable	*overload_tbl;
346 
347 	pf_osfp_t		 os_fingerprint;
348 
349 	int			 rtableid;
350 	u_int32_t		 timeout[PFTM_MAX];
351 	u_int32_t		 max_states;
352 	u_int32_t		 max_src_nodes;
353 	u_int32_t		 max_src_states;
354 	u_int32_t		 max_src_conn;
355 	struct {
356 		u_int32_t		limit;
357 		u_int32_t		seconds;
358 	}			 max_src_conn_rate;
359 	u_int32_t		 qid;
360 	u_int32_t		 pqid;
361 	u_int32_t		 nr;
362 	u_int32_t		 prob;
363 	uid_t			 cuid;
364 	pid_t			 cpid;
365 
366 	counter_u64_t		 states_cur;
367 	counter_u64_t		 states_tot;
368 	counter_u64_t		 src_nodes;
369 
370 	u_int16_t		 return_icmp;
371 	u_int16_t		 return_icmp6;
372 	u_int16_t		 max_mss;
373 	u_int16_t		 tag;
374 	u_int16_t		 match_tag;
375 	u_int16_t		 scrub_flags;
376 
377 	struct pf_rule_uid	 uid;
378 	struct pf_rule_gid	 gid;
379 
380 	u_int32_t		 rule_flag;
381 	uint32_t		 rule_ref;
382 	u_int8_t		 action;
383 	u_int8_t		 direction;
384 	u_int8_t		 log;
385 	u_int8_t		 logif;
386 	u_int8_t		 quick;
387 	u_int8_t		 ifnot;
388 	u_int8_t		 match_tag_not;
389 	u_int8_t		 natpass;
390 
391 	u_int8_t		 keep_state;
392 	sa_family_t		 af;
393 	u_int8_t		 proto;
394 	u_int8_t		 type;
395 	u_int8_t		 code;
396 	u_int8_t		 flags;
397 	u_int8_t		 flagset;
398 	u_int8_t		 min_ttl;
399 	u_int8_t		 allow_opts;
400 	u_int8_t		 rt;
401 	u_int8_t		 return_ttl;
402 	u_int8_t		 tos;
403 	u_int8_t		 set_tos;
404 	u_int8_t		 anchor_relative;
405 	u_int8_t		 anchor_wildcard;
406 
407 	u_int8_t		 flush;
408 	u_int8_t		 prio;
409 	u_int8_t		 set_prio[2];
410 
411 	struct {
412 		struct pf_addr		addr;
413 		u_int16_t		port;
414 	}			divert;
415 };
416 
417 struct pf_ksrc_node {
418 	LIST_ENTRY(pf_ksrc_node) entry;
419 	struct pf_addr	 addr;
420 	struct pf_addr	 raddr;
421 	union pf_krule_ptr rule;
422 	struct pfi_kkif	*kif;
423 	counter_u64_t	 bytes[2];
424 	counter_u64_t	 packets[2];
425 	u_int32_t	 states;
426 	u_int32_t	 conn;
427 	struct pf_threshold	conn_rate;
428 	u_int32_t	 creation;
429 	u_int32_t	 expire;
430 	sa_family_t	 af;
431 	u_int8_t	 ruletype;
432 };
433 #endif
434 
435 struct pf_state_scrub {
436 	struct timeval	pfss_last;	/* time received last packet	*/
437 	u_int32_t	pfss_tsecr;	/* last echoed timestamp	*/
438 	u_int32_t	pfss_tsval;	/* largest timestamp		*/
439 	u_int32_t	pfss_tsval0;	/* original timestamp		*/
440 	u_int16_t	pfss_flags;
441 #define PFSS_TIMESTAMP	0x0001		/* modulate timestamp		*/
442 #define PFSS_PAWS	0x0010		/* stricter PAWS checks		*/
443 #define PFSS_PAWS_IDLED	0x0020		/* was idle too long.  no PAWS	*/
444 #define PFSS_DATA_TS	0x0040		/* timestamp on data packets	*/
445 #define PFSS_DATA_NOTS	0x0080		/* no timestamp on data packets	*/
446 	u_int8_t	pfss_ttl;	/* stashed TTL			*/
447 	u_int8_t	pad;
448 	u_int32_t	pfss_ts_mod;	/* timestamp modulation		*/
449 };
450 
451 struct pf_state_host {
452 	struct pf_addr	addr;
453 	u_int16_t	port;
454 	u_int16_t	pad;
455 };
456 
457 struct pf_state_peer {
458 	struct pf_state_scrub	*scrub;	/* state is scrubbed		*/
459 	u_int32_t	seqlo;		/* Max sequence number sent	*/
460 	u_int32_t	seqhi;		/* Max the other end ACKd + win	*/
461 	u_int32_t	seqdiff;	/* Sequence number modulator	*/
462 	u_int16_t	max_win;	/* largest window (pre scaling)	*/
463 	u_int16_t	mss;		/* Maximum segment size option	*/
464 	u_int8_t	state;		/* active state level		*/
465 	u_int8_t	wscale;		/* window scaling factor	*/
466 	u_int8_t	tcp_est;	/* Did we reach TCPS_ESTABLISHED */
467 	u_int8_t	pad[1];
468 };
469 
470 /* Keep synced with struct pf_state_key. */
471 struct pf_state_key_cmp {
472 	struct pf_addr	 addr[2];
473 	u_int16_t	 port[2];
474 	sa_family_t	 af;
475 	u_int8_t	 proto;
476 	u_int8_t	 pad[2];
477 };
478 
479 struct pf_state_key {
480 	struct pf_addr	 addr[2];
481 	u_int16_t	 port[2];
482 	sa_family_t	 af;
483 	u_int8_t	 proto;
484 	u_int8_t	 pad[2];
485 
486 	LIST_ENTRY(pf_state_key) entry;
487 	TAILQ_HEAD(, pf_state)	 states[2];
488 };
489 
490 /* Keep synced with struct pf_state. */
491 struct pf_state_cmp {
492 	u_int64_t		 id;
493 	u_int32_t		 creatorid;
494 	u_int8_t		 direction;
495 	u_int8_t		 pad[3];
496 };
497 
498 #define	PFSTATE_ALLOWOPTS	0x01
499 #define	PFSTATE_SLOPPY		0x02
500 /*  was	PFSTATE_PFLOW		0x04 */
501 #define	PFSTATE_NOSYNC		0x08
502 #define	PFSTATE_ACK		0x10
503 #define	PFSTATE_SETPRIO		0x0200
504 #define	PFSTATE_SETMASK   (PFSTATE_SETPRIO)
505 
506 #ifdef _KERNEL
507 struct pf_state {
508 	u_int64_t		 id;
509 	u_int32_t		 creatorid;
510 	u_int8_t		 direction;
511 	u_int8_t		 pad[3];
512 
513 	u_int			 refs;
514 	TAILQ_ENTRY(pf_state)	 sync_list;
515 	TAILQ_ENTRY(pf_state)	 key_list[2];
516 	LIST_ENTRY(pf_state)	 entry;
517 	struct pf_state_peer	 src;
518 	struct pf_state_peer	 dst;
519 	union pf_krule_ptr	 rule;
520 	union pf_krule_ptr	 anchor;
521 	union pf_krule_ptr	 nat_rule;
522 	struct pf_addr		 rt_addr;
523 	struct pf_state_key	*key[2];	/* addresses stack and wire  */
524 	struct pfi_kkif		*kif;
525 	struct pfi_kkif		*rt_kif;
526 	struct pf_ksrc_node	*src_node;
527 	struct pf_ksrc_node	*nat_src_node;
528 	counter_u64_t		 packets[2];
529 	counter_u64_t		 bytes[2];
530 	u_int32_t		 creation;
531 	u_int32_t	 	 expire;
532 	u_int32_t		 pfsync_time;
533 	u_int16_t		 tag;
534 	u_int8_t		 log;
535 	u_int8_t		 state_flags;
536 	u_int8_t		 timeout;
537 	u_int8_t		 sync_state; /* PFSYNC_S_x */
538 
539 	/* XXX */
540 	u_int8_t		 sync_updates;
541 	u_int8_t		_tail[3];
542 };
543 #endif
544 
545 /*
546  * Unified state structures for pulling states out of the kernel
547  * used by pfsync(4) and the pf(4) ioctl.
548  */
549 struct pfsync_state_scrub {
550 	u_int16_t	pfss_flags;
551 	u_int8_t	pfss_ttl;	/* stashed TTL		*/
552 #define PFSYNC_SCRUB_FLAG_VALID		0x01
553 	u_int8_t	scrub_flag;
554 	u_int32_t	pfss_ts_mod;	/* timestamp modulation	*/
555 } __packed;
556 
557 struct pfsync_state_peer {
558 	struct pfsync_state_scrub scrub;	/* state is scrubbed	*/
559 	u_int32_t	seqlo;		/* Max sequence number sent	*/
560 	u_int32_t	seqhi;		/* Max the other end ACKd + win	*/
561 	u_int32_t	seqdiff;	/* Sequence number modulator	*/
562 	u_int16_t	max_win;	/* largest window (pre scaling)	*/
563 	u_int16_t	mss;		/* Maximum segment size option	*/
564 	u_int8_t	state;		/* active state level		*/
565 	u_int8_t	wscale;		/* window scaling factor	*/
566 	u_int8_t	pad[6];
567 } __packed;
568 
569 struct pfsync_state_key {
570 	struct pf_addr	 addr[2];
571 	u_int16_t	 port[2];
572 };
573 
574 struct pfsync_state {
575 	u_int64_t	 id;
576 	char		 ifname[IFNAMSIZ];
577 	struct pfsync_state_key	key[2];
578 	struct pfsync_state_peer src;
579 	struct pfsync_state_peer dst;
580 	struct pf_addr	 rt_addr;
581 	u_int32_t	 rule;
582 	u_int32_t	 anchor;
583 	u_int32_t	 nat_rule;
584 	u_int32_t	 creation;
585 	u_int32_t	 expire;
586 	u_int32_t	 packets[2][2];
587 	u_int32_t	 bytes[2][2];
588 	u_int32_t	 creatorid;
589 	sa_family_t	 af;
590 	u_int8_t	 proto;
591 	u_int8_t	 direction;
592 	u_int8_t	 __spare[2];
593 	u_int8_t	 log;
594 	u_int8_t	 state_flags;
595 	u_int8_t	 timeout;
596 	u_int8_t	 sync_flags;
597 	u_int8_t	 updates;
598 } __packed;
599 
600 #ifdef _KERNEL
601 /* pfsync */
602 typedef int		pfsync_state_import_t(struct pfsync_state *, u_int8_t);
603 typedef	void		pfsync_insert_state_t(struct pf_state *);
604 typedef	void		pfsync_update_state_t(struct pf_state *);
605 typedef	void		pfsync_delete_state_t(struct pf_state *);
606 typedef void		pfsync_clear_states_t(u_int32_t, const char *);
607 typedef int		pfsync_defer_t(struct pf_state *, struct mbuf *);
608 typedef void		pfsync_detach_ifnet_t(struct ifnet *);
609 
610 VNET_DECLARE(pfsync_state_import_t *, pfsync_state_import_ptr);
611 #define V_pfsync_state_import_ptr	VNET(pfsync_state_import_ptr)
612 VNET_DECLARE(pfsync_insert_state_t *, pfsync_insert_state_ptr);
613 #define V_pfsync_insert_state_ptr	VNET(pfsync_insert_state_ptr)
614 VNET_DECLARE(pfsync_update_state_t *, pfsync_update_state_ptr);
615 #define V_pfsync_update_state_ptr	VNET(pfsync_update_state_ptr)
616 VNET_DECLARE(pfsync_delete_state_t *, pfsync_delete_state_ptr);
617 #define V_pfsync_delete_state_ptr	VNET(pfsync_delete_state_ptr)
618 VNET_DECLARE(pfsync_clear_states_t *, pfsync_clear_states_ptr);
619 #define V_pfsync_clear_states_ptr	VNET(pfsync_clear_states_ptr)
620 VNET_DECLARE(pfsync_defer_t *, pfsync_defer_ptr);
621 #define V_pfsync_defer_ptr		VNET(pfsync_defer_ptr)
622 extern pfsync_detach_ifnet_t	*pfsync_detach_ifnet_ptr;
623 
624 void			pfsync_state_export(struct pfsync_state *,
625 			    struct pf_state *);
626 
627 /* pflog */
628 struct pf_kruleset;
629 struct pf_pdesc;
630 typedef int pflog_packet_t(struct pfi_kkif *, struct mbuf *, sa_family_t,
631     u_int8_t, u_int8_t, struct pf_krule *, struct pf_krule *,
632     struct pf_kruleset *, struct pf_pdesc *, int);
633 extern pflog_packet_t		*pflog_packet_ptr;
634 
635 #endif /* _KERNEL */
636 
637 #define	PFSYNC_FLAG_SRCNODE	0x04
638 #define	PFSYNC_FLAG_NATSRCNODE	0x08
639 
640 /* for copies to/from network byte order */
641 /* ioctl interface also uses network byte order */
642 #define pf_state_peer_hton(s,d) do {		\
643 	(d)->seqlo = htonl((s)->seqlo);		\
644 	(d)->seqhi = htonl((s)->seqhi);		\
645 	(d)->seqdiff = htonl((s)->seqdiff);	\
646 	(d)->max_win = htons((s)->max_win);	\
647 	(d)->mss = htons((s)->mss);		\
648 	(d)->state = (s)->state;		\
649 	(d)->wscale = (s)->wscale;		\
650 	if ((s)->scrub) {						\
651 		(d)->scrub.pfss_flags = 				\
652 		    htons((s)->scrub->pfss_flags & PFSS_TIMESTAMP);	\
653 		(d)->scrub.pfss_ttl = (s)->scrub->pfss_ttl;		\
654 		(d)->scrub.pfss_ts_mod = htonl((s)->scrub->pfss_ts_mod);\
655 		(d)->scrub.scrub_flag = PFSYNC_SCRUB_FLAG_VALID;	\
656 	}								\
657 } while (0)
658 
659 #define pf_state_peer_ntoh(s,d) do {		\
660 	(d)->seqlo = ntohl((s)->seqlo);		\
661 	(d)->seqhi = ntohl((s)->seqhi);		\
662 	(d)->seqdiff = ntohl((s)->seqdiff);	\
663 	(d)->max_win = ntohs((s)->max_win);	\
664 	(d)->mss = ntohs((s)->mss);		\
665 	(d)->state = (s)->state;		\
666 	(d)->wscale = (s)->wscale;		\
667 	if ((s)->scrub.scrub_flag == PFSYNC_SCRUB_FLAG_VALID && 	\
668 	    (d)->scrub != NULL) {					\
669 		(d)->scrub->pfss_flags =				\
670 		    ntohs((s)->scrub.pfss_flags) & PFSS_TIMESTAMP;	\
671 		(d)->scrub->pfss_ttl = (s)->scrub.pfss_ttl;		\
672 		(d)->scrub->pfss_ts_mod = ntohl((s)->scrub.pfss_ts_mod);\
673 	}								\
674 } while (0)
675 
676 #define pf_state_counter_hton(s,d) do {				\
677 	d[0] = htonl((s>>32)&0xffffffff);			\
678 	d[1] = htonl(s&0xffffffff);				\
679 } while (0)
680 
681 #define pf_state_counter_from_pfsync(s)				\
682 	(((u_int64_t)(s[0])<<32) | (u_int64_t)(s[1]))
683 
684 #define pf_state_counter_ntoh(s,d) do {				\
685 	d = ntohl(s[0]);					\
686 	d = d<<32;						\
687 	d += ntohl(s[1]);					\
688 } while (0)
689 
690 TAILQ_HEAD(pf_krulequeue, pf_krule);
691 
692 struct pf_kanchor;
693 
694 struct pf_kruleset {
695 	struct {
696 		struct pf_krulequeue	 queues[2];
697 		struct {
698 			struct pf_krulequeue	*ptr;
699 			struct pf_krule		**ptr_array;
700 			u_int32_t		 rcount;
701 			u_int32_t		 ticket;
702 			int			 open;
703 		}			 active, inactive;
704 	}			 rules[PF_RULESET_MAX];
705 	struct pf_kanchor	*anchor;
706 	u_int32_t		 tticket;
707 	int			 tables;
708 	int			 topen;
709 };
710 
711 RB_HEAD(pf_kanchor_global, pf_kanchor);
712 RB_HEAD(pf_kanchor_node, pf_kanchor);
713 struct pf_kanchor {
714 	RB_ENTRY(pf_kanchor)	 entry_global;
715 	RB_ENTRY(pf_kanchor)	 entry_node;
716 	struct pf_kanchor	*parent;
717 	struct pf_kanchor_node	 children;
718 	char			 name[PF_ANCHOR_NAME_SIZE];
719 	char			 path[MAXPATHLEN];
720 	struct pf_kruleset	 ruleset;
721 	int			 refcnt;	/* anchor rules */
722 	int			 match;	/* XXX: used for pfctl black magic */
723 };
724 RB_PROTOTYPE(pf_kanchor_global, pf_kanchor, entry_global, pf_anchor_compare);
725 RB_PROTOTYPE(pf_kanchor_node, pf_kanchor, entry_node, pf_kanchor_compare);
726 
727 #define PF_RESERVED_ANCHOR	"_pf"
728 
729 #define PFR_TFLAG_PERSIST	0x00000001
730 #define PFR_TFLAG_CONST		0x00000002
731 #define PFR_TFLAG_ACTIVE	0x00000004
732 #define PFR_TFLAG_INACTIVE	0x00000008
733 #define PFR_TFLAG_REFERENCED	0x00000010
734 #define PFR_TFLAG_REFDANCHOR	0x00000020
735 #define PFR_TFLAG_COUNTERS	0x00000040
736 /* Adjust masks below when adding flags. */
737 #define PFR_TFLAG_USRMASK	(PFR_TFLAG_PERSIST	| \
738 				 PFR_TFLAG_CONST	| \
739 				 PFR_TFLAG_COUNTERS)
740 #define PFR_TFLAG_SETMASK	(PFR_TFLAG_ACTIVE	| \
741 				 PFR_TFLAG_INACTIVE	| \
742 				 PFR_TFLAG_REFERENCED	| \
743 				 PFR_TFLAG_REFDANCHOR)
744 #define PFR_TFLAG_ALLMASK	(PFR_TFLAG_PERSIST	| \
745 				 PFR_TFLAG_CONST	| \
746 				 PFR_TFLAG_ACTIVE	| \
747 				 PFR_TFLAG_INACTIVE	| \
748 				 PFR_TFLAG_REFERENCED	| \
749 				 PFR_TFLAG_REFDANCHOR	| \
750 				 PFR_TFLAG_COUNTERS)
751 
752 struct pf_kanchor_stackframe;
753 
754 struct pfr_table {
755 	char			 pfrt_anchor[MAXPATHLEN];
756 	char			 pfrt_name[PF_TABLE_NAME_SIZE];
757 	u_int32_t		 pfrt_flags;
758 	u_int8_t		 pfrt_fback;
759 };
760 
761 enum { PFR_FB_NONE, PFR_FB_MATCH, PFR_FB_ADDED, PFR_FB_DELETED,
762 	PFR_FB_CHANGED, PFR_FB_CLEARED, PFR_FB_DUPLICATE,
763 	PFR_FB_NOTMATCH, PFR_FB_CONFLICT, PFR_FB_NOCOUNT, PFR_FB_MAX };
764 
765 struct pfr_addr {
766 	union {
767 		struct in_addr	 _pfra_ip4addr;
768 		struct in6_addr	 _pfra_ip6addr;
769 	}		 pfra_u;
770 	u_int8_t	 pfra_af;
771 	u_int8_t	 pfra_net;
772 	u_int8_t	 pfra_not;
773 	u_int8_t	 pfra_fback;
774 };
775 #define	pfra_ip4addr	pfra_u._pfra_ip4addr
776 #define	pfra_ip6addr	pfra_u._pfra_ip6addr
777 
778 enum { PFR_DIR_IN, PFR_DIR_OUT, PFR_DIR_MAX };
779 enum { PFR_OP_BLOCK, PFR_OP_PASS, PFR_OP_ADDR_MAX, PFR_OP_TABLE_MAX };
780 enum { PFR_TYPE_PACKETS, PFR_TYPE_BYTES, PFR_TYPE_MAX };
781 #define	PFR_NUM_COUNTERS	(PFR_DIR_MAX * PFR_OP_ADDR_MAX * PFR_TYPE_MAX)
782 #define PFR_OP_XPASS	PFR_OP_ADDR_MAX
783 
784 struct pfr_astats {
785 	struct pfr_addr	 pfras_a;
786 	u_int64_t	 pfras_packets[PFR_DIR_MAX][PFR_OP_ADDR_MAX];
787 	u_int64_t	 pfras_bytes[PFR_DIR_MAX][PFR_OP_ADDR_MAX];
788 	long		 pfras_tzero;
789 };
790 
791 enum { PFR_REFCNT_RULE, PFR_REFCNT_ANCHOR, PFR_REFCNT_MAX };
792 
793 struct pfr_tstats {
794 	struct pfr_table pfrts_t;
795 	u_int64_t	 pfrts_packets[PFR_DIR_MAX][PFR_OP_TABLE_MAX];
796 	u_int64_t	 pfrts_bytes[PFR_DIR_MAX][PFR_OP_TABLE_MAX];
797 	u_int64_t	 pfrts_match;
798 	u_int64_t	 pfrts_nomatch;
799 	long		 pfrts_tzero;
800 	int		 pfrts_cnt;
801 	int		 pfrts_refcnt[PFR_REFCNT_MAX];
802 };
803 
804 struct pfr_ktstats {
805 	struct pfr_table pfrts_t;
806 	counter_u64_t	 pfrkts_packets[PFR_DIR_MAX][PFR_OP_TABLE_MAX];
807 	counter_u64_t	 pfrkts_bytes[PFR_DIR_MAX][PFR_OP_TABLE_MAX];
808 	counter_u64_t	 pfrkts_match;
809 	counter_u64_t	 pfrkts_nomatch;
810 	long		 pfrkts_tzero;
811 	int		 pfrkts_cnt;
812 	int		 pfrkts_refcnt[PFR_REFCNT_MAX];
813 };
814 #define	pfrts_name	pfrts_t.pfrt_name
815 #define pfrts_flags	pfrts_t.pfrt_flags
816 
817 #ifndef _SOCKADDR_UNION_DEFINED
818 #define	_SOCKADDR_UNION_DEFINED
819 union sockaddr_union {
820 	struct sockaddr		sa;
821 	struct sockaddr_in	sin;
822 	struct sockaddr_in6	sin6;
823 };
824 #endif /* _SOCKADDR_UNION_DEFINED */
825 
826 struct pfr_kcounters {
827 	counter_u64_t		 pfrkc_counters;
828 	long			 pfrkc_tzero;
829 };
830 #define	pfr_kentry_counter(kc, dir, op, t)		\
831 	((kc)->pfrkc_counters +				\
832 	    (dir) * PFR_OP_ADDR_MAX * PFR_TYPE_MAX + (op) * PFR_TYPE_MAX + (t))
833 
834 #ifdef _KERNEL
835 SLIST_HEAD(pfr_kentryworkq, pfr_kentry);
836 struct pfr_kentry {
837 	struct radix_node	 pfrke_node[2];
838 	union sockaddr_union	 pfrke_sa;
839 	SLIST_ENTRY(pfr_kentry)	 pfrke_workq;
840 	struct pfr_kcounters	 pfrke_counters;
841 	u_int8_t		 pfrke_af;
842 	u_int8_t		 pfrke_net;
843 	u_int8_t		 pfrke_not;
844 	u_int8_t		 pfrke_mark;
845 };
846 
847 SLIST_HEAD(pfr_ktableworkq, pfr_ktable);
848 RB_HEAD(pfr_ktablehead, pfr_ktable);
849 struct pfr_ktable {
850 	struct pfr_ktstats	 pfrkt_kts;
851 	RB_ENTRY(pfr_ktable)	 pfrkt_tree;
852 	SLIST_ENTRY(pfr_ktable)	 pfrkt_workq;
853 	struct radix_node_head	*pfrkt_ip4;
854 	struct radix_node_head	*pfrkt_ip6;
855 	struct pfr_ktable	*pfrkt_shadow;
856 	struct pfr_ktable	*pfrkt_root;
857 	struct pf_kruleset	*pfrkt_rs;
858 	long			 pfrkt_larg;
859 	int			 pfrkt_nflags;
860 };
861 #define pfrkt_t		pfrkt_kts.pfrts_t
862 #define pfrkt_name	pfrkt_t.pfrt_name
863 #define pfrkt_anchor	pfrkt_t.pfrt_anchor
864 #define pfrkt_ruleset	pfrkt_t.pfrt_ruleset
865 #define pfrkt_flags	pfrkt_t.pfrt_flags
866 #define pfrkt_cnt	pfrkt_kts.pfrkts_cnt
867 #define pfrkt_refcnt	pfrkt_kts.pfrkts_refcnt
868 #define pfrkt_packets	pfrkt_kts.pfrkts_packets
869 #define pfrkt_bytes	pfrkt_kts.pfrkts_bytes
870 #define pfrkt_match	pfrkt_kts.pfrkts_match
871 #define pfrkt_nomatch	pfrkt_kts.pfrkts_nomatch
872 #define pfrkt_tzero	pfrkt_kts.pfrkts_tzero
873 #endif
874 
875 #ifdef _KERNEL
876 struct pfi_kkif {
877 	char				 pfik_name[IFNAMSIZ];
878 	union {
879 		RB_ENTRY(pfi_kkif)	 _pfik_tree;
880 		LIST_ENTRY(pfi_kkif)	 _pfik_list;
881 	} _pfik_glue;
882 #define	pfik_tree	_pfik_glue._pfik_tree
883 #define	pfik_list	_pfik_glue._pfik_list
884 	counter_u64_t			 pfik_packets[2][2][2];
885 	counter_u64_t			 pfik_bytes[2][2][2];
886 	u_int32_t			 pfik_tzero;
887 	u_int				 pfik_flags;
888 	struct ifnet			*pfik_ifp;
889 	struct ifg_group		*pfik_group;
890 	u_int				 pfik_rulerefs;
891 	TAILQ_HEAD(, pfi_dynaddr)	 pfik_dynaddrs;
892 };
893 #endif
894 
895 #define	PFI_IFLAG_REFS		0x0001	/* has state references */
896 #define PFI_IFLAG_SKIP		0x0100	/* skip filtering on interface */
897 
898 #ifdef _KERNEL
899 struct pf_pdesc {
900 	struct {
901 		int	 done;
902 		uid_t	 uid;
903 		gid_t	 gid;
904 	}		 lookup;
905 	u_int64_t	 tot_len;	/* Make Mickey money */
906 	union {
907 		struct tcphdr		*tcp;
908 		struct udphdr		*udp;
909 		struct icmp		*icmp;
910 #ifdef INET6
911 		struct icmp6_hdr	*icmp6;
912 #endif /* INET6 */
913 		void			*any;
914 	} hdr;
915 
916 	struct pf_krule	*nat_rule;	/* nat/rdr rule applied to packet */
917 	struct pf_addr	*src;		/* src address */
918 	struct pf_addr	*dst;		/* dst address */
919 	u_int16_t *sport;
920 	u_int16_t *dport;
921 	struct pf_mtag	*pf_mtag;
922 
923 	u_int32_t	 p_len;		/* total length of payload */
924 
925 	u_int16_t	*ip_sum;
926 	u_int16_t	*proto_sum;
927 	u_int16_t	 flags;		/* Let SCRUB trigger behavior in
928 					 * state code. Easier than tags */
929 #define PFDESC_TCP_NORM	0x0001		/* TCP shall be statefully scrubbed */
930 #define PFDESC_IP_REAS	0x0002		/* IP frags would've been reassembled */
931 	sa_family_t	 af;
932 	u_int8_t	 proto;
933 	u_int8_t	 tos;
934 	u_int8_t	 dir;		/* direction */
935 	u_int8_t	 sidx;		/* key index for source */
936 	u_int8_t	 didx;		/* key index for destination */
937 };
938 #endif
939 
940 /* flags for RDR options */
941 #define PF_DPORT_RANGE	0x01		/* Dest port uses range */
942 #define PF_RPORT_RANGE	0x02		/* RDR'ed port uses range */
943 
944 /* UDP state enumeration */
945 #define PFUDPS_NO_TRAFFIC	0
946 #define PFUDPS_SINGLE		1
947 #define PFUDPS_MULTIPLE		2
948 
949 #define PFUDPS_NSTATES		3	/* number of state levels */
950 
951 #define PFUDPS_NAMES { \
952 	"NO_TRAFFIC", \
953 	"SINGLE", \
954 	"MULTIPLE", \
955 	NULL \
956 }
957 
958 /* Other protocol state enumeration */
959 #define PFOTHERS_NO_TRAFFIC	0
960 #define PFOTHERS_SINGLE		1
961 #define PFOTHERS_MULTIPLE	2
962 
963 #define PFOTHERS_NSTATES	3	/* number of state levels */
964 
965 #define PFOTHERS_NAMES { \
966 	"NO_TRAFFIC", \
967 	"SINGLE", \
968 	"MULTIPLE", \
969 	NULL \
970 }
971 
972 #define ACTION_SET(a, x) \
973 	do { \
974 		if ((a) != NULL) \
975 			*(a) = (x); \
976 	} while (0)
977 
978 #define REASON_SET(a, x) \
979 	do { \
980 		if ((a) != NULL) \
981 			*(a) = (x); \
982 		if (x < PFRES_MAX) \
983 			counter_u64_add(V_pf_status.counters[x], 1); \
984 	} while (0)
985 
986 struct pf_kstatus {
987 	counter_u64_t	counters[PFRES_MAX]; /* reason for passing/dropping */
988 	counter_u64_t	lcounters[LCNT_MAX]; /* limit counters */
989 	counter_u64_t	fcounters[FCNT_MAX]; /* state operation counters */
990 	counter_u64_t	scounters[SCNT_MAX]; /* src_node operation counters */
991 	uint32_t	states;
992 	uint32_t	src_nodes;
993 	uint32_t	running;
994 	uint32_t	since;
995 	uint32_t	debug;
996 	uint32_t	hostid;
997 	char		ifname[IFNAMSIZ];
998 	uint8_t		pf_chksum[PF_MD5_DIGEST_LENGTH];
999 	bool		keep_counters;
1000 };
1001 
1002 struct pf_divert {
1003 	union {
1004 		struct in_addr	ipv4;
1005 		struct in6_addr	ipv6;
1006 	}		addr;
1007 	u_int16_t	port;
1008 };
1009 
1010 #define PFFRAG_FRENT_HIWAT	5000	/* Number of fragment entries */
1011 #define PFR_KENTRY_HIWAT	200000	/* Number of table entries */
1012 
1013 /*
1014  * Limit the length of the fragment queue traversal.  Remember
1015  * search entry points based on the fragment offset.
1016  */
1017 #define PF_FRAG_ENTRY_POINTS		16
1018 
1019 /*
1020  * The number of entries in the fragment queue must be limited
1021  * to avoid DoS by linear seaching.  Instead of a global limit,
1022  * use a limit per entry point.  For large packets these sum up.
1023  */
1024 #define PF_FRAG_ENTRY_LIMIT		64
1025 
1026 /*
1027  * ioctl parameter structures
1028  */
1029 
1030 struct pfioc_pooladdr {
1031 	u_int32_t		 action;
1032 	u_int32_t		 ticket;
1033 	u_int32_t		 nr;
1034 	u_int32_t		 r_num;
1035 	u_int8_t		 r_action;
1036 	u_int8_t		 r_last;
1037 	u_int8_t		 af;
1038 	char			 anchor[MAXPATHLEN];
1039 	struct pf_pooladdr	 addr;
1040 };
1041 
1042 struct pfioc_rule {
1043 	u_int32_t	 action;
1044 	u_int32_t	 ticket;
1045 	u_int32_t	 pool_ticket;
1046 	u_int32_t	 nr;
1047 	char		 anchor[MAXPATHLEN];
1048 	char		 anchor_call[MAXPATHLEN];
1049 	struct pf_rule	 rule;
1050 };
1051 
1052 struct pfioc_natlook {
1053 	struct pf_addr	 saddr;
1054 	struct pf_addr	 daddr;
1055 	struct pf_addr	 rsaddr;
1056 	struct pf_addr	 rdaddr;
1057 	u_int16_t	 sport;
1058 	u_int16_t	 dport;
1059 	u_int16_t	 rsport;
1060 	u_int16_t	 rdport;
1061 	sa_family_t	 af;
1062 	u_int8_t	 proto;
1063 	u_int8_t	 direction;
1064 };
1065 
1066 struct pfioc_state {
1067 	struct pfsync_state	state;
1068 };
1069 
1070 struct pfioc_src_node_kill {
1071 	sa_family_t psnk_af;
1072 	struct pf_rule_addr psnk_src;
1073 	struct pf_rule_addr psnk_dst;
1074 	u_int		    psnk_killed;
1075 };
1076 
1077 struct pfioc_state_kill {
1078 	struct pf_state_cmp	psk_pfcmp;
1079 	sa_family_t		psk_af;
1080 	int			psk_proto;
1081 	struct pf_rule_addr	psk_src;
1082 	struct pf_rule_addr	psk_dst;
1083 	char			psk_ifname[IFNAMSIZ];
1084 	char			psk_label[PF_RULE_LABEL_SIZE];
1085 	u_int			psk_killed;
1086 };
1087 
1088 struct pfioc_states {
1089 	int	ps_len;
1090 	union {
1091 		caddr_t			 psu_buf;
1092 		struct pfsync_state	*psu_states;
1093 	} ps_u;
1094 #define ps_buf		ps_u.psu_buf
1095 #define ps_states	ps_u.psu_states
1096 };
1097 
1098 struct pfioc_src_nodes {
1099 	int	psn_len;
1100 	union {
1101 		caddr_t		 psu_buf;
1102 		struct pf_src_node	*psu_src_nodes;
1103 	} psn_u;
1104 #define psn_buf		psn_u.psu_buf
1105 #define psn_src_nodes	psn_u.psu_src_nodes
1106 };
1107 
1108 struct pfioc_if {
1109 	char		 ifname[IFNAMSIZ];
1110 };
1111 
1112 struct pfioc_tm {
1113 	int		 timeout;
1114 	int		 seconds;
1115 };
1116 
1117 struct pfioc_limit {
1118 	int		 index;
1119 	unsigned	 limit;
1120 };
1121 
1122 struct pfioc_altq_v0 {
1123 	u_int32_t	 action;
1124 	u_int32_t	 ticket;
1125 	u_int32_t	 nr;
1126 	struct pf_altq_v0 altq;
1127 };
1128 
1129 struct pfioc_altq_v1 {
1130 	u_int32_t	 action;
1131 	u_int32_t	 ticket;
1132 	u_int32_t	 nr;
1133 	/*
1134 	 * Placed here so code that only uses the above parameters can be
1135 	 * written entirely in terms of the v0 or v1 type.
1136 	 */
1137 	u_int32_t	 version;
1138 	struct pf_altq_v1 altq;
1139 };
1140 
1141 /*
1142  * Latest version of struct pfioc_altq_vX.  This must move in lock-step with
1143  * the latest version of struct pf_altq_vX as it has that struct as a
1144  * member.
1145  */
1146 #define PFIOC_ALTQ_VERSION	PF_ALTQ_VERSION
1147 
1148 struct pfioc_qstats_v0 {
1149 	u_int32_t	 ticket;
1150 	u_int32_t	 nr;
1151 	void		*buf;
1152 	int		 nbytes;
1153 	u_int8_t	 scheduler;
1154 };
1155 
1156 struct pfioc_qstats_v1 {
1157 	u_int32_t	 ticket;
1158 	u_int32_t	 nr;
1159 	void		*buf;
1160 	int		 nbytes;
1161 	u_int8_t	 scheduler;
1162 	/*
1163 	 * Placed here so code that only uses the above parameters can be
1164 	 * written entirely in terms of the v0 or v1 type.
1165 	 */
1166 	u_int32_t	 version;  /* Requested version of stats struct */
1167 };
1168 
1169 /* Latest version of struct pfioc_qstats_vX */
1170 #define PFIOC_QSTATS_VERSION	1
1171 
1172 struct pfioc_ruleset {
1173 	u_int32_t	 nr;
1174 	char		 path[MAXPATHLEN];
1175 	char		 name[PF_ANCHOR_NAME_SIZE];
1176 };
1177 
1178 #define PF_RULESET_ALTQ		(PF_RULESET_MAX)
1179 #define PF_RULESET_TABLE	(PF_RULESET_MAX+1)
1180 struct pfioc_trans {
1181 	int		 size;	/* number of elements */
1182 	int		 esize; /* size of each element in bytes */
1183 	struct pfioc_trans_e {
1184 		int		rs_num;
1185 		char		anchor[MAXPATHLEN];
1186 		u_int32_t	ticket;
1187 	}		*array;
1188 };
1189 
1190 #define PFR_FLAG_ATOMIC		0x00000001	/* unused */
1191 #define PFR_FLAG_DUMMY		0x00000002
1192 #define PFR_FLAG_FEEDBACK	0x00000004
1193 #define PFR_FLAG_CLSTATS	0x00000008
1194 #define PFR_FLAG_ADDRSTOO	0x00000010
1195 #define PFR_FLAG_REPLACE	0x00000020
1196 #define PFR_FLAG_ALLRSETS	0x00000040
1197 #define PFR_FLAG_ALLMASK	0x0000007F
1198 #ifdef _KERNEL
1199 #define PFR_FLAG_USERIOCTL	0x10000000
1200 #endif
1201 
1202 struct pfioc_table {
1203 	struct pfr_table	 pfrio_table;
1204 	void			*pfrio_buffer;
1205 	int			 pfrio_esize;
1206 	int			 pfrio_size;
1207 	int			 pfrio_size2;
1208 	int			 pfrio_nadd;
1209 	int			 pfrio_ndel;
1210 	int			 pfrio_nchange;
1211 	int			 pfrio_flags;
1212 	u_int32_t		 pfrio_ticket;
1213 };
1214 #define	pfrio_exists	pfrio_nadd
1215 #define	pfrio_nzero	pfrio_nadd
1216 #define	pfrio_nmatch	pfrio_nadd
1217 #define pfrio_naddr	pfrio_size2
1218 #define pfrio_setflag	pfrio_size2
1219 #define pfrio_clrflag	pfrio_nadd
1220 
1221 struct pfioc_iface {
1222 	char	 pfiio_name[IFNAMSIZ];
1223 	void	*pfiio_buffer;
1224 	int	 pfiio_esize;
1225 	int	 pfiio_size;
1226 	int	 pfiio_nzero;
1227 	int	 pfiio_flags;
1228 };
1229 
1230 /*
1231  * ioctl operations
1232  */
1233 
1234 #define DIOCSTART	_IO  ('D',  1)
1235 #define DIOCSTOP	_IO  ('D',  2)
1236 #define DIOCADDRULE	_IOWR('D',  4, struct pfioc_rule)
1237 #define DIOCADDRULENV	_IOWR('D',  4, struct pfioc_nv)
1238 #define DIOCGETRULES	_IOWR('D',  6, struct pfioc_rule)
1239 #define DIOCGETRULE	_IOWR('D',  7, struct pfioc_rule)
1240 #define DIOCGETRULENV	_IOWR('D',  7, struct pfioc_nv)
1241 /* XXX cut 8 - 17 */
1242 #define DIOCCLRSTATES	_IOWR('D', 18, struct pfioc_state_kill)
1243 #define DIOCGETSTATE	_IOWR('D', 19, struct pfioc_state)
1244 #define DIOCSETSTATUSIF _IOWR('D', 20, struct pfioc_if)
1245 #define DIOCGETSTATUS	_IOWR('D', 21, struct pf_status)
1246 #define DIOCCLRSTATUS	_IO  ('D', 22)
1247 #define DIOCNATLOOK	_IOWR('D', 23, struct pfioc_natlook)
1248 #define DIOCSETDEBUG	_IOWR('D', 24, u_int32_t)
1249 #define DIOCGETSTATES	_IOWR('D', 25, struct pfioc_states)
1250 #define DIOCCHANGERULE	_IOWR('D', 26, struct pfioc_rule)
1251 /* XXX cut 26 - 28 */
1252 #define DIOCSETTIMEOUT	_IOWR('D', 29, struct pfioc_tm)
1253 #define DIOCGETTIMEOUT	_IOWR('D', 30, struct pfioc_tm)
1254 #define DIOCADDSTATE	_IOWR('D', 37, struct pfioc_state)
1255 #define DIOCCLRRULECTRS	_IO  ('D', 38)
1256 #define DIOCGETLIMIT	_IOWR('D', 39, struct pfioc_limit)
1257 #define DIOCSETLIMIT	_IOWR('D', 40, struct pfioc_limit)
1258 #define DIOCKILLSTATES	_IOWR('D', 41, struct pfioc_state_kill)
1259 #define DIOCSTARTALTQ	_IO  ('D', 42)
1260 #define DIOCSTOPALTQ	_IO  ('D', 43)
1261 #define DIOCADDALTQV0	_IOWR('D', 45, struct pfioc_altq_v0)
1262 #define DIOCADDALTQV1	_IOWR('D', 45, struct pfioc_altq_v1)
1263 #define DIOCGETALTQSV0	_IOWR('D', 47, struct pfioc_altq_v0)
1264 #define DIOCGETALTQSV1	_IOWR('D', 47, struct pfioc_altq_v1)
1265 #define DIOCGETALTQV0	_IOWR('D', 48, struct pfioc_altq_v0)
1266 #define DIOCGETALTQV1	_IOWR('D', 48, struct pfioc_altq_v1)
1267 #define DIOCCHANGEALTQV0 _IOWR('D', 49, struct pfioc_altq_v0)
1268 #define DIOCCHANGEALTQV1 _IOWR('D', 49, struct pfioc_altq_v1)
1269 #define DIOCGETQSTATSV0	_IOWR('D', 50, struct pfioc_qstats_v0)
1270 #define DIOCGETQSTATSV1	_IOWR('D', 50, struct pfioc_qstats_v1)
1271 #define DIOCBEGINADDRS	_IOWR('D', 51, struct pfioc_pooladdr)
1272 #define DIOCADDADDR	_IOWR('D', 52, struct pfioc_pooladdr)
1273 #define DIOCGETADDRS	_IOWR('D', 53, struct pfioc_pooladdr)
1274 #define DIOCGETADDR	_IOWR('D', 54, struct pfioc_pooladdr)
1275 #define DIOCCHANGEADDR	_IOWR('D', 55, struct pfioc_pooladdr)
1276 /* XXX cut 55 - 57 */
1277 #define	DIOCGETRULESETS	_IOWR('D', 58, struct pfioc_ruleset)
1278 #define	DIOCGETRULESET	_IOWR('D', 59, struct pfioc_ruleset)
1279 #define	DIOCRCLRTABLES	_IOWR('D', 60, struct pfioc_table)
1280 #define	DIOCRADDTABLES	_IOWR('D', 61, struct pfioc_table)
1281 #define	DIOCRDELTABLES	_IOWR('D', 62, struct pfioc_table)
1282 #define	DIOCRGETTABLES	_IOWR('D', 63, struct pfioc_table)
1283 #define	DIOCRGETTSTATS	_IOWR('D', 64, struct pfioc_table)
1284 #define DIOCRCLRTSTATS	_IOWR('D', 65, struct pfioc_table)
1285 #define	DIOCRCLRADDRS	_IOWR('D', 66, struct pfioc_table)
1286 #define	DIOCRADDADDRS	_IOWR('D', 67, struct pfioc_table)
1287 #define	DIOCRDELADDRS	_IOWR('D', 68, struct pfioc_table)
1288 #define	DIOCRSETADDRS	_IOWR('D', 69, struct pfioc_table)
1289 #define	DIOCRGETADDRS	_IOWR('D', 70, struct pfioc_table)
1290 #define	DIOCRGETASTATS	_IOWR('D', 71, struct pfioc_table)
1291 #define	DIOCRCLRASTATS	_IOWR('D', 72, struct pfioc_table)
1292 #define	DIOCRTSTADDRS	_IOWR('D', 73, struct pfioc_table)
1293 #define	DIOCRSETTFLAGS	_IOWR('D', 74, struct pfioc_table)
1294 #define	DIOCRINADEFINE	_IOWR('D', 77, struct pfioc_table)
1295 #define	DIOCOSFPFLUSH	_IO('D', 78)
1296 #define	DIOCOSFPADD	_IOWR('D', 79, struct pf_osfp_ioctl)
1297 #define	DIOCOSFPGET	_IOWR('D', 80, struct pf_osfp_ioctl)
1298 #define	DIOCXBEGIN	_IOWR('D', 81, struct pfioc_trans)
1299 #define	DIOCXCOMMIT	_IOWR('D', 82, struct pfioc_trans)
1300 #define	DIOCXROLLBACK	_IOWR('D', 83, struct pfioc_trans)
1301 #define	DIOCGETSRCNODES	_IOWR('D', 84, struct pfioc_src_nodes)
1302 #define	DIOCCLRSRCNODES	_IO('D', 85)
1303 #define	DIOCSETHOSTID	_IOWR('D', 86, u_int32_t)
1304 #define	DIOCIGETIFACES	_IOWR('D', 87, struct pfioc_iface)
1305 #define	DIOCSETIFFLAG	_IOWR('D', 89, struct pfioc_iface)
1306 #define	DIOCCLRIFFLAG	_IOWR('D', 90, struct pfioc_iface)
1307 #define	DIOCKILLSRCNODES	_IOWR('D', 91, struct pfioc_src_node_kill)
1308 #define	DIOCKEEPCOUNTERS	_IOWR('D', 92, struct pfioc_nv)
1309 
1310 struct pf_ifspeed_v0 {
1311 	char			ifname[IFNAMSIZ];
1312 	u_int32_t		baudrate;
1313 };
1314 
1315 struct pf_ifspeed_v1 {
1316 	char			ifname[IFNAMSIZ];
1317 	u_int32_t		baudrate32;
1318 	/* layout identical to struct pf_ifspeed_v0 up to this point */
1319 	u_int64_t		baudrate;
1320 };
1321 
1322 /* Latest version of struct pf_ifspeed_vX */
1323 #define PF_IFSPEED_VERSION	1
1324 
1325 #define	DIOCGIFSPEEDV0	_IOWR('D', 92, struct pf_ifspeed_v0)
1326 #define	DIOCGIFSPEEDV1	_IOWR('D', 92, struct pf_ifspeed_v1)
1327 
1328 /*
1329  * Compatibility and convenience macros
1330  */
1331 #ifndef _KERNEL
1332 #ifdef PFIOC_USE_LATEST
1333 /*
1334  * Maintaining in-tree consumers of the ioctl interface is easier when that
1335  * code can be written in terms old names that refer to the latest interface
1336  * version as that reduces the required changes in the consumers to those
1337  * that are functionally necessary to accommodate a new interface version.
1338  */
1339 #define	pfioc_altq	__CONCAT(pfioc_altq_v, PFIOC_ALTQ_VERSION)
1340 #define	pfioc_qstats	__CONCAT(pfioc_qstats_v, PFIOC_QSTATS_VERSION)
1341 #define	pf_ifspeed	__CONCAT(pf_ifspeed_v, PF_IFSPEED_VERSION)
1342 
1343 #define	DIOCADDALTQ	__CONCAT(DIOCADDALTQV, PFIOC_ALTQ_VERSION)
1344 #define	DIOCGETALTQS	__CONCAT(DIOCGETALTQSV, PFIOC_ALTQ_VERSION)
1345 #define	DIOCGETALTQ	__CONCAT(DIOCGETALTQV, PFIOC_ALTQ_VERSION)
1346 #define	DIOCCHANGEALTQ	__CONCAT(DIOCCHANGEALTQV, PFIOC_ALTQ_VERSION)
1347 #define	DIOCGETQSTATS	__CONCAT(DIOCGETQSTATSV, PFIOC_QSTATS_VERSION)
1348 #define	DIOCGIFSPEED	__CONCAT(DIOCGIFSPEEDV, PF_IFSPEED_VERSION)
1349 #else
1350 /*
1351  * When building out-of-tree code that is written for the old interface,
1352  * such as may exist in ports for example, resolve the old struct tags and
1353  * ioctl command names to the v0 versions.
1354  */
1355 #define	pfioc_altq	__CONCAT(pfioc_altq_v, 0)
1356 #define	pfioc_qstats	__CONCAT(pfioc_qstats_v, 0)
1357 #define	pf_ifspeed	__CONCAT(pf_ifspeed_v, 0)
1358 
1359 #define	DIOCADDALTQ	__CONCAT(DIOCADDALTQV, 0)
1360 #define	DIOCGETALTQS	__CONCAT(DIOCGETALTQSV, 0)
1361 #define	DIOCGETALTQ	__CONCAT(DIOCGETALTQV, 0)
1362 #define	DIOCCHANGEALTQ	__CONCAT(DIOCCHANGEALTQV, 0)
1363 #define	DIOCGETQSTATS	__CONCAT(DIOCGETQSTATSV, 0)
1364 #define	DIOCGIFSPEED	__CONCAT(DIOCGIFSPEEDV, 0)
1365 #endif /* PFIOC_USE_LATEST */
1366 #endif /* _KERNEL */
1367 
1368 #ifdef _KERNEL
1369 LIST_HEAD(pf_ksrc_node_list, pf_ksrc_node);
1370 struct pf_srchash {
1371 	struct pf_ksrc_node_list		nodes;
1372 	struct mtx			lock;
1373 };
1374 
1375 struct pf_keyhash {
1376 	LIST_HEAD(, pf_state_key)	keys;
1377 	struct mtx			lock;
1378 };
1379 
1380 struct pf_idhash {
1381 	LIST_HEAD(, pf_state)		states;
1382 	struct mtx			lock;
1383 };
1384 
1385 extern u_long		pf_hashmask;
1386 extern u_long		pf_srchashmask;
1387 #define	PF_HASHSIZ	(131072)
1388 #define	PF_SRCHASHSIZ	(PF_HASHSIZ/4)
1389 VNET_DECLARE(struct pf_keyhash *, pf_keyhash);
1390 VNET_DECLARE(struct pf_idhash *, pf_idhash);
1391 #define V_pf_keyhash	VNET(pf_keyhash)
1392 #define	V_pf_idhash	VNET(pf_idhash)
1393 VNET_DECLARE(struct pf_srchash *, pf_srchash);
1394 #define	V_pf_srchash	VNET(pf_srchash)
1395 
1396 #define PF_IDHASH(s)	(be64toh((s)->id) % (pf_hashmask + 1))
1397 
1398 VNET_DECLARE(void *, pf_swi_cookie);
1399 #define V_pf_swi_cookie	VNET(pf_swi_cookie)
1400 VNET_DECLARE(struct intr_event *, pf_swi_ie);
1401 #define	V_pf_swi_ie	VNET(pf_swi_ie)
1402 
1403 VNET_DECLARE(uint64_t, pf_stateid[MAXCPU]);
1404 #define	V_pf_stateid	VNET(pf_stateid)
1405 
1406 TAILQ_HEAD(pf_altqqueue, pf_altq);
1407 VNET_DECLARE(struct pf_altqqueue,	 pf_altqs[4]);
1408 #define	V_pf_altqs			 VNET(pf_altqs)
1409 VNET_DECLARE(struct pf_kpalist,		 pf_pabuf);
1410 #define	V_pf_pabuf			 VNET(pf_pabuf)
1411 
1412 VNET_DECLARE(u_int32_t,			 ticket_altqs_active);
1413 #define	V_ticket_altqs_active		 VNET(ticket_altqs_active)
1414 VNET_DECLARE(u_int32_t,			 ticket_altqs_inactive);
1415 #define	V_ticket_altqs_inactive		 VNET(ticket_altqs_inactive)
1416 VNET_DECLARE(int,			 altqs_inactive_open);
1417 #define	V_altqs_inactive_open		 VNET(altqs_inactive_open)
1418 VNET_DECLARE(u_int32_t,			 ticket_pabuf);
1419 #define	V_ticket_pabuf			 VNET(ticket_pabuf)
1420 VNET_DECLARE(struct pf_altqqueue *,	 pf_altqs_active);
1421 #define	V_pf_altqs_active		 VNET(pf_altqs_active)
1422 VNET_DECLARE(struct pf_altqqueue *,	 pf_altq_ifs_active);
1423 #define	V_pf_altq_ifs_active		 VNET(pf_altq_ifs_active)
1424 VNET_DECLARE(struct pf_altqqueue *,	 pf_altqs_inactive);
1425 #define	V_pf_altqs_inactive		 VNET(pf_altqs_inactive)
1426 VNET_DECLARE(struct pf_altqqueue *,	 pf_altq_ifs_inactive);
1427 #define	V_pf_altq_ifs_inactive		 VNET(pf_altq_ifs_inactive)
1428 
1429 VNET_DECLARE(struct pf_krulequeue, pf_unlinked_rules);
1430 #define	V_pf_unlinked_rules	VNET(pf_unlinked_rules)
1431 
1432 void				 pf_initialize(void);
1433 void				 pf_mtag_initialize(void);
1434 void				 pf_mtag_cleanup(void);
1435 void				 pf_cleanup(void);
1436 
1437 struct pf_mtag			*pf_get_mtag(struct mbuf *);
1438 
1439 extern void			 pf_calc_skip_steps(struct pf_krulequeue *);
1440 #ifdef ALTQ
1441 extern	void			 pf_altq_ifnet_event(struct ifnet *, int);
1442 #endif
1443 VNET_DECLARE(uma_zone_t,	 pf_state_z);
1444 #define	V_pf_state_z		 VNET(pf_state_z)
1445 VNET_DECLARE(uma_zone_t,	 pf_state_key_z);
1446 #define	V_pf_state_key_z	 VNET(pf_state_key_z)
1447 VNET_DECLARE(uma_zone_t,	 pf_state_scrub_z);
1448 #define	V_pf_state_scrub_z	 VNET(pf_state_scrub_z)
1449 
1450 extern void			 pf_purge_thread(void *);
1451 extern void			 pf_unload_vnet_purge(void);
1452 extern void			 pf_intr(void *);
1453 extern void			 pf_purge_expired_src_nodes(void);
1454 
1455 extern int			 pf_unlink_state(struct pf_state *, u_int);
1456 #define	PF_ENTER_LOCKED		0x00000001
1457 #define	PF_RETURN_LOCKED	0x00000002
1458 extern int			 pf_state_insert(struct pfi_kkif *,
1459 				    struct pf_state_key *,
1460 				    struct pf_state_key *,
1461 				    struct pf_state *);
1462 extern void			 pf_free_state(struct pf_state *);
1463 
1464 static __inline void
1465 pf_ref_state(struct pf_state *s)
1466 {
1467 
1468 	refcount_acquire(&s->refs);
1469 }
1470 
1471 static __inline int
1472 pf_release_state(struct pf_state *s)
1473 {
1474 
1475 	if (refcount_release(&s->refs)) {
1476 		pf_free_state(s);
1477 		return (1);
1478 	} else
1479 		return (0);
1480 }
1481 
1482 extern struct pf_state		*pf_find_state_byid(uint64_t, uint32_t);
1483 extern struct pf_state		*pf_find_state_all(struct pf_state_key_cmp *,
1484 				    u_int, int *);
1485 extern struct pf_ksrc_node	*pf_find_src_node(struct pf_addr *,
1486 				    struct pf_krule *, sa_family_t, int);
1487 extern void			 pf_unlink_src_node(struct pf_ksrc_node *);
1488 extern u_int			 pf_free_src_nodes(struct pf_ksrc_node_list *);
1489 extern void			 pf_print_state(struct pf_state *);
1490 extern void			 pf_print_flags(u_int8_t);
1491 extern u_int16_t		 pf_cksum_fixup(u_int16_t, u_int16_t, u_int16_t,
1492 				    u_int8_t);
1493 extern u_int16_t		 pf_proto_cksum_fixup(struct mbuf *, u_int16_t,
1494 				    u_int16_t, u_int16_t, u_int8_t);
1495 
1496 VNET_DECLARE(struct ifnet *,		 sync_ifp);
1497 #define	V_sync_ifp		 	 VNET(sync_ifp);
1498 VNET_DECLARE(struct pf_krule,		 pf_default_rule);
1499 #define	V_pf_default_rule		  VNET(pf_default_rule)
1500 extern void			 pf_addrcpy(struct pf_addr *, struct pf_addr *,
1501 				    u_int8_t);
1502 void				pf_free_rule(struct pf_krule *);
1503 
1504 #ifdef INET
1505 int	pf_test(int, int, struct ifnet *, struct mbuf **, struct inpcb *);
1506 int	pf_normalize_ip(struct mbuf **, int, struct pfi_kkif *, u_short *,
1507 	    struct pf_pdesc *);
1508 #endif /* INET */
1509 
1510 #ifdef INET6
1511 int	pf_test6(int, int, struct ifnet *, struct mbuf **, struct inpcb *);
1512 int	pf_normalize_ip6(struct mbuf **, int, struct pfi_kkif *, u_short *,
1513 	    struct pf_pdesc *);
1514 void	pf_poolmask(struct pf_addr *, struct pf_addr*,
1515 	    struct pf_addr *, struct pf_addr *, u_int8_t);
1516 void	pf_addr_inc(struct pf_addr *, sa_family_t);
1517 int	pf_refragment6(struct ifnet *, struct mbuf **, struct m_tag *);
1518 #endif /* INET6 */
1519 
1520 u_int32_t	pf_new_isn(struct pf_state *);
1521 void   *pf_pull_hdr(struct mbuf *, int, void *, int, u_short *, u_short *,
1522 	    sa_family_t);
1523 void	pf_change_a(void *, u_int16_t *, u_int32_t, u_int8_t);
1524 void	pf_change_proto_a(struct mbuf *, void *, u_int16_t *, u_int32_t,
1525 	    u_int8_t);
1526 void	pf_change_tcp_a(struct mbuf *, void *, u_int16_t *, u_int32_t);
1527 void	pf_patch_16_unaligned(struct mbuf *, u_int16_t *, void *, u_int16_t,
1528 	    bool, u_int8_t);
1529 void	pf_patch_32_unaligned(struct mbuf *, u_int16_t *, void *, u_int32_t,
1530     bool, u_int8_t);
1531 void	pf_send_deferred_syn(struct pf_state *);
1532 int	pf_match_addr(u_int8_t, struct pf_addr *, struct pf_addr *,
1533 	    struct pf_addr *, sa_family_t);
1534 int	pf_match_addr_range(struct pf_addr *, struct pf_addr *,
1535 	    struct pf_addr *, sa_family_t);
1536 int	pf_match_port(u_int8_t, u_int16_t, u_int16_t, u_int16_t);
1537 
1538 void	pf_normalize_init(void);
1539 void	pf_normalize_cleanup(void);
1540 int	pf_normalize_tcp(int, struct pfi_kkif *, struct mbuf *, int, int, void *,
1541 	    struct pf_pdesc *);
1542 void	pf_normalize_tcp_cleanup(struct pf_state *);
1543 int	pf_normalize_tcp_init(struct mbuf *, int, struct pf_pdesc *,
1544 	    struct tcphdr *, struct pf_state_peer *, struct pf_state_peer *);
1545 int	pf_normalize_tcp_stateful(struct mbuf *, int, struct pf_pdesc *,
1546 	    u_short *, struct tcphdr *, struct pf_state *,
1547 	    struct pf_state_peer *, struct pf_state_peer *, int *);
1548 u_int32_t
1549 	pf_state_expires(const struct pf_state *);
1550 void	pf_purge_expired_fragments(void);
1551 void	pf_purge_fragments(uint32_t);
1552 int	pf_routable(struct pf_addr *addr, sa_family_t af, struct pfi_kkif *,
1553 	    int);
1554 int	pf_socket_lookup(int, struct pf_pdesc *, struct mbuf *);
1555 struct pf_state_key *pf_alloc_state_key(int);
1556 void	pfr_initialize(void);
1557 void	pfr_cleanup(void);
1558 int	pfr_match_addr(struct pfr_ktable *, struct pf_addr *, sa_family_t);
1559 void	pfr_update_stats(struct pfr_ktable *, struct pf_addr *, sa_family_t,
1560 	    u_int64_t, int, int, int);
1561 int	pfr_pool_get(struct pfr_ktable *, int *, struct pf_addr *, sa_family_t);
1562 void	pfr_dynaddr_update(struct pfr_ktable *, struct pfi_dynaddr *);
1563 struct pfr_ktable *
1564 	pfr_attach_table(struct pf_kruleset *, char *);
1565 void	pfr_detach_table(struct pfr_ktable *);
1566 int	pfr_clr_tables(struct pfr_table *, int *, int);
1567 int	pfr_add_tables(struct pfr_table *, int, int *, int);
1568 int	pfr_del_tables(struct pfr_table *, int, int *, int);
1569 int	pfr_table_count(struct pfr_table *, int);
1570 int	pfr_get_tables(struct pfr_table *, struct pfr_table *, int *, int);
1571 int	pfr_get_tstats(struct pfr_table *, struct pfr_tstats *, int *, int);
1572 int	pfr_clr_tstats(struct pfr_table *, int, int *, int);
1573 int	pfr_set_tflags(struct pfr_table *, int, int, int, int *, int *, int);
1574 int	pfr_clr_addrs(struct pfr_table *, int *, int);
1575 int	pfr_insert_kentry(struct pfr_ktable *, struct pfr_addr *, long);
1576 int	pfr_add_addrs(struct pfr_table *, struct pfr_addr *, int, int *,
1577 	    int);
1578 int	pfr_del_addrs(struct pfr_table *, struct pfr_addr *, int, int *,
1579 	    int);
1580 int	pfr_set_addrs(struct pfr_table *, struct pfr_addr *, int, int *,
1581 	    int *, int *, int *, int, u_int32_t);
1582 int	pfr_get_addrs(struct pfr_table *, struct pfr_addr *, int *, int);
1583 int	pfr_get_astats(struct pfr_table *, struct pfr_astats *, int *, int);
1584 int	pfr_clr_astats(struct pfr_table *, struct pfr_addr *, int, int *,
1585 	    int);
1586 int	pfr_tst_addrs(struct pfr_table *, struct pfr_addr *, int, int *,
1587 	    int);
1588 int	pfr_ina_begin(struct pfr_table *, u_int32_t *, int *, int);
1589 int	pfr_ina_rollback(struct pfr_table *, u_int32_t, int *, int);
1590 int	pfr_ina_commit(struct pfr_table *, u_int32_t, int *, int *, int);
1591 int	pfr_ina_define(struct pfr_table *, struct pfr_addr *, int, int *,
1592 	    int *, u_int32_t, int);
1593 
1594 MALLOC_DECLARE(PFI_MTYPE);
1595 VNET_DECLARE(struct pfi_kkif *,		 pfi_all);
1596 #define	V_pfi_all	 		 VNET(pfi_all)
1597 
1598 void		 pfi_initialize(void);
1599 void		 pfi_initialize_vnet(void);
1600 void		 pfi_cleanup(void);
1601 void		 pfi_cleanup_vnet(void);
1602 void		 pfi_kkif_ref(struct pfi_kkif *);
1603 void		 pfi_kkif_unref(struct pfi_kkif *);
1604 struct pfi_kkif	*pfi_kkif_find(const char *);
1605 struct pfi_kkif	*pfi_kkif_attach(struct pfi_kkif *, const char *);
1606 int		 pfi_kkif_match(struct pfi_kkif *, struct pfi_kkif *);
1607 void		 pfi_kkif_purge(void);
1608 int		 pfi_match_addr(struct pfi_dynaddr *, struct pf_addr *,
1609 		    sa_family_t);
1610 int		 pfi_dynaddr_setup(struct pf_addr_wrap *, sa_family_t);
1611 void		 pfi_dynaddr_remove(struct pfi_dynaddr *);
1612 void		 pfi_dynaddr_copyout(struct pf_addr_wrap *);
1613 void		 pfi_update_status(const char *, struct pf_status *);
1614 void		 pfi_get_ifaces(const char *, struct pfi_kif *, int *);
1615 int		 pfi_set_flags(const char *, int);
1616 int		 pfi_clear_flags(const char *, int);
1617 
1618 int		 pf_match_tag(struct mbuf *, struct pf_krule *, int *, int);
1619 int		 pf_tag_packet(struct mbuf *, struct pf_pdesc *, int);
1620 int		 pf_addr_cmp(struct pf_addr *, struct pf_addr *,
1621 		    sa_family_t);
1622 void		 pf_qid2qname(u_int32_t, char *);
1623 
1624 VNET_DECLARE(struct pf_kstatus, pf_status);
1625 #define	V_pf_status	VNET(pf_status)
1626 
1627 struct pf_limit {
1628 	uma_zone_t	zone;
1629 	u_int		limit;
1630 };
1631 VNET_DECLARE(struct pf_limit, pf_limits[PF_LIMIT_MAX]);
1632 #define	V_pf_limits VNET(pf_limits)
1633 
1634 #endif /* _KERNEL */
1635 
1636 #ifdef _KERNEL
1637 VNET_DECLARE(struct pf_kanchor_global,		 pf_anchors);
1638 #define	V_pf_anchors				 VNET(pf_anchors)
1639 VNET_DECLARE(struct pf_kanchor,			 pf_main_anchor);
1640 #define	V_pf_main_anchor			 VNET(pf_main_anchor)
1641 #define pf_main_ruleset	V_pf_main_anchor.ruleset
1642 
1643 void			 pf_init_kruleset(struct pf_kruleset *);
1644 int			 pf_kanchor_setup(struct pf_krule *,
1645 			    const struct pf_kruleset *, const char *);
1646 int			 pf_kanchor_nvcopyout(const struct pf_kruleset *,
1647 			    const struct pf_krule *, nvlist_t *);
1648 int			 pf_kanchor_copyout(const struct pf_kruleset *,
1649 			    const struct pf_krule *, struct pfioc_rule *);
1650 void			 pf_kanchor_remove(struct pf_krule *);
1651 void			 pf_remove_if_empty_kruleset(struct pf_kruleset *);
1652 struct pf_kruleset	*pf_find_kruleset(const char *);
1653 struct pf_kruleset	*pf_find_or_create_kruleset(const char *);
1654 void			 pf_rs_initialize(void);
1655 
1656 void			 pf_krule_free(struct pf_krule *);
1657 #endif
1658 
1659 /* The fingerprint functions can be linked into userland programs (tcpdump) */
1660 int	pf_osfp_add(struct pf_osfp_ioctl *);
1661 #ifdef _KERNEL
1662 struct pf_osfp_enlist *
1663 	pf_osfp_fingerprint(struct pf_pdesc *, struct mbuf *, int,
1664 	    const struct tcphdr *);
1665 #endif /* _KERNEL */
1666 void	pf_osfp_flush(void);
1667 int	pf_osfp_get(struct pf_osfp_ioctl *);
1668 int	pf_osfp_match(struct pf_osfp_enlist *, pf_osfp_t);
1669 
1670 #ifdef _KERNEL
1671 void			 pf_print_host(struct pf_addr *, u_int16_t, u_int8_t);
1672 
1673 void			 pf_step_into_anchor(struct pf_kanchor_stackframe *, int *,
1674 			    struct pf_kruleset **, int, struct pf_krule **,
1675 			    struct pf_krule **, int *);
1676 int			 pf_step_out_of_anchor(struct pf_kanchor_stackframe *, int *,
1677 			    struct pf_kruleset **, int, struct pf_krule **,
1678 			    struct pf_krule **, int *);
1679 
1680 int			 pf_map_addr(u_int8_t, struct pf_krule *,
1681 			    struct pf_addr *, struct pf_addr *,
1682 			    struct pf_addr *, struct pf_ksrc_node **);
1683 struct pf_krule		*pf_get_translation(struct pf_pdesc *, struct mbuf *,
1684 			    int, int, struct pfi_kkif *, struct pf_ksrc_node **,
1685 			    struct pf_state_key **, struct pf_state_key **,
1686 			    struct pf_addr *, struct pf_addr *,
1687 			    uint16_t, uint16_t, struct pf_kanchor_stackframe *);
1688 
1689 struct pf_state_key	*pf_state_key_setup(struct pf_pdesc *, struct pf_addr *,
1690 			    struct pf_addr *, u_int16_t, u_int16_t);
1691 struct pf_state_key	*pf_state_key_clone(struct pf_state_key *);
1692 
1693 struct pfi_kkif		*pf_kkif_create(int);
1694 void			 pf_kkif_free(struct pfi_kkif *);
1695 void			 pf_kkif_zero(struct pfi_kkif *);
1696 #endif /* _KERNEL */
1697 
1698 #endif /* _NET_PFVAR_H_ */
1699