xref: /freebsd/sys/netpfil/pf/if_pfsync.c (revision 52c2bb75163559a6e2866ad374a7de67a4ea1273)
1 /*-
2  * SPDX-License-Identifier: (BSD-2-Clause-FreeBSD AND ISC)
3  *
4  * Copyright (c) 2002 Michael Shalayeff
5  * Copyright (c) 2012 Gleb Smirnoff <glebius@FreeBSD.org>
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  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
21  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
25  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
26  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27  * THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 /*-
31  * Copyright (c) 2009 David Gwynne <dlg@openbsd.org>
32  *
33  * Permission to use, copy, modify, and distribute this software for any
34  * purpose with or without fee is hereby granted, provided that the above
35  * copyright notice and this permission notice appear in all copies.
36  *
37  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
38  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
39  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
40  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
41  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
42  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
43  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
44  */
45 
46 /*
47  * $OpenBSD: if_pfsync.c,v 1.110 2009/02/24 05:39:19 dlg Exp $
48  *
49  * Revisions picked from OpenBSD after revision 1.110 import:
50  * 1.119 - don't m_copydata() beyond the len of mbuf in pfsync_input()
51  * 1.118, 1.124, 1.148, 1.149, 1.151, 1.171 - fixes to bulk updates
52  * 1.120, 1.175 - use monotonic time_uptime
53  * 1.122 - reduce number of updates for non-TCP sessions
54  * 1.125, 1.127 - rewrite merge or stale processing
55  * 1.128 - cleanups
56  * 1.146 - bzero() mbuf before sparsely filling it with data
57  * 1.170 - SIOCSIFMTU checks
58  * 1.126, 1.142 - deferred packets processing
59  * 1.173 - correct expire time processing
60  */
61 
62 #include <sys/cdefs.h>
63 __FBSDID("$FreeBSD$");
64 
65 #include "opt_inet.h"
66 #include "opt_inet6.h"
67 #include "opt_pf.h"
68 
69 #include <sys/param.h>
70 #include <sys/bus.h>
71 #include <sys/endian.h>
72 #include <sys/interrupt.h>
73 #include <sys/kernel.h>
74 #include <sys/lock.h>
75 #include <sys/mbuf.h>
76 #include <sys/module.h>
77 #include <sys/mutex.h>
78 #include <sys/priv.h>
79 #include <sys/protosw.h>
80 #include <sys/smp.h>
81 #include <sys/socket.h>
82 #include <sys/sockio.h>
83 #include <sys/sysctl.h>
84 #include <sys/syslog.h>
85 
86 #include <net/bpf.h>
87 #include <net/if.h>
88 #include <net/if_var.h>
89 #include <net/if_clone.h>
90 #include <net/if_types.h>
91 #include <net/vnet.h>
92 #include <net/pfvar.h>
93 #include <net/if_pfsync.h>
94 
95 #include <netinet/if_ether.h>
96 #include <netinet/in.h>
97 #include <netinet/in_var.h>
98 #include <netinet/ip.h>
99 #include <netinet/ip_carp.h>
100 #include <netinet/ip_var.h>
101 #include <netinet/tcp.h>
102 #include <netinet/tcp_fsm.h>
103 #include <netinet/tcp_seq.h>
104 
105 #define PFSYNC_MINPKT ( \
106 	sizeof(struct ip) + \
107 	sizeof(struct pfsync_header) + \
108 	sizeof(struct pfsync_subheader) )
109 
110 struct pfsync_bucket;
111 
112 struct pfsync_pkt {
113 	struct ip *ip;
114 	struct in_addr src;
115 	u_int8_t flags;
116 };
117 
118 static int	pfsync_upd_tcp(struct pf_state *, struct pfsync_state_peer *,
119 		    struct pfsync_state_peer *);
120 static int	pfsync_in_clr(struct pfsync_pkt *, struct mbuf *, int, int);
121 static int	pfsync_in_ins(struct pfsync_pkt *, struct mbuf *, int, int);
122 static int	pfsync_in_iack(struct pfsync_pkt *, struct mbuf *, int, int);
123 static int	pfsync_in_upd(struct pfsync_pkt *, struct mbuf *, int, int);
124 static int	pfsync_in_upd_c(struct pfsync_pkt *, struct mbuf *, int, int);
125 static int	pfsync_in_ureq(struct pfsync_pkt *, struct mbuf *, int, int);
126 static int	pfsync_in_del(struct pfsync_pkt *, struct mbuf *, int, int);
127 static int	pfsync_in_del_c(struct pfsync_pkt *, struct mbuf *, int, int);
128 static int	pfsync_in_bus(struct pfsync_pkt *, struct mbuf *, int, int);
129 static int	pfsync_in_tdb(struct pfsync_pkt *, struct mbuf *, int, int);
130 static int	pfsync_in_eof(struct pfsync_pkt *, struct mbuf *, int, int);
131 static int	pfsync_in_error(struct pfsync_pkt *, struct mbuf *, int, int);
132 
133 static int (*pfsync_acts[])(struct pfsync_pkt *, struct mbuf *, int, int) = {
134 	pfsync_in_clr,			/* PFSYNC_ACT_CLR */
135 	pfsync_in_ins,			/* PFSYNC_ACT_INS */
136 	pfsync_in_iack,			/* PFSYNC_ACT_INS_ACK */
137 	pfsync_in_upd,			/* PFSYNC_ACT_UPD */
138 	pfsync_in_upd_c,		/* PFSYNC_ACT_UPD_C */
139 	pfsync_in_ureq,			/* PFSYNC_ACT_UPD_REQ */
140 	pfsync_in_del,			/* PFSYNC_ACT_DEL */
141 	pfsync_in_del_c,		/* PFSYNC_ACT_DEL_C */
142 	pfsync_in_error,		/* PFSYNC_ACT_INS_F */
143 	pfsync_in_error,		/* PFSYNC_ACT_DEL_F */
144 	pfsync_in_bus,			/* PFSYNC_ACT_BUS */
145 	pfsync_in_tdb,			/* PFSYNC_ACT_TDB */
146 	pfsync_in_eof			/* PFSYNC_ACT_EOF */
147 };
148 
149 struct pfsync_q {
150 	void		(*write)(struct pf_state *, void *);
151 	size_t		len;
152 	u_int8_t	action;
153 };
154 
155 /* we have one of these for every PFSYNC_S_ */
156 static void	pfsync_out_state(struct pf_state *, void *);
157 static void	pfsync_out_iack(struct pf_state *, void *);
158 static void	pfsync_out_upd_c(struct pf_state *, void *);
159 static void	pfsync_out_del(struct pf_state *, void *);
160 
161 static struct pfsync_q pfsync_qs[] = {
162 	{ pfsync_out_state, sizeof(struct pfsync_state),   PFSYNC_ACT_INS },
163 	{ pfsync_out_iack,  sizeof(struct pfsync_ins_ack), PFSYNC_ACT_INS_ACK },
164 	{ pfsync_out_state, sizeof(struct pfsync_state),   PFSYNC_ACT_UPD },
165 	{ pfsync_out_upd_c, sizeof(struct pfsync_upd_c),   PFSYNC_ACT_UPD_C },
166 	{ pfsync_out_del,   sizeof(struct pfsync_del_c),   PFSYNC_ACT_DEL_C }
167 };
168 
169 static void	pfsync_q_ins(struct pf_state *, int, bool);
170 static void	pfsync_q_del(struct pf_state *, bool, struct pfsync_bucket *);
171 
172 static void	pfsync_update_state(struct pf_state *);
173 
174 struct pfsync_upd_req_item {
175 	TAILQ_ENTRY(pfsync_upd_req_item)	ur_entry;
176 	struct pfsync_upd_req			ur_msg;
177 };
178 
179 struct pfsync_deferral {
180 	struct pfsync_softc		*pd_sc;
181 	TAILQ_ENTRY(pfsync_deferral)	pd_entry;
182 	u_int				pd_refs;
183 	struct callout			pd_tmo;
184 
185 	struct pf_state			*pd_st;
186 	struct mbuf			*pd_m;
187 };
188 
189 struct pfsync_sofct;
190 
191 struct pfsync_bucket
192 {
193 	int			b_id;
194 	struct pfsync_softc	*b_sc;
195 	struct mtx		b_mtx;
196 	struct callout		b_tmo;
197 	int			b_flags;
198 #define	PFSYNCF_BUCKET_PUSH	0x00000001
199 
200 	size_t			b_len;
201 	TAILQ_HEAD(, pf_state)			b_qs[PFSYNC_S_COUNT];
202 	TAILQ_HEAD(, pfsync_upd_req_item)	b_upd_req_list;
203 	TAILQ_HEAD(, pfsync_deferral)		b_deferrals;
204 	u_int			b_deferred;
205 	void			*b_plus;
206 	size_t			b_pluslen;
207 
208 	struct  ifaltq b_snd;
209 };
210 
211 struct pfsync_softc {
212 	/* Configuration */
213 	struct ifnet		*sc_ifp;
214 	struct ifnet		*sc_sync_if;
215 	struct ip_moptions	sc_imo;
216 	struct in_addr		sc_sync_peer;
217 	uint32_t		sc_flags;
218 #define	PFSYNCF_OK		0x00000001
219 #define	PFSYNCF_DEFER		0x00000002
220 	uint8_t			sc_maxupdates;
221 	struct ip		sc_template;
222 	struct mtx		sc_mtx;
223 
224 	/* Queued data */
225 	struct pfsync_bucket	*sc_buckets;
226 
227 	/* Bulk update info */
228 	struct mtx		sc_bulk_mtx;
229 	uint32_t		sc_ureq_sent;
230 	int			sc_bulk_tries;
231 	uint32_t		sc_ureq_received;
232 	int			sc_bulk_hashid;
233 	uint64_t		sc_bulk_stateid;
234 	uint32_t		sc_bulk_creatorid;
235 	struct callout		sc_bulk_tmo;
236 	struct callout		sc_bulkfail_tmo;
237 };
238 
239 #define	PFSYNC_LOCK(sc)		mtx_lock(&(sc)->sc_mtx)
240 #define	PFSYNC_UNLOCK(sc)	mtx_unlock(&(sc)->sc_mtx)
241 #define	PFSYNC_LOCK_ASSERT(sc)	mtx_assert(&(sc)->sc_mtx, MA_OWNED)
242 
243 #define PFSYNC_BUCKET_LOCK(b)		mtx_lock(&(b)->b_mtx)
244 #define PFSYNC_BUCKET_UNLOCK(b)		mtx_unlock(&(b)->b_mtx)
245 #define PFSYNC_BUCKET_LOCK_ASSERT(b)	mtx_assert(&(b)->b_mtx, MA_OWNED)
246 
247 #define	PFSYNC_BLOCK(sc)	mtx_lock(&(sc)->sc_bulk_mtx)
248 #define	PFSYNC_BUNLOCK(sc)	mtx_unlock(&(sc)->sc_bulk_mtx)
249 #define	PFSYNC_BLOCK_ASSERT(sc)	mtx_assert(&(sc)->sc_bulk_mtx, MA_OWNED)
250 
251 static const char pfsyncname[] = "pfsync";
252 static MALLOC_DEFINE(M_PFSYNC, pfsyncname, "pfsync(4) data");
253 VNET_DEFINE_STATIC(struct pfsync_softc	*, pfsyncif) = NULL;
254 #define	V_pfsyncif		VNET(pfsyncif)
255 VNET_DEFINE_STATIC(void *, pfsync_swi_cookie) = NULL;
256 #define	V_pfsync_swi_cookie	VNET(pfsync_swi_cookie)
257 VNET_DEFINE_STATIC(struct pfsyncstats, pfsyncstats);
258 #define	V_pfsyncstats		VNET(pfsyncstats)
259 VNET_DEFINE_STATIC(int, pfsync_carp_adj) = CARP_MAXSKEW;
260 #define	V_pfsync_carp_adj	VNET(pfsync_carp_adj)
261 
262 static void	pfsync_timeout(void *);
263 static void	pfsync_push(struct pfsync_bucket *);
264 static void	pfsync_push_all(struct pfsync_softc *);
265 static void	pfsyncintr(void *);
266 static int	pfsync_multicast_setup(struct pfsync_softc *, struct ifnet *,
267 		    void *);
268 static void	pfsync_multicast_cleanup(struct pfsync_softc *);
269 static void	pfsync_pointers_init(void);
270 static void	pfsync_pointers_uninit(void);
271 static int	pfsync_init(void);
272 static void	pfsync_uninit(void);
273 
274 static unsigned long pfsync_buckets;
275 
276 SYSCTL_NODE(_net, OID_AUTO, pfsync, CTLFLAG_RW, 0, "PFSYNC");
277 SYSCTL_STRUCT(_net_pfsync, OID_AUTO, stats, CTLFLAG_VNET | CTLFLAG_RW,
278     &VNET_NAME(pfsyncstats), pfsyncstats,
279     "PFSYNC statistics (struct pfsyncstats, net/if_pfsync.h)");
280 SYSCTL_INT(_net_pfsync, OID_AUTO, carp_demotion_factor, CTLFLAG_RW,
281     &VNET_NAME(pfsync_carp_adj), 0, "pfsync's CARP demotion factor adjustment");
282 SYSCTL_ULONG(_net_pfsync, OID_AUTO, pfsync_buckets, CTLFLAG_RDTUN,
283     &pfsync_buckets, 0, "Number of pfsync hash buckets");
284 
285 static int	pfsync_clone_create(struct if_clone *, int, caddr_t);
286 static void	pfsync_clone_destroy(struct ifnet *);
287 static int	pfsync_alloc_scrub_memory(struct pfsync_state_peer *,
288 		    struct pf_state_peer *);
289 static int	pfsyncoutput(struct ifnet *, struct mbuf *,
290 		    const struct sockaddr *, struct route *);
291 static int	pfsyncioctl(struct ifnet *, u_long, caddr_t);
292 
293 static int	pfsync_defer(struct pf_state *, struct mbuf *);
294 static void	pfsync_undefer(struct pfsync_deferral *, int);
295 static void	pfsync_undefer_state(struct pf_state *, int);
296 static void	pfsync_defer_tmo(void *);
297 
298 static void	pfsync_request_update(u_int32_t, u_int64_t);
299 static bool	pfsync_update_state_req(struct pf_state *);
300 
301 static void	pfsync_drop(struct pfsync_softc *);
302 static void	pfsync_sendout(int, int);
303 static void	pfsync_send_plus(void *, size_t);
304 
305 static void	pfsync_bulk_start(void);
306 static void	pfsync_bulk_status(u_int8_t);
307 static void	pfsync_bulk_update(void *);
308 static void	pfsync_bulk_fail(void *);
309 
310 static void	pfsync_detach_ifnet(struct ifnet *);
311 #ifdef IPSEC
312 static void	pfsync_update_net_tdb(struct pfsync_tdb *);
313 #endif
314 static struct pfsync_bucket	*pfsync_get_bucket(struct pfsync_softc *,
315 		    struct pf_state *);
316 
317 
318 #define PFSYNC_MAX_BULKTRIES	12
319 
320 VNET_DEFINE(struct if_clone *, pfsync_cloner);
321 #define	V_pfsync_cloner	VNET(pfsync_cloner)
322 
323 static int
324 pfsync_clone_create(struct if_clone *ifc, int unit, caddr_t param)
325 {
326 	struct pfsync_softc *sc;
327 	struct ifnet *ifp;
328 	struct pfsync_bucket *b;
329 	int c, q;
330 
331 	if (unit != 0)
332 		return (EINVAL);
333 
334 	if (! pfsync_buckets)
335 		pfsync_buckets = mp_ncpus * 2;
336 
337 	sc = malloc(sizeof(struct pfsync_softc), M_PFSYNC, M_WAITOK | M_ZERO);
338 	sc->sc_flags |= PFSYNCF_OK;
339 	sc->sc_maxupdates = 128;
340 
341 	ifp = sc->sc_ifp = if_alloc(IFT_PFSYNC);
342 	if (ifp == NULL) {
343 		free(sc, M_PFSYNC);
344 		return (ENOSPC);
345 	}
346 	if_initname(ifp, pfsyncname, unit);
347 	ifp->if_softc = sc;
348 	ifp->if_ioctl = pfsyncioctl;
349 	ifp->if_output = pfsyncoutput;
350 	ifp->if_type = IFT_PFSYNC;
351 	ifp->if_hdrlen = sizeof(struct pfsync_header);
352 	ifp->if_mtu = ETHERMTU;
353 	mtx_init(&sc->sc_mtx, pfsyncname, NULL, MTX_DEF);
354 	mtx_init(&sc->sc_bulk_mtx, "pfsync bulk", NULL, MTX_DEF);
355 	callout_init_mtx(&sc->sc_bulk_tmo, &sc->sc_bulk_mtx, 0);
356 	callout_init_mtx(&sc->sc_bulkfail_tmo, &sc->sc_bulk_mtx, 0);
357 
358 	if_attach(ifp);
359 
360 	bpfattach(ifp, DLT_PFSYNC, PFSYNC_HDRLEN);
361 
362 	sc->sc_buckets = mallocarray(pfsync_buckets, sizeof(*sc->sc_buckets),
363 	    M_PFSYNC, M_ZERO | M_WAITOK);
364 	for (c = 0; c < pfsync_buckets; c++) {
365 		b = &sc->sc_buckets[c];
366 		mtx_init(&b->b_mtx, "pfsync bucket", NULL, MTX_DEF);
367 
368 		b->b_id = c;
369 		b->b_sc = sc;
370 		b->b_len = PFSYNC_MINPKT;
371 
372 		for (q = 0; q < PFSYNC_S_COUNT; q++)
373 			TAILQ_INIT(&b->b_qs[q]);
374 
375 		TAILQ_INIT(&b->b_upd_req_list);
376 		TAILQ_INIT(&b->b_deferrals);
377 
378 		callout_init(&b->b_tmo, 1);
379 
380 		b->b_snd.ifq_maxlen = ifqmaxlen;
381 	}
382 
383 	V_pfsyncif = sc;
384 
385 	return (0);
386 }
387 
388 static void
389 pfsync_clone_destroy(struct ifnet *ifp)
390 {
391 	struct pfsync_softc *sc = ifp->if_softc;
392 	struct pfsync_bucket *b;
393 	int c;
394 
395 	for (c = 0; c < pfsync_buckets; c++) {
396 		b = &sc->sc_buckets[c];
397 		/*
398 		 * At this stage, everything should have already been
399 		 * cleared by pfsync_uninit(), and we have only to
400 		 * drain callouts.
401 		 */
402 		while (b->b_deferred > 0) {
403 			struct pfsync_deferral *pd =
404 			    TAILQ_FIRST(&b->b_deferrals);
405 
406 			TAILQ_REMOVE(&b->b_deferrals, pd, pd_entry);
407 			b->b_deferred--;
408 			if (callout_stop(&pd->pd_tmo) > 0) {
409 				pf_release_state(pd->pd_st);
410 				m_freem(pd->pd_m);
411 				free(pd, M_PFSYNC);
412 			} else {
413 				pd->pd_refs++;
414 				callout_drain(&pd->pd_tmo);
415 				free(pd, M_PFSYNC);
416 			}
417 		}
418 
419 		callout_drain(&b->b_tmo);
420 	}
421 
422 	callout_drain(&sc->sc_bulkfail_tmo);
423 	callout_drain(&sc->sc_bulk_tmo);
424 
425 	if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p)
426 		(*carp_demote_adj_p)(-V_pfsync_carp_adj, "pfsync destroy");
427 	bpfdetach(ifp);
428 	if_detach(ifp);
429 
430 	pfsync_drop(sc);
431 
432 	if_free(ifp);
433 	if (sc->sc_imo.imo_membership)
434 		pfsync_multicast_cleanup(sc);
435 	mtx_destroy(&sc->sc_mtx);
436 	mtx_destroy(&sc->sc_bulk_mtx);
437 
438 	free(sc->sc_buckets, M_PFSYNC);
439 	free(sc, M_PFSYNC);
440 
441 	V_pfsyncif = NULL;
442 }
443 
444 static int
445 pfsync_alloc_scrub_memory(struct pfsync_state_peer *s,
446     struct pf_state_peer *d)
447 {
448 	if (s->scrub.scrub_flag && d->scrub == NULL) {
449 		d->scrub = uma_zalloc(V_pf_state_scrub_z, M_NOWAIT | M_ZERO);
450 		if (d->scrub == NULL)
451 			return (ENOMEM);
452 	}
453 
454 	return (0);
455 }
456 
457 
458 static int
459 pfsync_state_import(struct pfsync_state *sp, u_int8_t flags)
460 {
461 	struct pfsync_softc *sc = V_pfsyncif;
462 #ifndef	__NO_STRICT_ALIGNMENT
463 	struct pfsync_state_key key[2];
464 #endif
465 	struct pfsync_state_key *kw, *ks;
466 	struct pf_state	*st = NULL;
467 	struct pf_state_key *skw = NULL, *sks = NULL;
468 	struct pf_rule *r = NULL;
469 	struct pfi_kif	*kif;
470 	int error;
471 
472 	PF_RULES_RASSERT();
473 
474 	if (sp->creatorid == 0) {
475 		if (V_pf_status.debug >= PF_DEBUG_MISC)
476 			printf("%s: invalid creator id: %08x\n", __func__,
477 			    ntohl(sp->creatorid));
478 		return (EINVAL);
479 	}
480 
481 	if ((kif = pfi_kif_find(sp->ifname)) == NULL) {
482 		if (V_pf_status.debug >= PF_DEBUG_MISC)
483 			printf("%s: unknown interface: %s\n", __func__,
484 			    sp->ifname);
485 		if (flags & PFSYNC_SI_IOCTL)
486 			return (EINVAL);
487 		return (0);	/* skip this state */
488 	}
489 
490 	/*
491 	 * If the ruleset checksums match or the state is coming from the ioctl,
492 	 * it's safe to associate the state with the rule of that number.
493 	 */
494 	if (sp->rule != htonl(-1) && sp->anchor == htonl(-1) &&
495 	    (flags & (PFSYNC_SI_IOCTL | PFSYNC_SI_CKSUM)) && ntohl(sp->rule) <
496 	    pf_main_ruleset.rules[PF_RULESET_FILTER].active.rcount)
497 		r = pf_main_ruleset.rules[
498 		    PF_RULESET_FILTER].active.ptr_array[ntohl(sp->rule)];
499 	else
500 		r = &V_pf_default_rule;
501 
502 	if ((r->max_states &&
503 	    counter_u64_fetch(r->states_cur) >= r->max_states))
504 		goto cleanup;
505 
506 	/*
507 	 * XXXGL: consider M_WAITOK in ioctl path after.
508 	 */
509 	if ((st = uma_zalloc(V_pf_state_z, M_NOWAIT | M_ZERO)) == NULL)
510 		goto cleanup;
511 
512 	if ((skw = uma_zalloc(V_pf_state_key_z, M_NOWAIT)) == NULL)
513 		goto cleanup;
514 
515 #ifndef	__NO_STRICT_ALIGNMENT
516 	bcopy(&sp->key, key, sizeof(struct pfsync_state_key) * 2);
517 	kw = &key[PF_SK_WIRE];
518 	ks = &key[PF_SK_STACK];
519 #else
520 	kw = &sp->key[PF_SK_WIRE];
521 	ks = &sp->key[PF_SK_STACK];
522 #endif
523 
524 	if (PF_ANEQ(&kw->addr[0], &ks->addr[0], sp->af) ||
525 	    PF_ANEQ(&kw->addr[1], &ks->addr[1], sp->af) ||
526 	    kw->port[0] != ks->port[0] ||
527 	    kw->port[1] != ks->port[1]) {
528 		sks = uma_zalloc(V_pf_state_key_z, M_NOWAIT);
529 		if (sks == NULL)
530 			goto cleanup;
531 	} else
532 		sks = skw;
533 
534 	/* allocate memory for scrub info */
535 	if (pfsync_alloc_scrub_memory(&sp->src, &st->src) ||
536 	    pfsync_alloc_scrub_memory(&sp->dst, &st->dst))
537 		goto cleanup;
538 
539 	/* Copy to state key(s). */
540 	skw->addr[0] = kw->addr[0];
541 	skw->addr[1] = kw->addr[1];
542 	skw->port[0] = kw->port[0];
543 	skw->port[1] = kw->port[1];
544 	skw->proto = sp->proto;
545 	skw->af = sp->af;
546 	if (sks != skw) {
547 		sks->addr[0] = ks->addr[0];
548 		sks->addr[1] = ks->addr[1];
549 		sks->port[0] = ks->port[0];
550 		sks->port[1] = ks->port[1];
551 		sks->proto = sp->proto;
552 		sks->af = sp->af;
553 	}
554 
555 	/* copy to state */
556 	bcopy(&sp->rt_addr, &st->rt_addr, sizeof(st->rt_addr));
557 	st->creation = time_uptime - ntohl(sp->creation);
558 	st->expire = time_uptime;
559 	if (sp->expire) {
560 		uint32_t timeout;
561 
562 		timeout = r->timeout[sp->timeout];
563 		if (!timeout)
564 			timeout = V_pf_default_rule.timeout[sp->timeout];
565 
566 		/* sp->expire may have been adaptively scaled by export. */
567 		st->expire -= timeout - ntohl(sp->expire);
568 	}
569 
570 	st->direction = sp->direction;
571 	st->log = sp->log;
572 	st->timeout = sp->timeout;
573 	st->state_flags = sp->state_flags;
574 
575 	st->id = sp->id;
576 	st->creatorid = sp->creatorid;
577 	pf_state_peer_ntoh(&sp->src, &st->src);
578 	pf_state_peer_ntoh(&sp->dst, &st->dst);
579 
580 	st->rule.ptr = r;
581 	st->nat_rule.ptr = NULL;
582 	st->anchor.ptr = NULL;
583 	st->rt_kif = NULL;
584 
585 	st->pfsync_time = time_uptime;
586 	st->sync_state = PFSYNC_S_NONE;
587 
588 	if (!(flags & PFSYNC_SI_IOCTL))
589 		st->state_flags |= PFSTATE_NOSYNC;
590 
591 	if ((error = pf_state_insert(kif, skw, sks, st)) != 0)
592 		goto cleanup_state;
593 
594 	/* XXX when we have nat_rule/anchors, use STATE_INC_COUNTERS */
595 	counter_u64_add(r->states_cur, 1);
596 	counter_u64_add(r->states_tot, 1);
597 
598 	if (!(flags & PFSYNC_SI_IOCTL)) {
599 		st->state_flags &= ~PFSTATE_NOSYNC;
600 		if (st->state_flags & PFSTATE_ACK) {
601 			pfsync_q_ins(st, PFSYNC_S_IACK, true);
602 			pfsync_push_all(sc);
603 		}
604 	}
605 	st->state_flags &= ~PFSTATE_ACK;
606 	PF_STATE_UNLOCK(st);
607 
608 	return (0);
609 
610 cleanup:
611 	error = ENOMEM;
612 	if (skw == sks)
613 		sks = NULL;
614 	if (skw != NULL)
615 		uma_zfree(V_pf_state_key_z, skw);
616 	if (sks != NULL)
617 		uma_zfree(V_pf_state_key_z, sks);
618 
619 cleanup_state:	/* pf_state_insert() frees the state keys. */
620 	if (st) {
621 		if (st->dst.scrub)
622 			uma_zfree(V_pf_state_scrub_z, st->dst.scrub);
623 		if (st->src.scrub)
624 			uma_zfree(V_pf_state_scrub_z, st->src.scrub);
625 		uma_zfree(V_pf_state_z, st);
626 	}
627 	return (error);
628 }
629 
630 static int
631 pfsync_input(struct mbuf **mp, int *offp __unused, int proto __unused)
632 {
633 	struct pfsync_softc *sc = V_pfsyncif;
634 	struct pfsync_pkt pkt;
635 	struct mbuf *m = *mp;
636 	struct ip *ip = mtod(m, struct ip *);
637 	struct pfsync_header *ph;
638 	struct pfsync_subheader subh;
639 
640 	int offset, len;
641 	int rv;
642 	uint16_t count;
643 
644 	PF_RULES_RLOCK_TRACKER;
645 
646 	*mp = NULL;
647 	V_pfsyncstats.pfsyncs_ipackets++;
648 
649 	/* Verify that we have a sync interface configured. */
650 	if (!sc || !sc->sc_sync_if || !V_pf_status.running ||
651 	    (sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
652 		goto done;
653 
654 	/* verify that the packet came in on the right interface */
655 	if (sc->sc_sync_if != m->m_pkthdr.rcvif) {
656 		V_pfsyncstats.pfsyncs_badif++;
657 		goto done;
658 	}
659 
660 	if_inc_counter(sc->sc_ifp, IFCOUNTER_IPACKETS, 1);
661 	if_inc_counter(sc->sc_ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
662 	/* verify that the IP TTL is 255. */
663 	if (ip->ip_ttl != PFSYNC_DFLTTL) {
664 		V_pfsyncstats.pfsyncs_badttl++;
665 		goto done;
666 	}
667 
668 	offset = ip->ip_hl << 2;
669 	if (m->m_pkthdr.len < offset + sizeof(*ph)) {
670 		V_pfsyncstats.pfsyncs_hdrops++;
671 		goto done;
672 	}
673 
674 	if (offset + sizeof(*ph) > m->m_len) {
675 		if (m_pullup(m, offset + sizeof(*ph)) == NULL) {
676 			V_pfsyncstats.pfsyncs_hdrops++;
677 			return (IPPROTO_DONE);
678 		}
679 		ip = mtod(m, struct ip *);
680 	}
681 	ph = (struct pfsync_header *)((char *)ip + offset);
682 
683 	/* verify the version */
684 	if (ph->version != PFSYNC_VERSION) {
685 		V_pfsyncstats.pfsyncs_badver++;
686 		goto done;
687 	}
688 
689 	len = ntohs(ph->len) + offset;
690 	if (m->m_pkthdr.len < len) {
691 		V_pfsyncstats.pfsyncs_badlen++;
692 		goto done;
693 	}
694 
695 	/* Cheaper to grab this now than having to mess with mbufs later */
696 	pkt.ip = ip;
697 	pkt.src = ip->ip_src;
698 	pkt.flags = 0;
699 
700 	/*
701 	 * Trusting pf_chksum during packet processing, as well as seeking
702 	 * in interface name tree, require holding PF_RULES_RLOCK().
703 	 */
704 	PF_RULES_RLOCK();
705 	if (!bcmp(&ph->pfcksum, &V_pf_status.pf_chksum, PF_MD5_DIGEST_LENGTH))
706 		pkt.flags |= PFSYNC_SI_CKSUM;
707 
708 	offset += sizeof(*ph);
709 	while (offset <= len - sizeof(subh)) {
710 		m_copydata(m, offset, sizeof(subh), (caddr_t)&subh);
711 		offset += sizeof(subh);
712 
713 		if (subh.action >= PFSYNC_ACT_MAX) {
714 			V_pfsyncstats.pfsyncs_badact++;
715 			PF_RULES_RUNLOCK();
716 			goto done;
717 		}
718 
719 		count = ntohs(subh.count);
720 		V_pfsyncstats.pfsyncs_iacts[subh.action] += count;
721 		rv = (*pfsync_acts[subh.action])(&pkt, m, offset, count);
722 		if (rv == -1) {
723 			PF_RULES_RUNLOCK();
724 			return (IPPROTO_DONE);
725 		}
726 
727 		offset += rv;
728 	}
729 	PF_RULES_RUNLOCK();
730 
731 done:
732 	m_freem(m);
733 	return (IPPROTO_DONE);
734 }
735 
736 static int
737 pfsync_in_clr(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
738 {
739 	struct pfsync_clr *clr;
740 	struct mbuf *mp;
741 	int len = sizeof(*clr) * count;
742 	int i, offp;
743 	u_int32_t creatorid;
744 
745 	mp = m_pulldown(m, offset, len, &offp);
746 	if (mp == NULL) {
747 		V_pfsyncstats.pfsyncs_badlen++;
748 		return (-1);
749 	}
750 	clr = (struct pfsync_clr *)(mp->m_data + offp);
751 
752 	for (i = 0; i < count; i++) {
753 		creatorid = clr[i].creatorid;
754 
755 		if (clr[i].ifname[0] != '\0' &&
756 		    pfi_kif_find(clr[i].ifname) == NULL)
757 			continue;
758 
759 		for (int i = 0; i <= pf_hashmask; i++) {
760 			struct pf_idhash *ih = &V_pf_idhash[i];
761 			struct pf_state *s;
762 relock:
763 			PF_HASHROW_LOCK(ih);
764 			LIST_FOREACH(s, &ih->states, entry) {
765 				if (s->creatorid == creatorid) {
766 					s->state_flags |= PFSTATE_NOSYNC;
767 					pf_unlink_state(s, PF_ENTER_LOCKED);
768 					goto relock;
769 				}
770 			}
771 			PF_HASHROW_UNLOCK(ih);
772 		}
773 	}
774 
775 	return (len);
776 }
777 
778 static int
779 pfsync_in_ins(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
780 {
781 	struct mbuf *mp;
782 	struct pfsync_state *sa, *sp;
783 	int len = sizeof(*sp) * count;
784 	int i, offp;
785 
786 	mp = m_pulldown(m, offset, len, &offp);
787 	if (mp == NULL) {
788 		V_pfsyncstats.pfsyncs_badlen++;
789 		return (-1);
790 	}
791 	sa = (struct pfsync_state *)(mp->m_data + offp);
792 
793 	for (i = 0; i < count; i++) {
794 		sp = &sa[i];
795 
796 		/* Check for invalid values. */
797 		if (sp->timeout >= PFTM_MAX ||
798 		    sp->src.state > PF_TCPS_PROXY_DST ||
799 		    sp->dst.state > PF_TCPS_PROXY_DST ||
800 		    sp->direction > PF_OUT ||
801 		    (sp->af != AF_INET && sp->af != AF_INET6)) {
802 			if (V_pf_status.debug >= PF_DEBUG_MISC)
803 				printf("%s: invalid value\n", __func__);
804 			V_pfsyncstats.pfsyncs_badval++;
805 			continue;
806 		}
807 
808 		if (pfsync_state_import(sp, pkt->flags) == ENOMEM)
809 			/* Drop out, but process the rest of the actions. */
810 			break;
811 	}
812 
813 	return (len);
814 }
815 
816 static int
817 pfsync_in_iack(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
818 {
819 	struct pfsync_ins_ack *ia, *iaa;
820 	struct pf_state *st;
821 
822 	struct mbuf *mp;
823 	int len = count * sizeof(*ia);
824 	int offp, i;
825 
826 	mp = m_pulldown(m, offset, len, &offp);
827 	if (mp == NULL) {
828 		V_pfsyncstats.pfsyncs_badlen++;
829 		return (-1);
830 	}
831 	iaa = (struct pfsync_ins_ack *)(mp->m_data + offp);
832 
833 	for (i = 0; i < count; i++) {
834 		ia = &iaa[i];
835 
836 		st = pf_find_state_byid(ia->id, ia->creatorid);
837 		if (st == NULL)
838 			continue;
839 
840 		if (st->state_flags & PFSTATE_ACK) {
841 			pfsync_undefer_state(st, 0);
842 		}
843 		PF_STATE_UNLOCK(st);
844 	}
845 	/*
846 	 * XXX this is not yet implemented, but we know the size of the
847 	 * message so we can skip it.
848 	 */
849 
850 	return (count * sizeof(struct pfsync_ins_ack));
851 }
852 
853 static int
854 pfsync_upd_tcp(struct pf_state *st, struct pfsync_state_peer *src,
855     struct pfsync_state_peer *dst)
856 {
857 	int sync = 0;
858 
859 	PF_STATE_LOCK_ASSERT(st);
860 
861 	/*
862 	 * The state should never go backwards except
863 	 * for syn-proxy states.  Neither should the
864 	 * sequence window slide backwards.
865 	 */
866 	if ((st->src.state > src->state &&
867 	    (st->src.state < PF_TCPS_PROXY_SRC ||
868 	    src->state >= PF_TCPS_PROXY_SRC)) ||
869 
870 	    (st->src.state == src->state &&
871 	    SEQ_GT(st->src.seqlo, ntohl(src->seqlo))))
872 		sync++;
873 	else
874 		pf_state_peer_ntoh(src, &st->src);
875 
876 	if ((st->dst.state > dst->state) ||
877 
878 	    (st->dst.state >= TCPS_SYN_SENT &&
879 	    SEQ_GT(st->dst.seqlo, ntohl(dst->seqlo))))
880 		sync++;
881 	else
882 		pf_state_peer_ntoh(dst, &st->dst);
883 
884 	return (sync);
885 }
886 
887 static int
888 pfsync_in_upd(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
889 {
890 	struct pfsync_softc *sc = V_pfsyncif;
891 	struct pfsync_state *sa, *sp;
892 	struct pf_state *st;
893 	int sync;
894 
895 	struct mbuf *mp;
896 	int len = count * sizeof(*sp);
897 	int offp, i;
898 
899 	mp = m_pulldown(m, offset, len, &offp);
900 	if (mp == NULL) {
901 		V_pfsyncstats.pfsyncs_badlen++;
902 		return (-1);
903 	}
904 	sa = (struct pfsync_state *)(mp->m_data + offp);
905 
906 	for (i = 0; i < count; i++) {
907 		sp = &sa[i];
908 
909 		/* check for invalid values */
910 		if (sp->timeout >= PFTM_MAX ||
911 		    sp->src.state > PF_TCPS_PROXY_DST ||
912 		    sp->dst.state > PF_TCPS_PROXY_DST) {
913 			if (V_pf_status.debug >= PF_DEBUG_MISC) {
914 				printf("pfsync_input: PFSYNC_ACT_UPD: "
915 				    "invalid value\n");
916 			}
917 			V_pfsyncstats.pfsyncs_badval++;
918 			continue;
919 		}
920 
921 		st = pf_find_state_byid(sp->id, sp->creatorid);
922 		if (st == NULL) {
923 			/* insert the update */
924 			if (pfsync_state_import(sp, pkt->flags))
925 				V_pfsyncstats.pfsyncs_badstate++;
926 			continue;
927 		}
928 
929 		if (st->state_flags & PFSTATE_ACK) {
930 			pfsync_undefer_state(st, 1);
931 		}
932 
933 		if (st->key[PF_SK_WIRE]->proto == IPPROTO_TCP)
934 			sync = pfsync_upd_tcp(st, &sp->src, &sp->dst);
935 		else {
936 			sync = 0;
937 
938 			/*
939 			 * Non-TCP protocol state machine always go
940 			 * forwards
941 			 */
942 			if (st->src.state > sp->src.state)
943 				sync++;
944 			else
945 				pf_state_peer_ntoh(&sp->src, &st->src);
946 			if (st->dst.state > sp->dst.state)
947 				sync++;
948 			else
949 				pf_state_peer_ntoh(&sp->dst, &st->dst);
950 		}
951 		if (sync < 2) {
952 			pfsync_alloc_scrub_memory(&sp->dst, &st->dst);
953 			pf_state_peer_ntoh(&sp->dst, &st->dst);
954 			st->expire = time_uptime;
955 			st->timeout = sp->timeout;
956 		}
957 		st->pfsync_time = time_uptime;
958 
959 		if (sync) {
960 			V_pfsyncstats.pfsyncs_stale++;
961 
962 			pfsync_update_state(st);
963 			PF_STATE_UNLOCK(st);
964 			pfsync_push_all(sc);
965 			continue;
966 		}
967 		PF_STATE_UNLOCK(st);
968 	}
969 
970 	return (len);
971 }
972 
973 static int
974 pfsync_in_upd_c(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
975 {
976 	struct pfsync_softc *sc = V_pfsyncif;
977 	struct pfsync_upd_c *ua, *up;
978 	struct pf_state *st;
979 	int len = count * sizeof(*up);
980 	int sync;
981 	struct mbuf *mp;
982 	int offp, i;
983 
984 	mp = m_pulldown(m, offset, len, &offp);
985 	if (mp == NULL) {
986 		V_pfsyncstats.pfsyncs_badlen++;
987 		return (-1);
988 	}
989 	ua = (struct pfsync_upd_c *)(mp->m_data + offp);
990 
991 	for (i = 0; i < count; i++) {
992 		up = &ua[i];
993 
994 		/* check for invalid values */
995 		if (up->timeout >= PFTM_MAX ||
996 		    up->src.state > PF_TCPS_PROXY_DST ||
997 		    up->dst.state > PF_TCPS_PROXY_DST) {
998 			if (V_pf_status.debug >= PF_DEBUG_MISC) {
999 				printf("pfsync_input: "
1000 				    "PFSYNC_ACT_UPD_C: "
1001 				    "invalid value\n");
1002 			}
1003 			V_pfsyncstats.pfsyncs_badval++;
1004 			continue;
1005 		}
1006 
1007 		st = pf_find_state_byid(up->id, up->creatorid);
1008 		if (st == NULL) {
1009 			/* We don't have this state. Ask for it. */
1010 			PFSYNC_BUCKET_LOCK(&sc->sc_buckets[0]);
1011 			pfsync_request_update(up->creatorid, up->id);
1012 			PFSYNC_BUCKET_UNLOCK(&sc->sc_buckets[0]);
1013 			continue;
1014 		}
1015 
1016 		if (st->state_flags & PFSTATE_ACK) {
1017 			pfsync_undefer_state(st, 1);
1018 		}
1019 
1020 		if (st->key[PF_SK_WIRE]->proto == IPPROTO_TCP)
1021 			sync = pfsync_upd_tcp(st, &up->src, &up->dst);
1022 		else {
1023 			sync = 0;
1024 
1025 			/*
1026 			 * Non-TCP protocol state machine always go
1027 			 * forwards
1028 			 */
1029 			if (st->src.state > up->src.state)
1030 				sync++;
1031 			else
1032 				pf_state_peer_ntoh(&up->src, &st->src);
1033 			if (st->dst.state > up->dst.state)
1034 				sync++;
1035 			else
1036 				pf_state_peer_ntoh(&up->dst, &st->dst);
1037 		}
1038 		if (sync < 2) {
1039 			pfsync_alloc_scrub_memory(&up->dst, &st->dst);
1040 			pf_state_peer_ntoh(&up->dst, &st->dst);
1041 			st->expire = time_uptime;
1042 			st->timeout = up->timeout;
1043 		}
1044 		st->pfsync_time = time_uptime;
1045 
1046 		if (sync) {
1047 			V_pfsyncstats.pfsyncs_stale++;
1048 
1049 			pfsync_update_state(st);
1050 			PF_STATE_UNLOCK(st);
1051 			pfsync_push_all(sc);
1052 			continue;
1053 		}
1054 		PF_STATE_UNLOCK(st);
1055 	}
1056 
1057 	return (len);
1058 }
1059 
1060 static int
1061 pfsync_in_ureq(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1062 {
1063 	struct pfsync_upd_req *ur, *ura;
1064 	struct mbuf *mp;
1065 	int len = count * sizeof(*ur);
1066 	int i, offp;
1067 
1068 	struct pf_state *st;
1069 
1070 	mp = m_pulldown(m, offset, len, &offp);
1071 	if (mp == NULL) {
1072 		V_pfsyncstats.pfsyncs_badlen++;
1073 		return (-1);
1074 	}
1075 	ura = (struct pfsync_upd_req *)(mp->m_data + offp);
1076 
1077 	for (i = 0; i < count; i++) {
1078 		ur = &ura[i];
1079 
1080 		if (ur->id == 0 && ur->creatorid == 0)
1081 			pfsync_bulk_start();
1082 		else {
1083 			st = pf_find_state_byid(ur->id, ur->creatorid);
1084 			if (st == NULL) {
1085 				V_pfsyncstats.pfsyncs_badstate++;
1086 				continue;
1087 			}
1088 			if (st->state_flags & PFSTATE_NOSYNC) {
1089 				PF_STATE_UNLOCK(st);
1090 				continue;
1091 			}
1092 
1093 			pfsync_update_state_req(st);
1094 			PF_STATE_UNLOCK(st);
1095 		}
1096 	}
1097 
1098 	return (len);
1099 }
1100 
1101 static int
1102 pfsync_in_del(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1103 {
1104 	struct mbuf *mp;
1105 	struct pfsync_state *sa, *sp;
1106 	struct pf_state *st;
1107 	int len = count * sizeof(*sp);
1108 	int offp, i;
1109 
1110 	mp = m_pulldown(m, offset, len, &offp);
1111 	if (mp == NULL) {
1112 		V_pfsyncstats.pfsyncs_badlen++;
1113 		return (-1);
1114 	}
1115 	sa = (struct pfsync_state *)(mp->m_data + offp);
1116 
1117 	for (i = 0; i < count; i++) {
1118 		sp = &sa[i];
1119 
1120 		st = pf_find_state_byid(sp->id, sp->creatorid);
1121 		if (st == NULL) {
1122 			V_pfsyncstats.pfsyncs_badstate++;
1123 			continue;
1124 		}
1125 		st->state_flags |= PFSTATE_NOSYNC;
1126 		pf_unlink_state(st, PF_ENTER_LOCKED);
1127 	}
1128 
1129 	return (len);
1130 }
1131 
1132 static int
1133 pfsync_in_del_c(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1134 {
1135 	struct mbuf *mp;
1136 	struct pfsync_del_c *sa, *sp;
1137 	struct pf_state *st;
1138 	int len = count * sizeof(*sp);
1139 	int offp, i;
1140 
1141 	mp = m_pulldown(m, offset, len, &offp);
1142 	if (mp == NULL) {
1143 		V_pfsyncstats.pfsyncs_badlen++;
1144 		return (-1);
1145 	}
1146 	sa = (struct pfsync_del_c *)(mp->m_data + offp);
1147 
1148 	for (i = 0; i < count; i++) {
1149 		sp = &sa[i];
1150 
1151 		st = pf_find_state_byid(sp->id, sp->creatorid);
1152 		if (st == NULL) {
1153 			V_pfsyncstats.pfsyncs_badstate++;
1154 			continue;
1155 		}
1156 
1157 		st->state_flags |= PFSTATE_NOSYNC;
1158 		pf_unlink_state(st, PF_ENTER_LOCKED);
1159 	}
1160 
1161 	return (len);
1162 }
1163 
1164 static int
1165 pfsync_in_bus(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1166 {
1167 	struct pfsync_softc *sc = V_pfsyncif;
1168 	struct pfsync_bus *bus;
1169 	struct mbuf *mp;
1170 	int len = count * sizeof(*bus);
1171 	int offp;
1172 
1173 	PFSYNC_BLOCK(sc);
1174 
1175 	/* If we're not waiting for a bulk update, who cares. */
1176 	if (sc->sc_ureq_sent == 0) {
1177 		PFSYNC_BUNLOCK(sc);
1178 		return (len);
1179 	}
1180 
1181 	mp = m_pulldown(m, offset, len, &offp);
1182 	if (mp == NULL) {
1183 		PFSYNC_BUNLOCK(sc);
1184 		V_pfsyncstats.pfsyncs_badlen++;
1185 		return (-1);
1186 	}
1187 	bus = (struct pfsync_bus *)(mp->m_data + offp);
1188 
1189 	switch (bus->status) {
1190 	case PFSYNC_BUS_START:
1191 		callout_reset(&sc->sc_bulkfail_tmo, 4 * hz +
1192 		    V_pf_limits[PF_LIMIT_STATES].limit /
1193 		    ((sc->sc_ifp->if_mtu - PFSYNC_MINPKT) /
1194 		    sizeof(struct pfsync_state)),
1195 		    pfsync_bulk_fail, sc);
1196 		if (V_pf_status.debug >= PF_DEBUG_MISC)
1197 			printf("pfsync: received bulk update start\n");
1198 		break;
1199 
1200 	case PFSYNC_BUS_END:
1201 		if (time_uptime - ntohl(bus->endtime) >=
1202 		    sc->sc_ureq_sent) {
1203 			/* that's it, we're happy */
1204 			sc->sc_ureq_sent = 0;
1205 			sc->sc_bulk_tries = 0;
1206 			callout_stop(&sc->sc_bulkfail_tmo);
1207 			if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p)
1208 				(*carp_demote_adj_p)(-V_pfsync_carp_adj,
1209 				    "pfsync bulk done");
1210 			sc->sc_flags |= PFSYNCF_OK;
1211 			if (V_pf_status.debug >= PF_DEBUG_MISC)
1212 				printf("pfsync: received valid "
1213 				    "bulk update end\n");
1214 		} else {
1215 			if (V_pf_status.debug >= PF_DEBUG_MISC)
1216 				printf("pfsync: received invalid "
1217 				    "bulk update end: bad timestamp\n");
1218 		}
1219 		break;
1220 	}
1221 	PFSYNC_BUNLOCK(sc);
1222 
1223 	return (len);
1224 }
1225 
1226 static int
1227 pfsync_in_tdb(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1228 {
1229 	int len = count * sizeof(struct pfsync_tdb);
1230 
1231 #if defined(IPSEC)
1232 	struct pfsync_tdb *tp;
1233 	struct mbuf *mp;
1234 	int offp;
1235 	int i;
1236 	int s;
1237 
1238 	mp = m_pulldown(m, offset, len, &offp);
1239 	if (mp == NULL) {
1240 		V_pfsyncstats.pfsyncs_badlen++;
1241 		return (-1);
1242 	}
1243 	tp = (struct pfsync_tdb *)(mp->m_data + offp);
1244 
1245 	for (i = 0; i < count; i++)
1246 		pfsync_update_net_tdb(&tp[i]);
1247 #endif
1248 
1249 	return (len);
1250 }
1251 
1252 #if defined(IPSEC)
1253 /* Update an in-kernel tdb. Silently fail if no tdb is found. */
1254 static void
1255 pfsync_update_net_tdb(struct pfsync_tdb *pt)
1256 {
1257 	struct tdb		*tdb;
1258 	int			 s;
1259 
1260 	/* check for invalid values */
1261 	if (ntohl(pt->spi) <= SPI_RESERVED_MAX ||
1262 	    (pt->dst.sa.sa_family != AF_INET &&
1263 	    pt->dst.sa.sa_family != AF_INET6))
1264 		goto bad;
1265 
1266 	tdb = gettdb(pt->spi, &pt->dst, pt->sproto);
1267 	if (tdb) {
1268 		pt->rpl = ntohl(pt->rpl);
1269 		pt->cur_bytes = (unsigned long long)be64toh(pt->cur_bytes);
1270 
1271 		/* Neither replay nor byte counter should ever decrease. */
1272 		if (pt->rpl < tdb->tdb_rpl ||
1273 		    pt->cur_bytes < tdb->tdb_cur_bytes) {
1274 			goto bad;
1275 		}
1276 
1277 		tdb->tdb_rpl = pt->rpl;
1278 		tdb->tdb_cur_bytes = pt->cur_bytes;
1279 	}
1280 	return;
1281 
1282 bad:
1283 	if (V_pf_status.debug >= PF_DEBUG_MISC)
1284 		printf("pfsync_insert: PFSYNC_ACT_TDB_UPD: "
1285 		    "invalid value\n");
1286 	V_pfsyncstats.pfsyncs_badstate++;
1287 	return;
1288 }
1289 #endif
1290 
1291 
1292 static int
1293 pfsync_in_eof(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1294 {
1295 	/* check if we are at the right place in the packet */
1296 	if (offset != m->m_pkthdr.len)
1297 		V_pfsyncstats.pfsyncs_badlen++;
1298 
1299 	/* we're done. free and let the caller return */
1300 	m_freem(m);
1301 	return (-1);
1302 }
1303 
1304 static int
1305 pfsync_in_error(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count)
1306 {
1307 	V_pfsyncstats.pfsyncs_badact++;
1308 
1309 	m_freem(m);
1310 	return (-1);
1311 }
1312 
1313 static int
1314 pfsyncoutput(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
1315 	struct route *rt)
1316 {
1317 	m_freem(m);
1318 	return (0);
1319 }
1320 
1321 /* ARGSUSED */
1322 static int
1323 pfsyncioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1324 {
1325 	struct pfsync_softc *sc = ifp->if_softc;
1326 	struct ifreq *ifr = (struct ifreq *)data;
1327 	struct pfsyncreq pfsyncr;
1328 	int error;
1329 	int c;
1330 
1331 	switch (cmd) {
1332 	case SIOCSIFFLAGS:
1333 		PFSYNC_LOCK(sc);
1334 		if (ifp->if_flags & IFF_UP) {
1335 			ifp->if_drv_flags |= IFF_DRV_RUNNING;
1336 			PFSYNC_UNLOCK(sc);
1337 			pfsync_pointers_init();
1338 		} else {
1339 			ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1340 			PFSYNC_UNLOCK(sc);
1341 			pfsync_pointers_uninit();
1342 		}
1343 		break;
1344 	case SIOCSIFMTU:
1345 		if (!sc->sc_sync_if ||
1346 		    ifr->ifr_mtu <= PFSYNC_MINPKT ||
1347 		    ifr->ifr_mtu > sc->sc_sync_if->if_mtu)
1348 			return (EINVAL);
1349 		if (ifr->ifr_mtu < ifp->if_mtu) {
1350 			for (c = 0; c < pfsync_buckets; c++) {
1351 				PFSYNC_BUCKET_LOCK(&sc->sc_buckets[c]);
1352 				if (sc->sc_buckets[c].b_len > PFSYNC_MINPKT)
1353 					pfsync_sendout(1, c);
1354 				PFSYNC_BUCKET_UNLOCK(&sc->sc_buckets[c]);
1355 			}
1356 		}
1357 		ifp->if_mtu = ifr->ifr_mtu;
1358 		break;
1359 	case SIOCGETPFSYNC:
1360 		bzero(&pfsyncr, sizeof(pfsyncr));
1361 		PFSYNC_LOCK(sc);
1362 		if (sc->sc_sync_if) {
1363 			strlcpy(pfsyncr.pfsyncr_syncdev,
1364 			    sc->sc_sync_if->if_xname, IFNAMSIZ);
1365 		}
1366 		pfsyncr.pfsyncr_syncpeer = sc->sc_sync_peer;
1367 		pfsyncr.pfsyncr_maxupdates = sc->sc_maxupdates;
1368 		pfsyncr.pfsyncr_defer = (PFSYNCF_DEFER ==
1369 		    (sc->sc_flags & PFSYNCF_DEFER));
1370 		PFSYNC_UNLOCK(sc);
1371 		return (copyout(&pfsyncr, ifr_data_get_ptr(ifr),
1372 		    sizeof(pfsyncr)));
1373 
1374 	case SIOCSETPFSYNC:
1375 	    {
1376 		struct ip_moptions *imo = &sc->sc_imo;
1377 		struct ifnet *sifp;
1378 		struct ip *ip;
1379 		void *mship = NULL;
1380 
1381 		if ((error = priv_check(curthread, PRIV_NETINET_PF)) != 0)
1382 			return (error);
1383 		if ((error = copyin(ifr_data_get_ptr(ifr), &pfsyncr,
1384 		    sizeof(pfsyncr))))
1385 			return (error);
1386 
1387 		if (pfsyncr.pfsyncr_maxupdates > 255)
1388 			return (EINVAL);
1389 
1390 		if (pfsyncr.pfsyncr_syncdev[0] == 0)
1391 			sifp = NULL;
1392 		else if ((sifp = ifunit_ref(pfsyncr.pfsyncr_syncdev)) == NULL)
1393 			return (EINVAL);
1394 
1395 		if (sifp != NULL && (
1396 		    pfsyncr.pfsyncr_syncpeer.s_addr == 0 ||
1397 		    pfsyncr.pfsyncr_syncpeer.s_addr ==
1398 		    htonl(INADDR_PFSYNC_GROUP)))
1399 			mship = malloc((sizeof(struct in_multi *) *
1400 			    IP_MIN_MEMBERSHIPS), M_PFSYNC, M_WAITOK | M_ZERO);
1401 
1402 		PFSYNC_LOCK(sc);
1403 		if (pfsyncr.pfsyncr_syncpeer.s_addr == 0)
1404 			sc->sc_sync_peer.s_addr = htonl(INADDR_PFSYNC_GROUP);
1405 		else
1406 			sc->sc_sync_peer.s_addr =
1407 			    pfsyncr.pfsyncr_syncpeer.s_addr;
1408 
1409 		sc->sc_maxupdates = pfsyncr.pfsyncr_maxupdates;
1410 		if (pfsyncr.pfsyncr_defer) {
1411 			sc->sc_flags |= PFSYNCF_DEFER;
1412 			V_pfsync_defer_ptr = pfsync_defer;
1413 		} else {
1414 			sc->sc_flags &= ~PFSYNCF_DEFER;
1415 			V_pfsync_defer_ptr = NULL;
1416 		}
1417 
1418 		if (sifp == NULL) {
1419 			if (sc->sc_sync_if)
1420 				if_rele(sc->sc_sync_if);
1421 			sc->sc_sync_if = NULL;
1422 			if (imo->imo_membership)
1423 				pfsync_multicast_cleanup(sc);
1424 			PFSYNC_UNLOCK(sc);
1425 			break;
1426 		}
1427 
1428 		for (c = 0; c < pfsync_buckets; c++) {
1429 			PFSYNC_BUCKET_LOCK(&sc->sc_buckets[c]);
1430 			if (sc->sc_buckets[c].b_len > PFSYNC_MINPKT &&
1431 			    (sifp->if_mtu < sc->sc_ifp->if_mtu ||
1432 			    (sc->sc_sync_if != NULL &&
1433 			    sifp->if_mtu < sc->sc_sync_if->if_mtu) ||
1434 			    sifp->if_mtu < MCLBYTES - sizeof(struct ip)))
1435 				pfsync_sendout(1, c);
1436 			PFSYNC_BUCKET_UNLOCK(&sc->sc_buckets[c]);
1437 		}
1438 
1439 		if (imo->imo_membership)
1440 			pfsync_multicast_cleanup(sc);
1441 
1442 		if (sc->sc_sync_peer.s_addr == htonl(INADDR_PFSYNC_GROUP)) {
1443 			error = pfsync_multicast_setup(sc, sifp, mship);
1444 			if (error) {
1445 				if_rele(sifp);
1446 				free(mship, M_PFSYNC);
1447 				PFSYNC_UNLOCK(sc);
1448 				return (error);
1449 			}
1450 		}
1451 		if (sc->sc_sync_if)
1452 			if_rele(sc->sc_sync_if);
1453 		sc->sc_sync_if = sifp;
1454 
1455 		ip = &sc->sc_template;
1456 		bzero(ip, sizeof(*ip));
1457 		ip->ip_v = IPVERSION;
1458 		ip->ip_hl = sizeof(sc->sc_template) >> 2;
1459 		ip->ip_tos = IPTOS_LOWDELAY;
1460 		/* len and id are set later. */
1461 		ip->ip_off = htons(IP_DF);
1462 		ip->ip_ttl = PFSYNC_DFLTTL;
1463 		ip->ip_p = IPPROTO_PFSYNC;
1464 		ip->ip_src.s_addr = INADDR_ANY;
1465 		ip->ip_dst.s_addr = sc->sc_sync_peer.s_addr;
1466 
1467 		/* Request a full state table update. */
1468 		if ((sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p)
1469 			(*carp_demote_adj_p)(V_pfsync_carp_adj,
1470 			    "pfsync bulk start");
1471 		sc->sc_flags &= ~PFSYNCF_OK;
1472 		if (V_pf_status.debug >= PF_DEBUG_MISC)
1473 			printf("pfsync: requesting bulk update\n");
1474 		PFSYNC_UNLOCK(sc);
1475 		PFSYNC_BUCKET_LOCK(&sc->sc_buckets[0]);
1476 		pfsync_request_update(0, 0);
1477 		PFSYNC_BUCKET_UNLOCK(&sc->sc_buckets[0]);
1478 		PFSYNC_BLOCK(sc);
1479 		sc->sc_ureq_sent = time_uptime;
1480 		callout_reset(&sc->sc_bulkfail_tmo, 5 * hz, pfsync_bulk_fail,
1481 		    sc);
1482 		PFSYNC_BUNLOCK(sc);
1483 
1484 		break;
1485 	    }
1486 	default:
1487 		return (ENOTTY);
1488 	}
1489 
1490 	return (0);
1491 }
1492 
1493 static void
1494 pfsync_out_state(struct pf_state *st, void *buf)
1495 {
1496 	struct pfsync_state *sp = buf;
1497 
1498 	pfsync_state_export(sp, st);
1499 }
1500 
1501 static void
1502 pfsync_out_iack(struct pf_state *st, void *buf)
1503 {
1504 	struct pfsync_ins_ack *iack = buf;
1505 
1506 	iack->id = st->id;
1507 	iack->creatorid = st->creatorid;
1508 }
1509 
1510 static void
1511 pfsync_out_upd_c(struct pf_state *st, void *buf)
1512 {
1513 	struct pfsync_upd_c *up = buf;
1514 
1515 	bzero(up, sizeof(*up));
1516 	up->id = st->id;
1517 	pf_state_peer_hton(&st->src, &up->src);
1518 	pf_state_peer_hton(&st->dst, &up->dst);
1519 	up->creatorid = st->creatorid;
1520 	up->timeout = st->timeout;
1521 }
1522 
1523 static void
1524 pfsync_out_del(struct pf_state *st, void *buf)
1525 {
1526 	struct pfsync_del_c *dp = buf;
1527 
1528 	dp->id = st->id;
1529 	dp->creatorid = st->creatorid;
1530 	st->state_flags |= PFSTATE_NOSYNC;
1531 }
1532 
1533 static void
1534 pfsync_drop(struct pfsync_softc *sc)
1535 {
1536 	struct pf_state *st, *next;
1537 	struct pfsync_upd_req_item *ur;
1538 	struct pfsync_bucket *b;
1539 	int c, q;
1540 
1541 	for (c = 0; c < pfsync_buckets; c++) {
1542 		b = &sc->sc_buckets[c];
1543 		for (q = 0; q < PFSYNC_S_COUNT; q++) {
1544 			if (TAILQ_EMPTY(&b->b_qs[q]))
1545 				continue;
1546 
1547 			TAILQ_FOREACH_SAFE(st, &b->b_qs[q], sync_list, next) {
1548 				KASSERT(st->sync_state == q,
1549 					("%s: st->sync_state == q",
1550 						__func__));
1551 				st->sync_state = PFSYNC_S_NONE;
1552 				pf_release_state(st);
1553 			}
1554 			TAILQ_INIT(&b->b_qs[q]);
1555 		}
1556 
1557 		while ((ur = TAILQ_FIRST(&b->b_upd_req_list)) != NULL) {
1558 			TAILQ_REMOVE(&b->b_upd_req_list, ur, ur_entry);
1559 			free(ur, M_PFSYNC);
1560 		}
1561 
1562 		b->b_len = PFSYNC_MINPKT;
1563 		b->b_plus = NULL;
1564 	}
1565 }
1566 
1567 static void
1568 pfsync_sendout(int schedswi, int c)
1569 {
1570 	struct pfsync_softc *sc = V_pfsyncif;
1571 	struct ifnet *ifp = sc->sc_ifp;
1572 	struct mbuf *m;
1573 	struct ip *ip;
1574 	struct pfsync_header *ph;
1575 	struct pfsync_subheader *subh;
1576 	struct pf_state *st, *st_next;
1577 	struct pfsync_upd_req_item *ur;
1578 	struct pfsync_bucket *b = &sc->sc_buckets[c];
1579 	int offset;
1580 	int q, count = 0;
1581 
1582 	KASSERT(sc != NULL, ("%s: null sc", __func__));
1583 	KASSERT(b->b_len > PFSYNC_MINPKT,
1584 	    ("%s: sc_len %zu", __func__, b->b_len));
1585 	PFSYNC_BUCKET_LOCK_ASSERT(b);
1586 
1587 	if (ifp->if_bpf == NULL && sc->sc_sync_if == NULL) {
1588 		pfsync_drop(sc);
1589 		return;
1590 	}
1591 
1592 	m = m_get2(max_linkhdr + b->b_len, M_NOWAIT, MT_DATA, M_PKTHDR);
1593 	if (m == NULL) {
1594 		if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
1595 		V_pfsyncstats.pfsyncs_onomem++;
1596 		return;
1597 	}
1598 	m->m_data += max_linkhdr;
1599 	m->m_len = m->m_pkthdr.len = b->b_len;
1600 
1601 	/* build the ip header */
1602 	ip = (struct ip *)m->m_data;
1603 	bcopy(&sc->sc_template, ip, sizeof(*ip));
1604 	offset = sizeof(*ip);
1605 
1606 	ip->ip_len = htons(m->m_pkthdr.len);
1607 	ip_fillid(ip);
1608 
1609 	/* build the pfsync header */
1610 	ph = (struct pfsync_header *)(m->m_data + offset);
1611 	bzero(ph, sizeof(*ph));
1612 	offset += sizeof(*ph);
1613 
1614 	ph->version = PFSYNC_VERSION;
1615 	ph->len = htons(b->b_len - sizeof(*ip));
1616 	bcopy(V_pf_status.pf_chksum, ph->pfcksum, PF_MD5_DIGEST_LENGTH);
1617 
1618 	/* walk the queues */
1619 	for (q = 0; q < PFSYNC_S_COUNT; q++) {
1620 		if (TAILQ_EMPTY(&b->b_qs[q]))
1621 			continue;
1622 
1623 		subh = (struct pfsync_subheader *)(m->m_data + offset);
1624 		offset += sizeof(*subh);
1625 
1626 		count = 0;
1627 		TAILQ_FOREACH_SAFE(st, &b->b_qs[q], sync_list, st_next) {
1628 			KASSERT(st->sync_state == q,
1629 				("%s: st->sync_state == q",
1630 					__func__));
1631 			/*
1632 			 * XXXGL: some of write methods do unlocked reads
1633 			 * of state data :(
1634 			 */
1635 			pfsync_qs[q].write(st, m->m_data + offset);
1636 			offset += pfsync_qs[q].len;
1637 			st->sync_state = PFSYNC_S_NONE;
1638 			pf_release_state(st);
1639 			count++;
1640 		}
1641 		TAILQ_INIT(&b->b_qs[q]);
1642 
1643 		bzero(subh, sizeof(*subh));
1644 		subh->action = pfsync_qs[q].action;
1645 		subh->count = htons(count);
1646 		V_pfsyncstats.pfsyncs_oacts[pfsync_qs[q].action] += count;
1647 	}
1648 
1649 	if (!TAILQ_EMPTY(&b->b_upd_req_list)) {
1650 		subh = (struct pfsync_subheader *)(m->m_data + offset);
1651 		offset += sizeof(*subh);
1652 
1653 		count = 0;
1654 		while ((ur = TAILQ_FIRST(&b->b_upd_req_list)) != NULL) {
1655 			TAILQ_REMOVE(&b->b_upd_req_list, ur, ur_entry);
1656 
1657 			bcopy(&ur->ur_msg, m->m_data + offset,
1658 			    sizeof(ur->ur_msg));
1659 			offset += sizeof(ur->ur_msg);
1660 			free(ur, M_PFSYNC);
1661 			count++;
1662 		}
1663 
1664 		bzero(subh, sizeof(*subh));
1665 		subh->action = PFSYNC_ACT_UPD_REQ;
1666 		subh->count = htons(count);
1667 		V_pfsyncstats.pfsyncs_oacts[PFSYNC_ACT_UPD_REQ] += count;
1668 	}
1669 
1670 	/* has someone built a custom region for us to add? */
1671 	if (b->b_plus != NULL) {
1672 		bcopy(b->b_plus, m->m_data + offset, b->b_pluslen);
1673 		offset += b->b_pluslen;
1674 
1675 		b->b_plus = NULL;
1676 	}
1677 
1678 	subh = (struct pfsync_subheader *)(m->m_data + offset);
1679 	offset += sizeof(*subh);
1680 
1681 	bzero(subh, sizeof(*subh));
1682 	subh->action = PFSYNC_ACT_EOF;
1683 	subh->count = htons(1);
1684 	V_pfsyncstats.pfsyncs_oacts[PFSYNC_ACT_EOF]++;
1685 
1686 	/* we're done, let's put it on the wire */
1687 	if (ifp->if_bpf) {
1688 		m->m_data += sizeof(*ip);
1689 		m->m_len = m->m_pkthdr.len = b->b_len - sizeof(*ip);
1690 		BPF_MTAP(ifp, m);
1691 		m->m_data -= sizeof(*ip);
1692 		m->m_len = m->m_pkthdr.len = b->b_len;
1693 	}
1694 
1695 	if (sc->sc_sync_if == NULL) {
1696 		b->b_len = PFSYNC_MINPKT;
1697 		m_freem(m);
1698 		return;
1699 	}
1700 
1701 	if_inc_counter(sc->sc_ifp, IFCOUNTER_OPACKETS, 1);
1702 	if_inc_counter(sc->sc_ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
1703 	b->b_len = PFSYNC_MINPKT;
1704 
1705 	if (!_IF_QFULL(&b->b_snd))
1706 		_IF_ENQUEUE(&b->b_snd, m);
1707 	else {
1708 		m_freem(m);
1709 		if_inc_counter(sc->sc_ifp, IFCOUNTER_OQDROPS, 1);
1710 	}
1711 	if (schedswi)
1712 		swi_sched(V_pfsync_swi_cookie, 0);
1713 }
1714 
1715 static void
1716 pfsync_insert_state(struct pf_state *st)
1717 {
1718 	struct pfsync_softc *sc = V_pfsyncif;
1719 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1720 
1721 	if (st->state_flags & PFSTATE_NOSYNC)
1722 		return;
1723 
1724 	if ((st->rule.ptr->rule_flag & PFRULE_NOSYNC) ||
1725 	    st->key[PF_SK_WIRE]->proto == IPPROTO_PFSYNC) {
1726 		st->state_flags |= PFSTATE_NOSYNC;
1727 		return;
1728 	}
1729 
1730 	KASSERT(st->sync_state == PFSYNC_S_NONE,
1731 		("%s: st->sync_state %u", __func__, st->sync_state));
1732 
1733 	PFSYNC_BUCKET_LOCK(b);
1734 	if (b->b_len == PFSYNC_MINPKT)
1735 		callout_reset(&b->b_tmo, 1 * hz, pfsync_timeout, b);
1736 
1737 	pfsync_q_ins(st, PFSYNC_S_INS, true);
1738 	PFSYNC_BUCKET_UNLOCK(b);
1739 
1740 	st->sync_updates = 0;
1741 }
1742 
1743 static int
1744 pfsync_defer(struct pf_state *st, struct mbuf *m)
1745 {
1746 	struct pfsync_softc *sc = V_pfsyncif;
1747 	struct pfsync_deferral *pd;
1748 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1749 
1750 	if (m->m_flags & (M_BCAST|M_MCAST))
1751 		return (0);
1752 
1753 	PFSYNC_LOCK(sc);
1754 
1755 	if (sc == NULL || !(sc->sc_ifp->if_flags & IFF_DRV_RUNNING) ||
1756 	    !(sc->sc_flags & PFSYNCF_DEFER)) {
1757 		PFSYNC_UNLOCK(sc);
1758 		return (0);
1759 	}
1760 
1761 	if (b->b_deferred >= 128)
1762 		pfsync_undefer(TAILQ_FIRST(&b->b_deferrals), 0);
1763 
1764 	pd = malloc(sizeof(*pd), M_PFSYNC, M_NOWAIT);
1765 	if (pd == NULL)
1766 		return (0);
1767 	b->b_deferred++;
1768 
1769 	m->m_flags |= M_SKIP_FIREWALL;
1770 	st->state_flags |= PFSTATE_ACK;
1771 
1772 	pd->pd_sc = sc;
1773 	pd->pd_refs = 0;
1774 	pd->pd_st = st;
1775 	pf_ref_state(st);
1776 	pd->pd_m = m;
1777 
1778 	TAILQ_INSERT_TAIL(&b->b_deferrals, pd, pd_entry);
1779 	callout_init_mtx(&pd->pd_tmo, &b->b_mtx, CALLOUT_RETURNUNLOCKED);
1780 	callout_reset(&pd->pd_tmo, 10, pfsync_defer_tmo, pd);
1781 
1782 	pfsync_push(b);
1783 
1784 	return (1);
1785 }
1786 
1787 static void
1788 pfsync_undefer(struct pfsync_deferral *pd, int drop)
1789 {
1790 	struct pfsync_softc *sc = pd->pd_sc;
1791 	struct mbuf *m = pd->pd_m;
1792 	struct pf_state *st = pd->pd_st;
1793 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1794 
1795 	PFSYNC_BUCKET_LOCK_ASSERT(b);
1796 
1797 	TAILQ_REMOVE(&b->b_deferrals, pd, pd_entry);
1798 	b->b_deferred--;
1799 	pd->pd_st->state_flags &= ~PFSTATE_ACK;	/* XXX: locking! */
1800 	free(pd, M_PFSYNC);
1801 	pf_release_state(st);
1802 
1803 	if (drop)
1804 		m_freem(m);
1805 	else {
1806 		_IF_ENQUEUE(&b->b_snd, m);
1807 		pfsync_push(b);
1808 	}
1809 }
1810 
1811 static void
1812 pfsync_defer_tmo(void *arg)
1813 {
1814 	struct pfsync_deferral *pd = arg;
1815 	struct pfsync_softc *sc = pd->pd_sc;
1816 	struct mbuf *m = pd->pd_m;
1817 	struct pf_state *st = pd->pd_st;
1818 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1819 
1820 	PFSYNC_BUCKET_LOCK_ASSERT(b);
1821 
1822 	CURVNET_SET(m->m_pkthdr.rcvif->if_vnet);
1823 
1824 	TAILQ_REMOVE(&b->b_deferrals, pd, pd_entry);
1825 	b->b_deferred--;
1826 	pd->pd_st->state_flags &= ~PFSTATE_ACK;	/* XXX: locking! */
1827 	if (pd->pd_refs == 0)
1828 		free(pd, M_PFSYNC);
1829 	PFSYNC_UNLOCK(sc);
1830 
1831 	ip_output(m, NULL, NULL, 0, NULL, NULL);
1832 
1833 	pf_release_state(st);
1834 
1835 	CURVNET_RESTORE();
1836 }
1837 
1838 static void
1839 pfsync_undefer_state(struct pf_state *st, int drop)
1840 {
1841 	struct pfsync_softc *sc = V_pfsyncif;
1842 	struct pfsync_deferral *pd;
1843 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1844 
1845 	PFSYNC_BUCKET_LOCK(b);
1846 
1847 	TAILQ_FOREACH(pd, &b->b_deferrals, pd_entry) {
1848 		 if (pd->pd_st == st) {
1849 			if (callout_stop(&pd->pd_tmo) > 0)
1850 				pfsync_undefer(pd, drop);
1851 
1852 			PFSYNC_BUCKET_UNLOCK(b);
1853 			return;
1854 		}
1855 	}
1856 	PFSYNC_BUCKET_UNLOCK(b);
1857 
1858 	panic("%s: unable to find deferred state", __func__);
1859 }
1860 
1861 static struct pfsync_bucket*
1862 pfsync_get_bucket(struct pfsync_softc *sc, struct pf_state *st)
1863 {
1864 	int c = PF_IDHASH(st) % pfsync_buckets;
1865 	return &sc->sc_buckets[c];
1866 }
1867 
1868 static void
1869 pfsync_update_state(struct pf_state *st)
1870 {
1871 	struct pfsync_softc *sc = V_pfsyncif;
1872 	bool sync = false, ref = true;
1873 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1874 
1875 	PF_STATE_LOCK_ASSERT(st);
1876 	PFSYNC_BUCKET_LOCK(b);
1877 
1878 	if (st->state_flags & PFSTATE_ACK)
1879 		pfsync_undefer_state(st, 0);
1880 	if (st->state_flags & PFSTATE_NOSYNC) {
1881 		if (st->sync_state != PFSYNC_S_NONE)
1882 			pfsync_q_del(st, true, b);
1883 		PFSYNC_BUCKET_UNLOCK(b);
1884 		return;
1885 	}
1886 
1887 	if (b->b_len == PFSYNC_MINPKT)
1888 		callout_reset(&b->b_tmo, 1 * hz, pfsync_timeout, b);
1889 
1890 	switch (st->sync_state) {
1891 	case PFSYNC_S_UPD_C:
1892 	case PFSYNC_S_UPD:
1893 	case PFSYNC_S_INS:
1894 		/* we're already handling it */
1895 
1896 		if (st->key[PF_SK_WIRE]->proto == IPPROTO_TCP) {
1897 			st->sync_updates++;
1898 			if (st->sync_updates >= sc->sc_maxupdates)
1899 				sync = true;
1900 		}
1901 		break;
1902 
1903 	case PFSYNC_S_IACK:
1904 		pfsync_q_del(st, false, b);
1905 		ref = false;
1906 		/* FALLTHROUGH */
1907 
1908 	case PFSYNC_S_NONE:
1909 		pfsync_q_ins(st, PFSYNC_S_UPD_C, ref);
1910 		st->sync_updates = 0;
1911 		break;
1912 
1913 	default:
1914 		panic("%s: unexpected sync state %d", __func__, st->sync_state);
1915 	}
1916 
1917 	if (sync || (time_uptime - st->pfsync_time) < 2)
1918 		pfsync_push(b);
1919 
1920 	PFSYNC_BUCKET_UNLOCK(b);
1921 }
1922 
1923 static void
1924 pfsync_request_update(u_int32_t creatorid, u_int64_t id)
1925 {
1926 	struct pfsync_softc *sc = V_pfsyncif;
1927 	struct pfsync_bucket *b = &sc->sc_buckets[0];
1928 	struct pfsync_upd_req_item *item;
1929 	size_t nlen = sizeof(struct pfsync_upd_req);
1930 
1931 	PFSYNC_BUCKET_LOCK_ASSERT(b);
1932 
1933 	/*
1934 	 * This code does a bit to prevent multiple update requests for the
1935 	 * same state being generated. It searches current subheader queue,
1936 	 * but it doesn't lookup into queue of already packed datagrams.
1937 	 */
1938 	TAILQ_FOREACH(item, &b->b_upd_req_list, ur_entry)
1939 		if (item->ur_msg.id == id &&
1940 		    item->ur_msg.creatorid == creatorid)
1941 			return;
1942 
1943 	item = malloc(sizeof(*item), M_PFSYNC, M_NOWAIT);
1944 	if (item == NULL)
1945 		return; /* XXX stats */
1946 
1947 	item->ur_msg.id = id;
1948 	item->ur_msg.creatorid = creatorid;
1949 
1950 	if (TAILQ_EMPTY(&b->b_upd_req_list))
1951 		nlen += sizeof(struct pfsync_subheader);
1952 
1953 	if (b->b_len + nlen > sc->sc_ifp->if_mtu) {
1954 		pfsync_sendout(1, 0);
1955 
1956 		nlen = sizeof(struct pfsync_subheader) +
1957 		    sizeof(struct pfsync_upd_req);
1958 	}
1959 
1960 	TAILQ_INSERT_TAIL(&b->b_upd_req_list, item, ur_entry);
1961 	b->b_len += nlen;
1962 }
1963 
1964 static bool
1965 pfsync_update_state_req(struct pf_state *st)
1966 {
1967 	struct pfsync_softc *sc = V_pfsyncif;
1968 	bool ref = true, full = false;
1969 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
1970 
1971 	PF_STATE_LOCK_ASSERT(st);
1972 	PFSYNC_BUCKET_LOCK(b);
1973 
1974 	if (st->state_flags & PFSTATE_NOSYNC) {
1975 		if (st->sync_state != PFSYNC_S_NONE)
1976 			pfsync_q_del(st, true, b);
1977 		PFSYNC_BUCKET_UNLOCK(b);
1978 		return (full);
1979 	}
1980 
1981 	switch (st->sync_state) {
1982 	case PFSYNC_S_UPD_C:
1983 	case PFSYNC_S_IACK:
1984 		pfsync_q_del(st, false, b);
1985 		ref = false;
1986 		/* FALLTHROUGH */
1987 
1988 	case PFSYNC_S_NONE:
1989 		pfsync_q_ins(st, PFSYNC_S_UPD, ref);
1990 		pfsync_push(b);
1991 		break;
1992 
1993 	case PFSYNC_S_INS:
1994 	case PFSYNC_S_UPD:
1995 	case PFSYNC_S_DEL:
1996 		/* we're already handling it */
1997 		break;
1998 
1999 	default:
2000 		panic("%s: unexpected sync state %d", __func__, st->sync_state);
2001 	}
2002 
2003 	if ((sc->sc_ifp->if_mtu - b->b_len) < sizeof(struct pfsync_state))
2004 		full = true;
2005 
2006 	PFSYNC_BUCKET_UNLOCK(b);
2007 
2008 	return (full);
2009 }
2010 
2011 static void
2012 pfsync_delete_state(struct pf_state *st)
2013 {
2014 	struct pfsync_softc *sc = V_pfsyncif;
2015 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
2016 	bool ref = true;
2017 
2018 	PFSYNC_BUCKET_LOCK(b);
2019 	if (st->state_flags & PFSTATE_ACK)
2020 		pfsync_undefer_state(st, 1);
2021 	if (st->state_flags & PFSTATE_NOSYNC) {
2022 		if (st->sync_state != PFSYNC_S_NONE)
2023 			pfsync_q_del(st, true, b);
2024 		PFSYNC_BUCKET_UNLOCK(b);
2025 		return;
2026 	}
2027 
2028 	if (b->b_len == PFSYNC_MINPKT)
2029 		callout_reset(&b->b_tmo, 1 * hz, pfsync_timeout, b);
2030 
2031 	switch (st->sync_state) {
2032 	case PFSYNC_S_INS:
2033 		/* We never got to tell the world so just forget about it. */
2034 		pfsync_q_del(st, true, b);
2035 		break;
2036 
2037 	case PFSYNC_S_UPD_C:
2038 	case PFSYNC_S_UPD:
2039 	case PFSYNC_S_IACK:
2040 		pfsync_q_del(st, false, b);
2041 		ref = false;
2042 		/* FALLTHROUGH */
2043 
2044 	case PFSYNC_S_NONE:
2045 		pfsync_q_ins(st, PFSYNC_S_DEL, ref);
2046 		break;
2047 
2048 	default:
2049 		panic("%s: unexpected sync state %d", __func__, st->sync_state);
2050 	}
2051 
2052 	PFSYNC_BUCKET_UNLOCK(b);
2053 }
2054 
2055 static void
2056 pfsync_clear_states(u_int32_t creatorid, const char *ifname)
2057 {
2058 	struct {
2059 		struct pfsync_subheader subh;
2060 		struct pfsync_clr clr;
2061 	} __packed r;
2062 
2063 	bzero(&r, sizeof(r));
2064 
2065 	r.subh.action = PFSYNC_ACT_CLR;
2066 	r.subh.count = htons(1);
2067 	V_pfsyncstats.pfsyncs_oacts[PFSYNC_ACT_CLR]++;
2068 
2069 	strlcpy(r.clr.ifname, ifname, sizeof(r.clr.ifname));
2070 	r.clr.creatorid = creatorid;
2071 
2072 	pfsync_send_plus(&r, sizeof(r));
2073 }
2074 
2075 static void
2076 pfsync_q_ins(struct pf_state *st, int q, bool ref)
2077 {
2078 	struct pfsync_softc *sc = V_pfsyncif;
2079 	size_t nlen = pfsync_qs[q].len;
2080 	struct pfsync_bucket *b = pfsync_get_bucket(sc, st);
2081 
2082 	PFSYNC_BUCKET_LOCK_ASSERT(b);
2083 
2084 	KASSERT(st->sync_state == PFSYNC_S_NONE,
2085 		("%s: st->sync_state %u", __func__, st->sync_state));
2086 	KASSERT(b->b_len >= PFSYNC_MINPKT, ("pfsync pkt len is too low %zu",
2087 	    b->b_len));
2088 
2089 	if (TAILQ_EMPTY(&b->b_qs[q]))
2090 		nlen += sizeof(struct pfsync_subheader);
2091 
2092 	if (b->b_len + nlen > sc->sc_ifp->if_mtu) {
2093 		pfsync_sendout(1, b->b_id);
2094 
2095 		nlen = sizeof(struct pfsync_subheader) + pfsync_qs[q].len;
2096 	}
2097 
2098 	b->b_len += nlen;
2099 	TAILQ_INSERT_TAIL(&b->b_qs[q], st, sync_list);
2100 	st->sync_state = q;
2101 	if (ref)
2102 		pf_ref_state(st);
2103 }
2104 
2105 static void
2106 pfsync_q_del(struct pf_state *st, bool unref, struct pfsync_bucket *b)
2107 {
2108 	int q = st->sync_state;
2109 
2110 	PFSYNC_BUCKET_LOCK_ASSERT(b);
2111 	KASSERT(st->sync_state != PFSYNC_S_NONE,
2112 		("%s: st->sync_state != PFSYNC_S_NONE", __func__));
2113 
2114 	b->b_len -= pfsync_qs[q].len;
2115 	TAILQ_REMOVE(&b->b_qs[q], st, sync_list);
2116 	st->sync_state = PFSYNC_S_NONE;
2117 	if (unref)
2118 		pf_release_state(st);
2119 
2120 	if (TAILQ_EMPTY(&b->b_qs[q]))
2121 		b->b_len -= sizeof(struct pfsync_subheader);
2122 }
2123 
2124 static void
2125 pfsync_bulk_start(void)
2126 {
2127 	struct pfsync_softc *sc = V_pfsyncif;
2128 
2129 	if (V_pf_status.debug >= PF_DEBUG_MISC)
2130 		printf("pfsync: received bulk update request\n");
2131 
2132 	PFSYNC_BLOCK(sc);
2133 
2134 	sc->sc_ureq_received = time_uptime;
2135 	sc->sc_bulk_hashid = 0;
2136 	sc->sc_bulk_stateid = 0;
2137 	pfsync_bulk_status(PFSYNC_BUS_START);
2138 	callout_reset(&sc->sc_bulk_tmo, 1, pfsync_bulk_update, sc);
2139 	PFSYNC_BUNLOCK(sc);
2140 }
2141 
2142 static void
2143 pfsync_bulk_update(void *arg)
2144 {
2145 	struct pfsync_softc *sc = arg;
2146 	struct pf_state *s;
2147 	int i, sent = 0;
2148 
2149 	PFSYNC_BLOCK_ASSERT(sc);
2150 	CURVNET_SET(sc->sc_ifp->if_vnet);
2151 
2152 	/*
2153 	 * Start with last state from previous invocation.
2154 	 * It may had gone, in this case start from the
2155 	 * hash slot.
2156 	 */
2157 	s = pf_find_state_byid(sc->sc_bulk_stateid, sc->sc_bulk_creatorid);
2158 
2159 	if (s != NULL)
2160 		i = PF_IDHASH(s);
2161 	else
2162 		i = sc->sc_bulk_hashid;
2163 
2164 	for (; i <= pf_hashmask; i++) {
2165 		struct pf_idhash *ih = &V_pf_idhash[i];
2166 
2167 		if (s != NULL)
2168 			PF_HASHROW_ASSERT(ih);
2169 		else {
2170 			PF_HASHROW_LOCK(ih);
2171 			s = LIST_FIRST(&ih->states);
2172 		}
2173 
2174 		for (; s; s = LIST_NEXT(s, entry)) {
2175 			if (s->sync_state == PFSYNC_S_NONE &&
2176 			    s->timeout < PFTM_MAX &&
2177 			    s->pfsync_time <= sc->sc_ureq_received) {
2178 				if (pfsync_update_state_req(s)) {
2179 					/* We've filled a packet. */
2180 					sc->sc_bulk_hashid = i;
2181 					sc->sc_bulk_stateid = s->id;
2182 					sc->sc_bulk_creatorid = s->creatorid;
2183 					PF_HASHROW_UNLOCK(ih);
2184 					callout_reset(&sc->sc_bulk_tmo, 1,
2185 					    pfsync_bulk_update, sc);
2186 					goto full;
2187 				}
2188 				sent++;
2189 			}
2190 		}
2191 		PF_HASHROW_UNLOCK(ih);
2192 	}
2193 
2194 	/* We're done. */
2195 	pfsync_bulk_status(PFSYNC_BUS_END);
2196 full:
2197 	CURVNET_RESTORE();
2198 }
2199 
2200 static void
2201 pfsync_bulk_status(u_int8_t status)
2202 {
2203 	struct {
2204 		struct pfsync_subheader subh;
2205 		struct pfsync_bus bus;
2206 	} __packed r;
2207 
2208 	struct pfsync_softc *sc = V_pfsyncif;
2209 
2210 	bzero(&r, sizeof(r));
2211 
2212 	r.subh.action = PFSYNC_ACT_BUS;
2213 	r.subh.count = htons(1);
2214 	V_pfsyncstats.pfsyncs_oacts[PFSYNC_ACT_BUS]++;
2215 
2216 	r.bus.creatorid = V_pf_status.hostid;
2217 	r.bus.endtime = htonl(time_uptime - sc->sc_ureq_received);
2218 	r.bus.status = status;
2219 
2220 	pfsync_send_plus(&r, sizeof(r));
2221 }
2222 
2223 static void
2224 pfsync_bulk_fail(void *arg)
2225 {
2226 	struct pfsync_softc *sc = arg;
2227 	struct pfsync_bucket *b = &sc->sc_buckets[0];
2228 
2229 	CURVNET_SET(sc->sc_ifp->if_vnet);
2230 
2231 	PFSYNC_BLOCK_ASSERT(sc);
2232 
2233 	if (sc->sc_bulk_tries++ < PFSYNC_MAX_BULKTRIES) {
2234 		/* Try again */
2235 		callout_reset(&sc->sc_bulkfail_tmo, 5 * hz,
2236 		    pfsync_bulk_fail, V_pfsyncif);
2237 		PFSYNC_BUCKET_LOCK(b);
2238 		pfsync_request_update(0, 0);
2239 		PFSYNC_BUCKET_UNLOCK(b);
2240 	} else {
2241 		/* Pretend like the transfer was ok. */
2242 		sc->sc_ureq_sent = 0;
2243 		sc->sc_bulk_tries = 0;
2244 		PFSYNC_LOCK(sc);
2245 		if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p)
2246 			(*carp_demote_adj_p)(-V_pfsync_carp_adj,
2247 			    "pfsync bulk fail");
2248 		sc->sc_flags |= PFSYNCF_OK;
2249 		PFSYNC_UNLOCK(sc);
2250 		if (V_pf_status.debug >= PF_DEBUG_MISC)
2251 			printf("pfsync: failed to receive bulk update\n");
2252 	}
2253 
2254 	CURVNET_RESTORE();
2255 }
2256 
2257 static void
2258 pfsync_send_plus(void *plus, size_t pluslen)
2259 {
2260 	struct pfsync_softc *sc = V_pfsyncif;
2261 	struct pfsync_bucket *b = &sc->sc_buckets[0];
2262 
2263 	PFSYNC_BUCKET_LOCK(b);
2264 
2265 	if (b->b_len + pluslen > sc->sc_ifp->if_mtu)
2266 		pfsync_sendout(1, b->b_id);
2267 
2268 	b->b_plus = plus;
2269 	b->b_len += (b->b_pluslen = pluslen);
2270 
2271 	pfsync_sendout(1, b->b_id);
2272 	PFSYNC_BUCKET_UNLOCK(b);
2273 }
2274 
2275 static void
2276 pfsync_timeout(void *arg)
2277 {
2278 	struct pfsync_bucket *b = arg;
2279 
2280 	CURVNET_SET(b->b_sc->sc_ifp->if_vnet);
2281 	PFSYNC_BUCKET_LOCK(b);
2282 	pfsync_push(b);
2283 	PFSYNC_BUCKET_UNLOCK(b);
2284 	CURVNET_RESTORE();
2285 }
2286 
2287 static void
2288 pfsync_push(struct pfsync_bucket *b)
2289 {
2290 
2291 	PFSYNC_BUCKET_LOCK_ASSERT(b);
2292 
2293 	b->b_flags |= PFSYNCF_BUCKET_PUSH;
2294 	swi_sched(V_pfsync_swi_cookie, 0);
2295 }
2296 
2297 static void
2298 pfsync_push_all(struct pfsync_softc *sc)
2299 {
2300 	int c;
2301 	struct pfsync_bucket *b;
2302 
2303 	for (c = 0; c < pfsync_buckets; c++) {
2304 		b = &sc->sc_buckets[c];
2305 
2306 		PFSYNC_BUCKET_LOCK(b);
2307 		pfsync_push(b);
2308 		PFSYNC_BUCKET_UNLOCK(b);
2309 	}
2310 }
2311 
2312 static void
2313 pfsyncintr(void *arg)
2314 {
2315 	struct pfsync_softc *sc = arg;
2316 	struct pfsync_bucket *b;
2317 	struct mbuf *m, *n;
2318 	int c;
2319 
2320 	CURVNET_SET(sc->sc_ifp->if_vnet);
2321 
2322 	for (c = 0; c < pfsync_buckets; c++) {
2323 		b = &sc->sc_buckets[c];
2324 
2325 		PFSYNC_BUCKET_LOCK(b);
2326 		if ((b->b_flags & PFSYNCF_BUCKET_PUSH) && b->b_len > PFSYNC_MINPKT) {
2327 			pfsync_sendout(0, b->b_id);
2328 			b->b_flags &= ~PFSYNCF_BUCKET_PUSH;
2329 		}
2330 		_IF_DEQUEUE_ALL(&b->b_snd, m);
2331 		PFSYNC_BUCKET_UNLOCK(b);
2332 
2333 		for (; m != NULL; m = n) {
2334 
2335 			n = m->m_nextpkt;
2336 			m->m_nextpkt = NULL;
2337 
2338 			/*
2339 			 * We distinguish between a deferral packet and our
2340 			 * own pfsync packet based on M_SKIP_FIREWALL
2341 			 * flag. This is XXX.
2342 			 */
2343 			if (m->m_flags & M_SKIP_FIREWALL)
2344 				ip_output(m, NULL, NULL, 0, NULL, NULL);
2345 			else if (ip_output(m, NULL, NULL, IP_RAWOUTPUT, &sc->sc_imo,
2346 			    NULL) == 0)
2347 				V_pfsyncstats.pfsyncs_opackets++;
2348 			else
2349 				V_pfsyncstats.pfsyncs_oerrors++;
2350 		}
2351 	}
2352 	CURVNET_RESTORE();
2353 }
2354 
2355 static int
2356 pfsync_multicast_setup(struct pfsync_softc *sc, struct ifnet *ifp, void *mship)
2357 {
2358 	struct ip_moptions *imo = &sc->sc_imo;
2359 	int error;
2360 
2361 	if (!(ifp->if_flags & IFF_MULTICAST))
2362 		return (EADDRNOTAVAIL);
2363 
2364 	imo->imo_membership = (struct in_multi **)mship;
2365 	imo->imo_max_memberships = IP_MIN_MEMBERSHIPS;
2366 	imo->imo_multicast_vif = -1;
2367 
2368 	if ((error = in_joingroup(ifp, &sc->sc_sync_peer, NULL,
2369 	    &imo->imo_membership[0])) != 0) {
2370 		imo->imo_membership = NULL;
2371 		return (error);
2372 	}
2373 	imo->imo_num_memberships++;
2374 	imo->imo_multicast_ifp = ifp;
2375 	imo->imo_multicast_ttl = PFSYNC_DFLTTL;
2376 	imo->imo_multicast_loop = 0;
2377 
2378 	return (0);
2379 }
2380 
2381 static void
2382 pfsync_multicast_cleanup(struct pfsync_softc *sc)
2383 {
2384 	struct ip_moptions *imo = &sc->sc_imo;
2385 
2386 	in_leavegroup(imo->imo_membership[0], NULL);
2387 	free(imo->imo_membership, M_PFSYNC);
2388 	imo->imo_membership = NULL;
2389 	imo->imo_multicast_ifp = NULL;
2390 }
2391 
2392 void
2393 pfsync_detach_ifnet(struct ifnet *ifp)
2394 {
2395 	struct pfsync_softc *sc = V_pfsyncif;
2396 
2397 	if (sc == NULL)
2398 		return;
2399 
2400 	PFSYNC_LOCK(sc);
2401 
2402 	if (sc->sc_sync_if == ifp) {
2403 		/* We don't need mutlicast cleanup here, because the interface
2404 		 * is going away. We do need to ensure we don't try to do
2405 		 * cleanup later.
2406 		 */
2407 		sc->sc_imo.imo_membership = NULL;
2408 		sc->sc_imo.imo_multicast_ifp = NULL;
2409 		sc->sc_sync_if = NULL;
2410 	}
2411 
2412 	PFSYNC_UNLOCK(sc);
2413 }
2414 
2415 #ifdef INET
2416 extern  struct domain inetdomain;
2417 static struct protosw in_pfsync_protosw = {
2418 	.pr_type =		SOCK_RAW,
2419 	.pr_domain =		&inetdomain,
2420 	.pr_protocol =		IPPROTO_PFSYNC,
2421 	.pr_flags =		PR_ATOMIC|PR_ADDR,
2422 	.pr_input =		pfsync_input,
2423 	.pr_output =		rip_output,
2424 	.pr_ctloutput =		rip_ctloutput,
2425 	.pr_usrreqs =		&rip_usrreqs
2426 };
2427 #endif
2428 
2429 static void
2430 pfsync_pointers_init()
2431 {
2432 
2433 	PF_RULES_WLOCK();
2434 	V_pfsync_state_import_ptr = pfsync_state_import;
2435 	V_pfsync_insert_state_ptr = pfsync_insert_state;
2436 	V_pfsync_update_state_ptr = pfsync_update_state;
2437 	V_pfsync_delete_state_ptr = pfsync_delete_state;
2438 	V_pfsync_clear_states_ptr = pfsync_clear_states;
2439 	V_pfsync_defer_ptr = pfsync_defer;
2440 	PF_RULES_WUNLOCK();
2441 }
2442 
2443 static void
2444 pfsync_pointers_uninit()
2445 {
2446 
2447 	PF_RULES_WLOCK();
2448 	V_pfsync_state_import_ptr = NULL;
2449 	V_pfsync_insert_state_ptr = NULL;
2450 	V_pfsync_update_state_ptr = NULL;
2451 	V_pfsync_delete_state_ptr = NULL;
2452 	V_pfsync_clear_states_ptr = NULL;
2453 	V_pfsync_defer_ptr = NULL;
2454 	PF_RULES_WUNLOCK();
2455 }
2456 
2457 static void
2458 vnet_pfsync_init(const void *unused __unused)
2459 {
2460 	int error;
2461 
2462 	V_pfsync_cloner = if_clone_simple(pfsyncname,
2463 	    pfsync_clone_create, pfsync_clone_destroy, 1);
2464 	error = swi_add(NULL, pfsyncname, pfsyncintr, V_pfsyncif,
2465 	    SWI_NET, INTR_MPSAFE, &V_pfsync_swi_cookie);
2466 	if (error) {
2467 		if_clone_detach(V_pfsync_cloner);
2468 		log(LOG_INFO, "swi_add() failed in %s\n", __func__);
2469 	}
2470 
2471 	pfsync_pointers_init();
2472 }
2473 VNET_SYSINIT(vnet_pfsync_init, SI_SUB_PROTO_FIREWALL, SI_ORDER_ANY,
2474     vnet_pfsync_init, NULL);
2475 
2476 static void
2477 vnet_pfsync_uninit(const void *unused __unused)
2478 {
2479 
2480 	pfsync_pointers_uninit();
2481 
2482 	if_clone_detach(V_pfsync_cloner);
2483 	swi_remove(V_pfsync_swi_cookie);
2484 }
2485 
2486 VNET_SYSUNINIT(vnet_pfsync_uninit, SI_SUB_PROTO_FIREWALL, SI_ORDER_FOURTH,
2487     vnet_pfsync_uninit, NULL);
2488 
2489 static int
2490 pfsync_init()
2491 {
2492 #ifdef INET
2493 	int error;
2494 
2495 	pfsync_detach_ifnet_ptr = pfsync_detach_ifnet;
2496 
2497 	error = pf_proto_register(PF_INET, &in_pfsync_protosw);
2498 	if (error)
2499 		return (error);
2500 	error = ipproto_register(IPPROTO_PFSYNC);
2501 	if (error) {
2502 		pf_proto_unregister(PF_INET, IPPROTO_PFSYNC, SOCK_RAW);
2503 		return (error);
2504 	}
2505 #endif
2506 
2507 	return (0);
2508 }
2509 
2510 static void
2511 pfsync_uninit()
2512 {
2513 	pfsync_detach_ifnet_ptr = NULL;
2514 
2515 #ifdef INET
2516 	ipproto_unregister(IPPROTO_PFSYNC);
2517 	pf_proto_unregister(PF_INET, IPPROTO_PFSYNC, SOCK_RAW);
2518 #endif
2519 }
2520 
2521 static int
2522 pfsync_modevent(module_t mod, int type, void *data)
2523 {
2524 	int error = 0;
2525 
2526 	switch (type) {
2527 	case MOD_LOAD:
2528 		error = pfsync_init();
2529 		break;
2530 	case MOD_UNLOAD:
2531 		pfsync_uninit();
2532 		break;
2533 	default:
2534 		error = EINVAL;
2535 		break;
2536 	}
2537 
2538 	return (error);
2539 }
2540 
2541 static moduledata_t pfsync_mod = {
2542 	pfsyncname,
2543 	pfsync_modevent,
2544 	0
2545 };
2546 
2547 #define PFSYNC_MODVER 1
2548 
2549 /* Stay on FIREWALL as we depend on pf being initialized and on inetdomain. */
2550 DECLARE_MODULE(pfsync, pfsync_mod, SI_SUB_PROTO_FIREWALL, SI_ORDER_ANY);
2551 MODULE_VERSION(pfsync, PFSYNC_MODVER);
2552 MODULE_DEPEND(pfsync, pf, PF_MODVER, PF_MODVER, PF_MODVER);
2553