Context Navigation

source: rtems-libbsd/freebsd/sys/contrib/pf/net/pf_if.c @ 2017a6d

55-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 2017a6d was 2017a6d, checked in by Sebastian Huber <sebastian.huber@…>, on 04/07/16 at 07:48:12
Directly use <sys/time.h> provided by Newlib
Property mode set to `100644`
File size: 25.8 KB

Line
1	#include <machine/rtems-bsd-kernel-space.h>
2
3	/* $OpenBSD: pf_if.c,v 1.54 2008/06/14 16:55:28 mk Exp $ */
4
5	/*
6	* Copyright 2005 Henning Brauer <henning@openbsd.org>
7	* Copyright 2005 Ryan McBride <mcbride@openbsd.org>
8	* Copyright (c) 2001 Daniel Hartmeier
9	* Copyright (c) 2003 Cedric Berger
10	* All rights reserved.
11	*
12	* Redistribution and use in source and binary forms, with or without
13	* modification, are permitted provided that the following conditions
14	* are met:
15	*
16	* - Redistributions of source code must retain the above copyright
17	* notice, this list of conditions and the following disclaimer.
18	* - Redistributions in binary form must reproduce the above
19	* copyright notice, this list of conditions and the following
20	* disclaimer in the documentation and/or other materials provided
21	* with the distribution.
22	*
23	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27	* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34	* POSSIBILITY OF SUCH DAMAGE.
35	*/
36
37	#if defined(__FreeBSD__)
38	#include <rtems/bsd/local/opt_inet.h>
39	#include <rtems/bsd/local/opt_inet6.h>
40
41	#include <sys/cdefs.h>
42	__FBSDID("$FreeBSD$");
43	#endif
44
45	#include <rtems/bsd/sys/param.h>
46	#include <sys/systm.h>
47	#ifdef __FreeBSD__
48	#include <sys/malloc.h>
49	#endif
50	#include <sys/mbuf.h>
51	#include <sys/filio.h>
52	#include <sys/socket.h>
53	#include <sys/socketvar.h>
54	#include <sys/kernel.h>
55	#ifndef __FreeBSD__
56	#include <sys/device.h>
57	#endif
58	#include <sys/time.h>
59	#ifndef __FreeBSD__
60	#include <sys/pool.h>
61	#endif
62
63	#include <net/if.h>
64	#include <net/if_types.h>
65	#ifdef __FreeBSD__
66	#include <net/vnet.h>
67	#endif
68
69	#include <netinet/in.h>
70	#include <netinet/in_var.h>
71	#include <netinet/in_systm.h>
72	#include <netinet/ip.h>
73	#include <netinet/ip_var.h>
74
75	#include <net/pfvar.h>
76
77	#ifdef INET6
78	#include <netinet/ip6.h>
79	#endif /* INET6 */
80
81	#ifdef __FreeBSD__
82	VNET_DEFINE(struct pfi_kif *, pfi_all);
83	VNET_DEFINE(uma_zone_t, pfi_addr_pl);
84	VNET_DEFINE(struct pfi_ifhead, pfi_ifs);
85	#define V_pfi_ifs VNET(pfi_ifs)
86	VNET_DEFINE(long, pfi_update);
87	#define V_pfi_update VNET(pfi_update)
88	VNET_DEFINE(struct pfr_addr *, pfi_buffer);
89	#define V_pfi_buffer VNET(pfi_buffer)
90	VNET_DEFINE(int, pfi_buffer_cnt);
91	#define V_pfi_buffer_cnt VNET(pfi_buffer_cnt)
92	VNET_DEFINE(int, pfi_buffer_max);
93	#define V_pfi_buffer_max VNET(pfi_buffer_max)
94	#else
95	struct pfi_kif *pfi_all = NULL;
96	struct pool pfi_addr_pl;
97	struct pfi_ifhead pfi_ifs;
98	long pfi_update = 1;
99	struct pfr_addr *pfi_buffer;
100	int pfi_buffer_cnt;
101	int pfi_buffer_max;
102	#endif
103	#ifdef __FreeBSD__
104	eventhandler_tag pfi_attach_cookie;
105	eventhandler_tag pfi_detach_cookie;
106	eventhandler_tag pfi_attach_group_cookie;
107	eventhandler_tag pfi_change_group_cookie;
108	eventhandler_tag pfi_detach_group_cookie;
109	eventhandler_tag pfi_ifaddr_event_cookie;
110	#endif
111
112	void pfi_kif_update(struct pfi_kif *);
113	void pfi_dynaddr_update(struct pfi_dynaddr *dyn);
114	void pfi_table_update(struct pfr_ktable , struct pfi_kif ,
115	int, int);
116	void pfi_kifaddr_update(void *);
117	void pfi_instance_add(struct ifnet *, int, int);
118	void pfi_address_add(struct sockaddr *, int, int);
119	int pfi_if_compare(struct pfi_kif , struct pfi_kif );
120	int pfi_skip_if(const char , struct pfi_kif );
121	int pfi_unmask(void *);
122	#ifdef __FreeBSD__
123	void pfi_attach_ifnet_event(void * __unused, struct ifnet *);
124	void pfi_detach_ifnet_event(void * __unused, struct ifnet *);
125	void pfi_attach_group_event(void , struct ifg_group );
126	void pfi_change_group_event(void , char );
127	void pfi_detach_group_event(void , struct ifg_group );
128	void pfi_ifaddr_event(void * __unused, struct ifnet *);
129	#endif
130
131	RB_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
132	RB_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
133
134	#define PFI_BUFFER_MAX 0x10000
135	#define PFI_MTYPE M_IFADDR
136
137	void
138	pfi_initialize(void)
139	{
140	#ifdef __FreeBSD__
141	if (V_pfi_all != NULL) /* already initialized */
142	#else
143	if (pfi_all != NULL) /* already initialized */
144	#endif
145	return;
146
147	#ifndef __FreeBSD__
148	pool_init(&V_pfi_addr_pl, sizeof(struct pfi_dynaddr), 0, 0, 0,
149	"pfiaddrpl", &pool_allocator_nointr);
150	#endif
151	#ifdef __FreeBSD__
152	V_pfi_buffer_max = 64;
153	V_pfi_buffer = malloc(V_pfi_buffer_max * sizeof(*V_pfi_buffer),
154	PFI_MTYPE, M_WAITOK);
155
156	if ((V_pfi_all = pfi_kif_get(IFG_ALL)) == NULL)
157	#else
158	pfi_buffer_max = 64;
159	pfi_buffer = malloc(pfi_buffer_max * sizeof(*pfi_buffer),
160	PFI_MTYPE, M_WAITOK);
161
162	if ((pfi_all = pfi_kif_get(IFG_ALL)) == NULL)
163	#endif
164	panic("pfi_kif_get for pfi_all failed");
165	#ifdef __FreeBSD__
166	struct ifg_group *ifg;
167	struct ifnet *ifp;
168
169	IFNET_RLOCK();
170	TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
171	pfi_attach_ifgroup(ifg);
172	TAILQ_FOREACH(ifp, &V_ifnet, if_link)
173	pfi_attach_ifnet(ifp);
174	IFNET_RUNLOCK();
175
176	pfi_attach_cookie = EVENTHANDLER_REGISTER(ifnet_arrival_event,
177	pfi_attach_ifnet_event, NULL, EVENTHANDLER_PRI_ANY);
178	pfi_detach_cookie = EVENTHANDLER_REGISTER(ifnet_departure_event,
179	pfi_detach_ifnet_event, NULL, EVENTHANDLER_PRI_ANY);
180	pfi_attach_group_cookie = EVENTHANDLER_REGISTER(group_attach_event,
181	pfi_attach_group_event, curvnet, EVENTHANDLER_PRI_ANY);
182	pfi_change_group_cookie = EVENTHANDLER_REGISTER(group_change_event,
183	pfi_change_group_event, curvnet, EVENTHANDLER_PRI_ANY);
184	pfi_detach_group_cookie = EVENTHANDLER_REGISTER(group_detach_event,
185	pfi_detach_group_event, curvnet, EVENTHANDLER_PRI_ANY);
186	pfi_ifaddr_event_cookie = EVENTHANDLER_REGISTER(ifaddr_event,
187	pfi_ifaddr_event, NULL, EVENTHANDLER_PRI_ANY);
188	#endif
189	}
190
191	#ifdef __FreeBSD__
192	void
193	pfi_cleanup(void)
194	{
195	struct pfi_kif *p;
196
197	PF_UNLOCK();
198	EVENTHANDLER_DEREGISTER(ifnet_arrival_event, pfi_attach_cookie);
199	EVENTHANDLER_DEREGISTER(ifnet_departure_event, pfi_detach_cookie);
200	EVENTHANDLER_DEREGISTER(group_attach_event, pfi_attach_group_cookie);
201	EVENTHANDLER_DEREGISTER(group_change_event, pfi_change_group_cookie);
202	EVENTHANDLER_DEREGISTER(group_detach_event, pfi_detach_group_cookie);
203	EVENTHANDLER_DEREGISTER(ifaddr_event, pfi_ifaddr_event_cookie);
204	PF_LOCK();
205
206	V_pfi_all = NULL;
207	while ((p = RB_MIN(pfi_ifhead, &V_pfi_ifs))) {
208	if (p->pfik_rules \|\| p->pfik_states) {
209	printf("pfi_cleanup: dangling refs for %s\n",
210	p->pfik_name);
211	}
212
213	RB_REMOVE(pfi_ifhead, &V_pfi_ifs, p);
214	free(p, PFI_MTYPE);
215	}
216
217	free(V_pfi_buffer, PFI_MTYPE);
218	}
219	#endif
220
221	struct pfi_kif *
222	pfi_kif_get(const char *kif_name)
223	{
224	struct pfi_kif *kif;
225	struct pfi_kif_cmp s;
226
227	bzero(&s, sizeof(s));
228	strlcpy(s.pfik_name, kif_name, sizeof(s.pfik_name));
229	#ifdef __FreeBSD__
230	if ((kif = RB_FIND(pfi_ifhead, &V_pfi_ifs, (struct pfi_kif *)&s)) != NULL)
231	#else
232	if ((kif = RB_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&s)) != NULL)
233	#endif
234	return (kif);
235
236	/* create new one */
237	#ifdef __FreeBSD__
238	if ((kif = malloc(sizeof(*kif), PFI_MTYPE, M_NOWAIT \| M_ZERO)) == NULL)
239	#else
240	if ((kif = malloc(sizeof(*kif), PFI_MTYPE, M_DONTWAIT\|M_ZERO)) == NULL)
241	#endif
242	return (NULL);
243
244	strlcpy(kif->pfik_name, kif_name, sizeof(kif->pfik_name));
245	#ifdef __FreeBSD__
246	/*
247	* It seems that the value of time_second is in unintialzied state
248	* when pf sets interface statistics clear time in boot phase if pf
249	* was statically linked to kernel. Instead of setting the bogus
250	* time value have pfi_get_ifaces handle this case. In
251	* pfi_get_ifaces it uses boottime.tv_sec if it sees the time is 0.
252	*/
253	kif->pfik_tzero = time_second > 1 ? time_second : 0;
254	#else
255	kif->pfik_tzero = time_second;
256	#endif
257	TAILQ_INIT(&kif->pfik_dynaddrs);
258
259	#ifdef __FreeBSD__
260	RB_INSERT(pfi_ifhead, &V_pfi_ifs, kif);
261	#else
262	RB_INSERT(pfi_ifhead, &pfi_ifs, kif);
263	#endif
264
265	return (kif);
266	}
267
268	void
269	pfi_kif_ref(struct pfi_kif *kif, enum pfi_kif_refs what)
270	{
271	switch (what) {
272	case PFI_KIF_REF_RULE:
273	kif->pfik_rules++;
274	break;
275	case PFI_KIF_REF_STATE:
276	kif->pfik_states++;
277	break;
278	default:
279	panic("pfi_kif_ref with unknown type");
280	}
281	}
282
283	void
284	pfi_kif_unref(struct pfi_kif *kif, enum pfi_kif_refs what)
285	{
286	if (kif == NULL)
287	return;
288
289	switch (what) {
290	case PFI_KIF_REF_NONE:
291	break;
292	case PFI_KIF_REF_RULE:
293	if (kif->pfik_rules <= 0) {
294	printf("pfi_kif_unref: rules refcount <= 0\n");
295	return;
296	}
297	kif->pfik_rules--;
298	break;
299	case PFI_KIF_REF_STATE:
300	if (kif->pfik_states <= 0) {
301	printf("pfi_kif_unref: state refcount <= 0\n");
302	return;
303	}
304	kif->pfik_states--;
305	break;
306	default:
307	panic("pfi_kif_unref with unknown type");
308	}
309
310	#ifdef __FreeBSD__
311	if (kif->pfik_ifp != NULL \|\| kif->pfik_group != NULL \|\| kif == V_pfi_all)
312	#else
313	if (kif->pfik_ifp != NULL \|\| kif->pfik_group != NULL \|\| kif == pfi_all)
314	#endif
315	return;
316
317	if (kif->pfik_rules \|\| kif->pfik_states)
318	return;
319
320	#ifdef __FreeBSD__
321	RB_REMOVE(pfi_ifhead, &V_pfi_ifs, kif);
322	#else
323	RB_REMOVE(pfi_ifhead, &pfi_ifs, kif);
324	#endif
325	free(kif, PFI_MTYPE);
326	}
327
328	int
329	pfi_kif_match(struct pfi_kif rule_kif, struct pfi_kif packet_kif)
330	{
331	struct ifg_list *p;
332
333	if (rule_kif == NULL \|\| rule_kif == packet_kif)
334	return (1);
335
336	if (rule_kif->pfik_group != NULL)
337	TAILQ_FOREACH(p, &packet_kif->pfik_ifp->if_groups, ifgl_next)
338	if (p->ifgl_group == rule_kif->pfik_group)
339	return (1);
340
341	return (0);
342	}
343
344	void
345	pfi_attach_ifnet(struct ifnet *ifp)
346	{
347	struct pfi_kif *kif;
348	int s;
349
350	pfi_initialize();
351	s = splsoftnet();
352	#ifdef __FreeBSD__
353	V_pfi_update++;
354	#else
355	pfi_update++;
356	#endif
357	if ((kif = pfi_kif_get(ifp->if_xname)) == NULL)
358	panic("pfi_kif_get failed");
359
360	kif->pfik_ifp = ifp;
361	ifp->if_pf_kif = (caddr_t)kif;
362
363	#ifndef __FreeBSD__
364	if ((kif->pfik_ah_cookie = hook_establish(ifp->if_addrhooks, 1,
365	pfi_kifaddr_update, kif)) == NULL)
366	panic("pfi_attach_ifnet: cannot allocate '%s' address hook",
367	ifp->if_xname);
368	#endif
369
370	pfi_kif_update(kif);
371
372	splx(s);
373	}
374
375	void
376	pfi_detach_ifnet(struct ifnet *ifp)
377	{
378	int s;
379	struct pfi_kif *kif;
380
381	if ((kif = (struct pfi_kif *)ifp->if_pf_kif) == NULL)
382	return;
383
384	s = splsoftnet();
385	#ifdef __FreeBSD__
386	V_pfi_update++;
387	#else
388	pfi_update++;
389	#endif
390	#ifndef __FreeBSD__
391	hook_disestablish(ifp->if_addrhooks, kif->pfik_ah_cookie);
392	#endif
393	pfi_kif_update(kif);
394
395	kif->pfik_ifp = NULL;
396	ifp->if_pf_kif = NULL;
397	pfi_kif_unref(kif, PFI_KIF_REF_NONE);
398	splx(s);
399	}
400
401	void
402	pfi_attach_ifgroup(struct ifg_group *ifg)
403	{
404	struct pfi_kif *kif;
405	int s;
406
407	pfi_initialize();
408	s = splsoftnet();
409	#ifdef __FreeBSD__
410	V_pfi_update++;
411	#else
412	pfi_update++;
413	#endif
414	if ((kif = pfi_kif_get(ifg->ifg_group)) == NULL)
415	panic("pfi_kif_get failed");
416
417	kif->pfik_group = ifg;
418	ifg->ifg_pf_kif = (caddr_t)kif;
419
420	splx(s);
421	}
422
423	void
424	pfi_detach_ifgroup(struct ifg_group *ifg)
425	{
426	int s;
427	struct pfi_kif *kif;
428
429	if ((kif = (struct pfi_kif *)ifg->ifg_pf_kif) == NULL)
430	return;
431
432	s = splsoftnet();
433	#ifdef __FreeBSD__
434	V_pfi_update++;
435	#else
436	pfi_update++;
437	#endif
438
439	kif->pfik_group = NULL;
440	ifg->ifg_pf_kif = NULL;
441	pfi_kif_unref(kif, PFI_KIF_REF_NONE);
442	splx(s);
443	}
444
445	void
446	pfi_group_change(const char *group)
447	{
448	struct pfi_kif *kif;
449	int s;
450
451	s = splsoftnet();
452	#ifdef __FreeBSD__
453	V_pfi_update++;
454	#else
455	pfi_update++;
456	#endif
457	if ((kif = pfi_kif_get(group)) == NULL)
458	panic("pfi_kif_get failed");
459
460	pfi_kif_update(kif);
461
462	splx(s);
463	}
464
465	int
466	pfi_match_addr(struct pfi_dynaddr dyn, struct pf_addr a, sa_family_t af)
467	{
468	switch (af) {
469	#ifdef INET
470	case AF_INET:
471	switch (dyn->pfid_acnt4) {
472	case 0:
473	return (0);
474	case 1:
475	return (PF_MATCHA(0, &dyn->pfid_addr4,
476	&dyn->pfid_mask4, a, AF_INET));
477	default:
478	return (pfr_match_addr(dyn->pfid_kt, a, AF_INET));
479	}
480	break;
481	#endif /* INET */
482	#ifdef INET6
483	case AF_INET6:
484	switch (dyn->pfid_acnt6) {
485	case 0:
486	return (0);
487	case 1:
488	return (PF_MATCHA(0, &dyn->pfid_addr6,
489	&dyn->pfid_mask6, a, AF_INET6));
490	default:
491	return (pfr_match_addr(dyn->pfid_kt, a, AF_INET6));
492	}
493	break;
494	#endif /* INET6 */
495	default:
496	return (0);
497	}
498	}
499
500	int
501	pfi_dynaddr_setup(struct pf_addr_wrap *aw, sa_family_t af)
502	{
503	struct pfi_dynaddr *dyn;
504	char tblname[PF_TABLE_NAME_SIZE];
505	struct pf_ruleset *ruleset = NULL;
506	int s, rv = 0;
507
508	if (aw->type != PF_ADDR_DYNIFTL)
509	return (0);
510	#ifdef __FreeBSD__
511	if ((dyn = pool_get(&V_pfi_addr_pl, PR_NOWAIT \| PR_ZERO))
512	#else
513	if ((dyn = pool_get(&pfi_addr_pl, PR_WAITOK \| PR_LIMITFAIL \| PR_ZERO))
514	#endif
515	== NULL)
516	return (1);
517
518	s = splsoftnet();
519	if (!strcmp(aw->v.ifname, "self"))
520	dyn->pfid_kif = pfi_kif_get(IFG_ALL);
521	else
522	dyn->pfid_kif = pfi_kif_get(aw->v.ifname);
523	if (dyn->pfid_kif == NULL) {
524	rv = 1;
525	goto _bad;
526	}
527	pfi_kif_ref(dyn->pfid_kif, PFI_KIF_REF_RULE);
528
529	dyn->pfid_net = pfi_unmask(&aw->v.a.mask);
530	if (af == AF_INET && dyn->pfid_net == 32)
531	dyn->pfid_net = 128;
532	strlcpy(tblname, aw->v.ifname, sizeof(tblname));
533	if (aw->iflags & PFI_AFLAG_NETWORK)
534	strlcat(tblname, ":network", sizeof(tblname));
535	if (aw->iflags & PFI_AFLAG_BROADCAST)
536	strlcat(tblname, ":broadcast", sizeof(tblname));
537	if (aw->iflags & PFI_AFLAG_PEER)
538	strlcat(tblname, ":peer", sizeof(tblname));
539	if (aw->iflags & PFI_AFLAG_NOALIAS)
540	strlcat(tblname, ":0", sizeof(tblname));
541	if (dyn->pfid_net != 128)
542	snprintf(tblname + strlen(tblname),
543	sizeof(tblname) - strlen(tblname), "/%d", dyn->pfid_net);
544	if ((ruleset = pf_find_or_create_ruleset(PF_RESERVED_ANCHOR)) == NULL) {
545	rv = 1;
546	goto _bad;
547	}
548
549	if ((dyn->pfid_kt = pfr_attach_table(ruleset, tblname, 1)) == NULL) {
550	rv = 1;
551	goto _bad;
552	}
553
554	dyn->pfid_kt->pfrkt_flags \|= PFR_TFLAG_ACTIVE;
555	dyn->pfid_iflags = aw->iflags;
556	dyn->pfid_af = af;
557
558	TAILQ_INSERT_TAIL(&dyn->pfid_kif->pfik_dynaddrs, dyn, entry);
559	aw->p.dyn = dyn;
560	pfi_kif_update(dyn->pfid_kif);
561	splx(s);
562	return (0);
563
564	_bad:
565	if (dyn->pfid_kt != NULL)
566	pfr_detach_table(dyn->pfid_kt);
567	if (ruleset != NULL)
568	pf_remove_if_empty_ruleset(ruleset);
569	if (dyn->pfid_kif != NULL)
570	pfi_kif_unref(dyn->pfid_kif, PFI_KIF_REF_RULE);
571	#ifdef __FreeBSD__
572	pool_put(&V_pfi_addr_pl, dyn);
573	#else
574	pool_put(&pfi_addr_pl, dyn);
575	#endif
576	splx(s);
577	return (rv);
578	}
579
580	void
581	pfi_kif_update(struct pfi_kif *kif)
582	{
583	struct ifg_list *ifgl;
584	struct pfi_dynaddr *p;
585
586	/* update all dynaddr */
587	TAILQ_FOREACH(p, &kif->pfik_dynaddrs, entry)
588	pfi_dynaddr_update(p);
589
590	/* again for all groups kif is member of */
591	if (kif->pfik_ifp != NULL)
592	TAILQ_FOREACH(ifgl, &kif->pfik_ifp->if_groups, ifgl_next)
593	pfi_kif_update((struct pfi_kif *)
594	ifgl->ifgl_group->ifg_pf_kif);
595	}
596
597	void
598	pfi_dynaddr_update(struct pfi_dynaddr *dyn)
599	{
600	struct pfi_kif *kif;
601	struct pfr_ktable *kt;
602
603	if (dyn == NULL \|\| dyn->pfid_kif == NULL \|\| dyn->pfid_kt == NULL)
604	panic("pfi_dynaddr_update");
605
606	kif = dyn->pfid_kif;
607	kt = dyn->pfid_kt;
608
609	#ifdef __FreeBSD__
610	if (kt->pfrkt_larg != V_pfi_update) {
611	#else
612	if (kt->pfrkt_larg != pfi_update) {
613	#endif
614	/* this table needs to be brought up-to-date */
615	pfi_table_update(kt, kif, dyn->pfid_net, dyn->pfid_iflags);
616	#ifdef __FreeBSD__
617	kt->pfrkt_larg = V_pfi_update;
618	#else
619	kt->pfrkt_larg = pfi_update;
620	#endif
621	}
622	pfr_dynaddr_update(kt, dyn);
623	}
624
625	void
626	pfi_table_update(struct pfr_ktable kt, struct pfi_kif kif, int net, int flags)
627	{
628	int e, size2 = 0;
629	struct ifg_member *ifgm;
630
631	#ifdef __FreeBSD__
632	V_pfi_buffer_cnt = 0;
633	#else
634	pfi_buffer_cnt = 0;
635	#endif
636
637	if (kif->pfik_ifp != NULL)
638	pfi_instance_add(kif->pfik_ifp, net, flags);
639	else if (kif->pfik_group != NULL)
640	TAILQ_FOREACH(ifgm, &kif->pfik_group->ifg_members, ifgm_next)
641	pfi_instance_add(ifgm->ifgm_ifp, net, flags);
642
643	#ifdef __FreeBSD__
644	if ((e = pfr_set_addrs(&kt->pfrkt_t, V_pfi_buffer, V_pfi_buffer_cnt, &size2,
645	NULL, NULL, NULL, 0, PFR_TFLAG_ALLMASK)))
646	printf("pfi_table_update: cannot set %d new addresses "
647	"into table %s: %d\n", V_pfi_buffer_cnt, kt->pfrkt_name, e);
648	#else
649	if ((e = pfr_set_addrs(&kt->pfrkt_t, pfi_buffer, pfi_buffer_cnt, &size2,
650	NULL, NULL, NULL, 0, PFR_TFLAG_ALLMASK)))
651	printf("pfi_table_update: cannot set %d new addresses "
652	"into table %s: %d\n", pfi_buffer_cnt, kt->pfrkt_name, e);
653	#endif
654	}
655
656	void
657	pfi_instance_add(struct ifnet *ifp, int net, int flags)
658	{
659	struct ifaddr *ia;
660	int got4 = 0, got6 = 0;
661	int net2, af;
662
663	if (ifp == NULL)
664	return;
665	TAILQ_FOREACH(ia, &ifp->if_addrlist, ifa_list) {
666	if (ia->ifa_addr == NULL)
667	continue;
668	af = ia->ifa_addr->sa_family;
669	if (af != AF_INET && af != AF_INET6)
670	continue;
671	#ifdef __FreeBSD__
672	/*
673	* XXX: For point-to-point interfaces, (ifname:0) and IPv4,
674	* jump over addresses without a proper route to work
675	* around a problem with ppp not fully removing the
676	* address used during IPCP.
677	*/
678	if ((ifp->if_flags & IFF_POINTOPOINT) &&
679	!(ia->ifa_flags & IFA_ROUTE) &&
680	(flags & PFI_AFLAG_NOALIAS) && (af == AF_INET))
681	continue;
682	#endif
683	if ((flags & PFI_AFLAG_BROADCAST) && af == AF_INET6)
684	continue;
685	if ((flags & PFI_AFLAG_BROADCAST) &&
686	!(ifp->if_flags & IFF_BROADCAST))
687	continue;
688	if ((flags & PFI_AFLAG_PEER) &&
689	!(ifp->if_flags & IFF_POINTOPOINT))
690	continue;
691	if ((flags & PFI_AFLAG_NETWORK) && af == AF_INET6 &&
692	IN6_IS_ADDR_LINKLOCAL(
693	&((struct sockaddr_in6 *)ia->ifa_addr)->sin6_addr))
694	continue;
695	if (flags & PFI_AFLAG_NOALIAS) {
696	if (af == AF_INET && got4)
697	continue;
698	if (af == AF_INET6 && got6)
699	continue;
700	}
701	if (af == AF_INET)
702	got4 = 1;
703	else if (af == AF_INET6)
704	got6 = 1;
705	net2 = net;
706	if (net2 == 128 && (flags & PFI_AFLAG_NETWORK)) {
707	if (af == AF_INET)
708	net2 = pfi_unmask(&((struct sockaddr_in *)
709	ia->ifa_netmask)->sin_addr);
710	else if (af == AF_INET6)
711	net2 = pfi_unmask(&((struct sockaddr_in6 *)
712	ia->ifa_netmask)->sin6_addr);
713	}
714	if (af == AF_INET && net2 > 32)
715	net2 = 32;
716	if (flags & PFI_AFLAG_BROADCAST)
717	pfi_address_add(ia->ifa_broadaddr, af, net2);
718	else if (flags & PFI_AFLAG_PEER)
719	pfi_address_add(ia->ifa_dstaddr, af, net2);
720	else
721	pfi_address_add(ia->ifa_addr, af, net2);
722	}
723	}
724
725	void
726	pfi_address_add(struct sockaddr *sa, int af, int net)
727	{
728	struct pfr_addr *p;
729	int i;
730
731	#ifdef __FreeBSD__
732	if (V_pfi_buffer_cnt >= V_pfi_buffer_max) {
733	int new_max = V_pfi_buffer_max * 2;
734	#else
735	if (pfi_buffer_cnt >= pfi_buffer_max) {
736	int new_max = pfi_buffer_max * 2;
737	#endif
738
739	if (new_max > PFI_BUFFER_MAX) {
740	printf("pfi_address_add: address buffer full (%d/%d)\n",
741	#ifdef __FreeBSD__
742	V_pfi_buffer_cnt, PFI_BUFFER_MAX);
743	#else
744	pfi_buffer_cnt, PFI_BUFFER_MAX);
745	#endif
746	return;
747	}
748	p = malloc(new_max * sizeof(*V_pfi_buffer), PFI_MTYPE,
749	#ifdef __FreeBSD__
750	M_NOWAIT);
751	#else
752	M_DONTWAIT);
753	#endif
754	if (p == NULL) {
755	printf("pfi_address_add: no memory to grow buffer "
756	#ifdef __FreeBSD__
757	"(%d/%d)\n", V_pfi_buffer_cnt, PFI_BUFFER_MAX);
758	#else
759	"(%d/%d)\n", pfi_buffer_cnt, PFI_BUFFER_MAX);
760	#endif
761	return;
762	}
763	#ifdef __FreeBSD__
764	memcpy(V_pfi_buffer, p, V_pfi_buffer_cnt * sizeof(*V_pfi_buffer));
765	/* no need to zero buffer */
766	free(V_pfi_buffer, PFI_MTYPE);
767	V_pfi_buffer = p;
768	V_pfi_buffer_max = new_max;
769	#else
770	memcpy(pfi_buffer, p, pfi_buffer_cnt * sizeof(*pfi_buffer));
771	/* no need to zero buffer */
772	free(pfi_buffer, PFI_MTYPE);
773	pfi_buffer = p;
774	pfi_buffer_max = new_max;
775	#endif
776	}
777	if (af == AF_INET && net > 32)
778	net = 128;
779	#ifdef __FreeBSD__
780	p = V_pfi_buffer + V_pfi_buffer_cnt++;
781	#else
782	p = pfi_buffer + pfi_buffer_cnt++;
783	#endif
784	bzero(p, sizeof(*p));
785	p->pfra_af = af;
786	p->pfra_net = net;
787	if (af == AF_INET)
788	p->pfra_ip4addr = ((struct sockaddr_in *)sa)->sin_addr;
789	else if (af == AF_INET6) {
790	p->pfra_ip6addr = ((struct sockaddr_in6 *)sa)->sin6_addr;
791	if (IN6_IS_SCOPE_EMBED(&p->pfra_ip6addr))
792	p->pfra_ip6addr.s6_addr16[1] = 0;
793	}
794	/* mask network address bits */
795	if (net < 128)
796	((caddr_t)p)[p->pfra_net/8] &= ~(0xFF >> (p->pfra_net%8));
797	for (i = (p->pfra_net+7)/8; i < sizeof(p->pfra_u); i++)
798	((caddr_t)p)[i] = 0;
799	}
800
801	void
802	pfi_dynaddr_remove(struct pf_addr_wrap *aw)
803	{
804	int s;
805
806	if (aw->type != PF_ADDR_DYNIFTL \|\| aw->p.dyn == NULL \|\|
807	aw->p.dyn->pfid_kif == NULL \|\| aw->p.dyn->pfid_kt == NULL)
808	return;
809
810	s = splsoftnet();
811	TAILQ_REMOVE(&aw->p.dyn->pfid_kif->pfik_dynaddrs, aw->p.dyn, entry);
812	pfi_kif_unref(aw->p.dyn->pfid_kif, PFI_KIF_REF_RULE);
813	aw->p.dyn->pfid_kif = NULL;
814	pfr_detach_table(aw->p.dyn->pfid_kt);
815	aw->p.dyn->pfid_kt = NULL;
816	#ifdef __FreeBSD__
817	pool_put(&V_pfi_addr_pl, aw->p.dyn);
818	#else
819	pool_put(&pfi_addr_pl, aw->p.dyn);
820	#endif
821	aw->p.dyn = NULL;
822	splx(s);
823	}
824
825	void
826	pfi_dynaddr_copyout(struct pf_addr_wrap *aw)
827	{
828	if (aw->type != PF_ADDR_DYNIFTL \|\| aw->p.dyn == NULL \|\|
829	aw->p.dyn->pfid_kif == NULL)
830	return;
831	aw->p.dyncnt = aw->p.dyn->pfid_acnt4 + aw->p.dyn->pfid_acnt6;
832	}
833
834	void
835	pfi_kifaddr_update(void *v)
836	{
837	int s;
838	struct pfi_kif kif = (struct pfi_kif )v;
839
840	s = splsoftnet();
841	#ifdef __FreeBSD__
842	V_pfi_update++;
843	#else
844	pfi_update++;
845	#endif
846	pfi_kif_update(kif);
847	splx(s);
848	}
849
850	int
851	pfi_if_compare(struct pfi_kif p, struct pfi_kif q)
852	{
853	return (strncmp(p->pfik_name, q->pfik_name, IFNAMSIZ));
854	}
855
856	void
857	pfi_update_status(const char name, struct pf_status pfs)
858	{
859	struct pfi_kif *p;
860	struct pfi_kif_cmp key;
861	struct ifg_member p_member, *ifgm;
862	TAILQ_HEAD(, ifg_member) ifg_members;
863	int i, j, k, s;
864
865	strlcpy(key.pfik_name, name, sizeof(key.pfik_name));
866	s = splsoftnet();
867	#ifdef __FreeBSD__
868	p = RB_FIND(pfi_ifhead, &V_pfi_ifs, (struct pfi_kif *)&key);
869	#else
870	p = RB_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&key);
871	#endif
872	if (p == NULL) {
873	splx(s);
874	return;
875	}
876	if (p->pfik_group != NULL) {
877	bcopy(&p->pfik_group->ifg_members, &ifg_members,
878	sizeof(ifg_members));
879	} else {
880	/* build a temporary list for p only */
881	bzero(&p_member, sizeof(p_member));
882	p_member.ifgm_ifp = p->pfik_ifp;
883	TAILQ_INIT(&ifg_members);
884	TAILQ_INSERT_TAIL(&ifg_members, &p_member, ifgm_next);
885	}
886	if (pfs) {
887	bzero(pfs->pcounters, sizeof(pfs->pcounters));
888	bzero(pfs->bcounters, sizeof(pfs->bcounters));
889	}
890	TAILQ_FOREACH(ifgm, &ifg_members, ifgm_next) {
891	if (ifgm->ifgm_ifp == NULL)
892	continue;
893	p = (struct pfi_kif *)ifgm->ifgm_ifp->if_pf_kif;
894
895	/* just clear statistics */
896	if (pfs == NULL) {
897	bzero(p->pfik_packets, sizeof(p->pfik_packets));
898	bzero(p->pfik_bytes, sizeof(p->pfik_bytes));
899	p->pfik_tzero = time_second;
900	continue;
901	}
902	for (i = 0; i < 2; i++)
903	for (j = 0; j < 2; j++)
904	for (k = 0; k < 2; k++) {
905	pfs->pcounters[i][j][k] +=
906	p->pfik_packets[i][j][k];
907	pfs->bcounters[i][j] +=
908	p->pfik_bytes[i][j][k];
909	}
910	}
911	splx(s);
912	}
913
914	int
915	pfi_get_ifaces(const char name, struct pfi_kif buf, int *size)
916	{
917	struct pfi_kif p, nextp;
918	int s, n = 0;
919	#ifdef __FreeBSD__
920	int error;
921	#endif
922
923	s = splsoftnet();
924	#ifdef __FreeBSD__
925	for (p = RB_MIN(pfi_ifhead, &V_pfi_ifs); p; p = nextp) {
926	nextp = RB_NEXT(pfi_ifhead, &V_pfi_ifs, p);
927	#else
928	for (p = RB_MIN(pfi_ifhead, &pfi_ifs); p; p = nextp) {
929	nextp = RB_NEXT(pfi_ifhead, &pfi_ifs, p);
930	#endif
931	if (pfi_skip_if(name, p))
932	continue;
933	if (*size > n++) {
934	if (!p->pfik_tzero)
935	p->pfik_tzero = time_second;
936	pfi_kif_ref(p, PFI_KIF_REF_RULE);
937	#ifdef __FreeBSD__
938	PF_COPYOUT(p, buf++, sizeof(*buf), error);
939	if (error) {
940	#else
941	if (copyout(p, buf++, sizeof(*buf))) {
942	#endif
943	pfi_kif_unref(p, PFI_KIF_REF_RULE);
944	splx(s);
945	return (EFAULT);
946	}
947	#ifdef __FreeBSD__
948	nextp = RB_NEXT(pfi_ifhead, &V_pfi_ifs, p);
949	#else
950	nextp = RB_NEXT(pfi_ifhead, &pfi_ifs, p);
951	#endif
952	pfi_kif_unref(p, PFI_KIF_REF_RULE);
953	}
954	}
955	splx(s);
956	*size = n;
957	return (0);
958	}
959
960	int
961	pfi_skip_if(const char filter, struct pfi_kif p)
962	{
963	int n;
964
965	if (filter == NULL \|\| !*filter)
966	return (0);
967	if (!strcmp(p->pfik_name, filter))
968	return (0); /* exact match */
969	n = strlen(filter);
970	if (n < 1 \|\| n >= IFNAMSIZ)
971	return (1); /* sanity check */
972	if (filter[n-1] >= '0' && filter[n-1] <= '9')
973	return (1); /* only do exact match in that case */
974	if (strncmp(p->pfik_name, filter, n))
975	return (1); /* prefix doesn't match */
976	return (p->pfik_name[n] < '0' \|\| p->pfik_name[n] > '9');
977	}
978
979	int
980	pfi_set_flags(const char *name, int flags)
981	{
982	struct pfi_kif *p;
983	int s;
984
985	s = splsoftnet();
986	#ifdef __FreeBSD__
987	RB_FOREACH(p, pfi_ifhead, &V_pfi_ifs) {
988	#else
989	RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
990	#endif
991	if (pfi_skip_if(name, p))
992	continue;
993	p->pfik_flags \|= flags;
994	}
995	splx(s);
996	return (0);
997	}
998
999	int
1000	pfi_clear_flags(const char *name, int flags)
1001	{
1002	struct pfi_kif *p;
1003	int s;
1004
1005	s = splsoftnet();
1006	#ifdef __FreeBSD__
1007	RB_FOREACH(p, pfi_ifhead, &V_pfi_ifs) {
1008	#else
1009	RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
1010	#endif
1011	if (pfi_skip_if(name, p))
1012	continue;
1013	p->pfik_flags &= ~flags;
1014	}
1015	splx(s);
1016	return (0);
1017	}
1018
1019	/* from pf_print_state.c */
1020	int
1021	pfi_unmask(void *addr)
1022	{
1023	struct pf_addr *m = addr;
1024	int i = 31, j = 0, b = 0;
1025	u_int32_t tmp;
1026
1027	while (j < 4 && m->addr32[j] == 0xffffffff) {
1028	b += 32;
1029	j++;
1030	}
1031	if (j < 4) {
1032	tmp = ntohl(m->addr32[j]);
1033	for (i = 31; tmp & (1 << i); --i)
1034	b++;
1035	}
1036	return (b);
1037	}
1038
1039	#ifdef __FreeBSD__
1040	void
1041	pfi_attach_ifnet_event(void arg __unused, struct ifnet ifp)
1042	{
1043
1044	CURVNET_SET(ifp->if_vnet);
1045	PF_LOCK();
1046	pfi_attach_ifnet(ifp);
1047	#ifdef ALTQ
1048	pf_altq_ifnet_event(ifp, 0);
1049	#endif
1050	PF_UNLOCK();
1051	CURVNET_RESTORE();
1052	}
1053
1054	void
1055	pfi_detach_ifnet_event(void arg __unused, struct ifnet ifp)
1056	{
1057
1058	CURVNET_SET(ifp->if_vnet);
1059	PF_LOCK();
1060	pfi_detach_ifnet(ifp);
1061	#ifdef ALTQ
1062	pf_altq_ifnet_event(ifp, 1);
1063	#endif
1064	PF_UNLOCK();
1065	CURVNET_RESTORE();
1066	}
1067
1068	void
1069	pfi_attach_group_event(void arg , struct ifg_group ifg)
1070	{
1071
1072	CURVNET_SET((struct vnet *)arg);
1073	PF_LOCK();
1074	pfi_attach_ifgroup(ifg);
1075	PF_UNLOCK();
1076	CURVNET_RESTORE();
1077	}
1078
1079	void
1080	pfi_change_group_event(void arg, char gname)
1081	{
1082
1083	CURVNET_SET((struct vnet *)arg);
1084	PF_LOCK();
1085	pfi_group_change(gname);
1086	PF_UNLOCK();
1087	CURVNET_RESTORE();
1088	}
1089
1090	void
1091	pfi_detach_group_event(void arg, struct ifg_group ifg)
1092	{
1093
1094	CURVNET_SET((struct vnet *)arg);
1095	PF_LOCK();
1096	pfi_detach_ifgroup(ifg);
1097	PF_UNLOCK();
1098	CURVNET_RESTORE();
1099	}
1100
1101	void
1102	pfi_ifaddr_event(void arg __unused, struct ifnet ifp)
1103	{
1104
1105	CURVNET_SET(ifp->if_vnet);
1106	PF_LOCK();
1107	if (ifp && ifp->if_pf_kif)
1108	pfi_kifaddr_update(ifp->if_pf_kif);
1109	PF_UNLOCK();
1110	CURVNET_RESTORE();
1111	}
1112	#endif /* __FreeBSD__ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: