[apple/xnu.git] / bsd / kern / uipc_domain.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1982, 1986, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)uipc_domain.c	8.3 (Berkeley) 2/14/95
 */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/domain.h>
#include <sys/mbuf.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/queue.h>

void	pffasttimo __P((void *));
void	pfslowtimo __P((void *));

/*
 * Add/delete 'domain': Link structure into system list,
 *  invoke the domain init, and then the proto inits.
 * To delete, just remove from the list (dom_refs must be zero)
 */


void init_domain(register struct domain *dp)
{
	struct protosw  *pr;
	
	if (dp->dom_init)
		(*dp->dom_init)();

	/* and then init the currently installed protos in this domain */

	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
		if (pr->pr_usrreqs == 0)
			panic("domaininit: %ssw[%d] has no usrreqs!",
			      dp->dom_name, 
			      (int)(pr - dp->dom_protosw));

		if (pr->pr_init)
			(*pr->pr_init)();
	}

	/* Recompute for new protocol */
	if (max_linkhdr < 16)		/* XXX - Sheesh; everything's ether? */
		max_linkhdr = 16;
	if (dp->dom_protohdrlen > max_protohdr)
		max_protohdr = dp->dom_protohdrlen;
	max_hdr = max_linkhdr + max_protohdr;
	max_datalen = MHLEN - max_hdr;
}

void	concat_domain(struct domain *dp) 
{
	dp->dom_next = domains; 
	domains = dp; 
}

void
net_add_domain(register struct domain *dp)
{	register struct protosw *pr;
	register int s;
	extern int splhigh(void);
	extern int splx(int);

	kprintf("Adding domain %s (family %d)\n", dp->dom_name,
		dp->dom_family);
	/* First, link in the domain */
	s = splhigh();

	concat_domain(dp);

	init_domain(dp);

	splx(s);
}

int
net_del_domain(register struct domain *dp)
{	register struct domain *dp1, *dp2;
	register int s, retval = 0;
	extern int splhigh(void);
	extern int splx(int);
 
	if (dp->dom_refs)
		return(EBUSY);

	s = splhigh();

	for (dp2 = NULL, dp1 = domains; dp1; dp2 = dp1, dp1 = dp1->dom_next)
	{	if (dp == dp1)
			break;
	}
	if (dp1)
	{	if (dp2)
			dp2->dom_next = dp1->dom_next;
		else
			domains = dp1->dom_next;
	} else
		retval = EPFNOSUPPORT;
	splx(s);

	return(retval);
}

/*
 * net_add_proto - link a protosw into a domain's protosw chain
 */
int
net_add_proto(register struct protosw *pp,
	      register struct domain *dp)
{	register struct protosw *pp1, *pp2;
	register int s;
	extern int splhigh(void);
	extern int splx(int);

	s = splhigh();
	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
	{	if (pp1->pr_type == pp->pr_type &&
		    pp1->pr_protocol == pp->pr_protocol) {
			splx(s);
			return(EEXIST);
		}
		pp2 = pp1;
	}
	if (pp2 == NULL)
		dp->dom_protosw = pp;
	else
		pp2->pr_next = pp;
	pp->pr_next = NULL;
	TAILQ_INIT(&pp->pr_sfilter);
	if (pp->pr_init)
		(*pp->pr_init)();

	/* Make sure pr_init isn't called again!! */
	pp->pr_init = 0;
	splx(s);
	return(0);
}

/*
 * net_del_proto - remove a protosw from a domain's protosw chain.
 * Search the protosw chain for the element with matching data.
 * Then unlink and return.
 */
int
net_del_proto(register int type,
	      register int protocol,
	      register struct domain *dp)
{	register struct protosw *pp1, *pp2;
	int s;
	extern int splhigh(void);
	extern int splx(int);

	s = splhigh();
	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
	{	if (pp1->pr_type == type &&
		    pp1->pr_protocol == protocol)
			break;
		pp2 = pp1;
	}
        if (pp1 == NULL) {
			splx(s);
			return(ENXIO);
		}
	if (pp2)
		pp2->pr_next = pp1->pr_next;
	else
		dp->dom_protosw = pp1->pr_next;
	splx(s);
	return(0);
}


void
domaininit()
{	register struct domain *dp;
	register struct protosw *pr;
	extern struct domain localdomain, routedomain, ndrvdomain, inetdomain;
	extern struct domain systemdomain;
#if NS
	extern struct domain nsdomain;
#endif
#if ISO
	extern struct domain isodomain;
#endif
#if CCITT
	extern struct domain ccittdomain;
#endif

#if NETAT
	extern struct domain atalkdomain;
#endif
#if INET6
	extern struct domain inet6domain;
#endif
#if IPSEC
	extern struct domain keydomain;
#endif

	/*
	 * Add all the static domains to the domains list
	 */

	thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
	concat_domain(&localdomain);
	concat_domain(&routedomain);
	concat_domain(&inetdomain);
#if NETAT
	concat_domain(&atalkdomain);
#endif
#if INET6
	concat_domain(&inet6domain);
#endif
#if IPSEC
	concat_domain(&keydomain);
#endif

#if NS
	concat_domain(&nsdomain);
#endif
#if ISO
	concat_domain(&isodomain);
#endif
#if CCITT
	concat_domain(&ccittdomain);
#endif
	concat_domain(&ndrvdomain);

	concat_domain(&systemdomain);

	/*
	 * Now ask them all to init (XXX including the routing domain,
	 * see above)
	 */
	for (dp = domains; dp; dp = dp->dom_next)
		init_domain(dp);

	timeout(pffasttimo, NULL, 1);
	timeout(pfslowtimo, NULL, 1);
	thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
}

struct protosw *
pffindtype(family, type)
	int family, type;
{
	register struct domain *dp;
	register struct protosw *pr;

	for (dp = domains; dp; dp = dp->dom_next)
		if (dp->dom_family == family)
			goto found;
	return (0);
found:
	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
		if (pr->pr_type && pr->pr_type == type)
			return (pr);
	return (0);
}

struct domain *
pffinddomain(int pf)
{	struct domain *dp;

	dp = domains;
	while (dp)
	{	if (dp->dom_family == pf)
			return(dp);
		dp = dp->dom_next;
	}
	return(NULL);
}

struct protosw *
pffindproto(family, protocol, type)
	int family, protocol, type;
{
	register struct domain *dp;
	register struct protosw *pr;
	struct protosw *maybe = 0;

	if (family == 0)
		return (0);
	for (dp = domains; dp; dp = dp->dom_next)
		if (dp->dom_family == family)
			goto found;
	return (0);
found:
	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
		if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
			return (pr);

		if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
		    pr->pr_protocol == 0 && maybe == (struct protosw *)0)
			maybe = pr;
	}
	return (maybe);
}

int
net_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
	int *name;
	u_int namelen;
	void *oldp;
	size_t *oldlenp;
	void *newp;
	size_t newlen;
	struct proc *p;
{
	register struct domain *dp;
	register struct protosw *pr;
	int family, protocol;

	/*
	 * All sysctl names at this level are nonterminal;
	 * next two components are protocol family and protocol number,
	 * then at least one addition component.
	 */
	if (namelen < 3)
		return (EISDIR);		/* overloaded */
	family = name[0];
	protocol = name[1];

	if (family == 0)
		return (0);
	for (dp = domains; dp; dp = dp->dom_next)
		if (dp->dom_family == family)
			goto found;
	return (ENOPROTOOPT);
found:
	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
		if (pr->pr_protocol == protocol && pr->pr_sysctl)
			return ((*pr->pr_sysctl)(name + 2, namelen - 2,
			    oldp, oldlenp, newp, newlen));
	return (ENOPROTOOPT);
}

void
pfctlinput(cmd, sa)
	int cmd;
	struct sockaddr *sa;
{
	pfctlinput2(cmd, sa, (void*)0);
}

void
pfctlinput2(cmd, sa, ctlparam)
	int cmd;
	struct sockaddr *sa;
	void *ctlparam;
{
	struct domain *dp;
	struct protosw *pr;

	if (!sa)
		return;
	for (dp = domains; dp; dp = dp->dom_next)
		for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
			if (pr->pr_ctlinput)
				(*pr->pr_ctlinput)(cmd, sa, ctlparam);
}

void
pfslowtimo(arg)
	void *arg;
{
	register struct domain *dp;
	register struct protosw *pr;
	boolean_t 	funnel_state;

	funnel_state = thread_funnel_set(network_flock, TRUE);

	for (dp = domains; dp; dp = dp->dom_next)
		for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
			if (pr->pr_slowtimo)
				(*pr->pr_slowtimo)();
	timeout(pfslowtimo, NULL, hz/2);
        
	(void) thread_funnel_set(network_flock, FALSE);
}

void
pffasttimo(arg)
	void *arg;
{
	register struct domain *dp;
	register struct protosw *pr;
	boolean_t 	funnel_state;

	funnel_state = thread_funnel_set(network_flock, TRUE);

	for (dp = domains; dp; dp = dp->dom_next)
		for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
			if (pr->pr_fasttimo)
				(*pr->pr_fasttimo)();
	timeout(pffasttimo, NULL, hz/5);

	(void) thread_funnel_set(network_flock, FALSE);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
	26	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	27	/*
	28	* Copyright (c) 1982, 1986, 1993
	29	* The Regents of the University of California. All rights reserved.
	30	*
	31	* Redistribution and use in source and binary forms, with or without
	32	* modification, are permitted provided that the following conditions
	33	* are met:
	34	* 1. Redistributions of source code must retain the above copyright
	35	* notice, this list of conditions and the following disclaimer.
	36	* 2. Redistributions in binary form must reproduce the above copyright
	37	* notice, this list of conditions and the following disclaimer in the
	38	* documentation and/or other materials provided with the distribution.
	39	* 3. All advertising materials mentioning features or use of this software
	40	* must display the following acknowledgement:
	41	* This product includes software developed by the University of
	42	* California, Berkeley and its contributors.
	43	* 4. Neither the name of the University nor the names of its contributors
	44	* may be used to endorse or promote products derived from this software
	45	* without specific prior written permission.
	46	*
	47	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	48	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	49	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	50	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	51	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	52	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	53	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	54	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	55	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	56	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	57	* SUCH DAMAGE.
	58	*
	59	* @(#)uipc_domain.c 8.3 (Berkeley) 2/14/95
	60	*/
	61
	62	#include <sys/param.h>
	63	#include <sys/socket.h>
	64	#include <sys/protosw.h>
	65	#include <sys/domain.h>
	66	#include <sys/mbuf.h>
	67	#include <sys/time.h>
	68	#include <sys/kernel.h>
	69	#include <sys/systm.h>
	70	#include <sys/proc.h>
	71	#include <sys/sysctl.h>
	72	#include <sys/syslog.h>
	73	#include <sys/queue.h>
	74
	75	void pffasttimo __P((void *));
	76	void pfslowtimo __P((void *));
	77
	78	/*
	79	* Add/delete 'domain': Link structure into system list,
	80	* invoke the domain init, and then the proto inits.
	81	* To delete, just remove from the list (dom_refs must be zero)
	82	*/
	83
	84
	85	void init_domain(register struct domain *dp)
86	{
87	struct protosw *pr;
88
89	if (dp->dom_init)
90	(*dp->dom_init)();
91
92	/* and then init the currently installed protos in this domain */
93
94	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
95	if (pr->pr_usrreqs == 0)
96	panic("domaininit: %ssw[%d] has no usrreqs!",
97	dp->dom_name,
98	(int)(pr - dp->dom_protosw));
99
100	if (pr->pr_init)
101	(*pr->pr_init)();
102	}
103
104	/* Recompute for new protocol */
105	if (max_linkhdr < 16) /* XXX - Sheesh; everything's ether? */
106	max_linkhdr = 16;
107	if (dp->dom_protohdrlen > max_protohdr)
108	max_protohdr = dp->dom_protohdrlen;
109	max_hdr = max_linkhdr + max_protohdr;
110	max_datalen = MHLEN - max_hdr;
111	}
112
113	void concat_domain(struct domain *dp)
114	{
115	dp->dom_next = domains;
116	domains = dp;
117	}
118
119	void
120	net_add_domain(register struct domain *dp)
121	{ register struct protosw *pr;
122	register int s;
123	extern int splhigh(void);
124	extern int splx(int);
125
126	kprintf("Adding domain %s (family %d)\n", dp->dom_name,
127	dp->dom_family);
128	/* First, link in the domain */
129	s = splhigh();
130
131	concat_domain(dp);
132
133	init_domain(dp);
134
135	splx(s);
136	}
137
138	int
139	net_del_domain(register struct domain *dp)
140	{ register struct domain dp1, dp2;
141	register int s, retval = 0;
142	extern int splhigh(void);
143	extern int splx(int);
144
145	if (dp->dom_refs)
146	return(EBUSY);
147
148	s = splhigh();
149
150	for (dp2 = NULL, dp1 = domains; dp1; dp2 = dp1, dp1 = dp1->dom_next)
151	{ if (dp == dp1)
152	break;
153	}
154	if (dp1)
155	{ if (dp2)
156	dp2->dom_next = dp1->dom_next;
157	else
158	domains = dp1->dom_next;
159	} else
160	retval = EPFNOSUPPORT;
161	splx(s);
162
163	return(retval);
164	}
165
166	/*
167	* net_add_proto - link a protosw into a domain's protosw chain
168	*/
169	int
170	net_add_proto(register struct protosw *pp,
171	register struct domain *dp)
172	{ register struct protosw pp1, pp2;
173	register int s;
174	extern int splhigh(void);
175	extern int splx(int);
176
177	s = splhigh();
178	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
179	{ if (pp1->pr_type == pp->pr_type &&
180	pp1->pr_protocol == pp->pr_protocol) {
181	splx(s);
182	return(EEXIST);
183	}
184	pp2 = pp1;
185	}
186	if (pp2 == NULL)
187	dp->dom_protosw = pp;
188	else
189	pp2->pr_next = pp;
190	pp->pr_next = NULL;
191	TAILQ_INIT(&pp->pr_sfilter);
192	if (pp->pr_init)
193	(*pp->pr_init)();
194
195	/* Make sure pr_init isn't called again!! */
196	pp->pr_init = 0;
197	splx(s);
198	return(0);
199	}
200
201	/*
202	* net_del_proto - remove a protosw from a domain's protosw chain.
203	* Search the protosw chain for the element with matching data.
204	* Then unlink and return.
205	*/
206	int
207	net_del_proto(register int type,
208	register int protocol,
209	register struct domain *dp)
210	{ register struct protosw pp1, pp2;
211	int s;
212	extern int splhigh(void);
213	extern int splx(int);
214
215	s = splhigh();
216	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
217	{ if (pp1->pr_type == type &&
218	pp1->pr_protocol == protocol)
219	break;
220	pp2 = pp1;
221	}
222	if (pp1 == NULL) {
223	splx(s);
224	return(ENXIO);
225	}
226	if (pp2)
227	pp2->pr_next = pp1->pr_next;
228	else
229	dp->dom_protosw = pp1->pr_next;
230	splx(s);
231	return(0);
232	}
233
234
235	void
236	domaininit()
237	{ register struct domain *dp;
238	register struct protosw *pr;
239	extern struct domain localdomain, routedomain, ndrvdomain, inetdomain;
240	extern struct domain systemdomain;
241	#if NS
242	extern struct domain nsdomain;
243	#endif
244	#if ISO
245	extern struct domain isodomain;
246	#endif
247	#if CCITT
248	extern struct domain ccittdomain;
249	#endif
250
251	#if NETAT
252	extern struct domain atalkdomain;
253	#endif
254	#if INET6
255	extern struct domain inet6domain;
256	#endif
257	#if IPSEC
258	extern struct domain keydomain;
259	#endif
260
261	/*
262	* Add all the static domains to the domains list
263	*/
264
265	thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
266	concat_domain(&localdomain);
267	concat_domain(&routedomain);
268	concat_domain(&inetdomain);
269	#if NETAT
270	concat_domain(&atalkdomain);
271	#endif
272	#if INET6
273	concat_domain(&inet6domain);
274	#endif
275	#if IPSEC
276	concat_domain(&keydomain);
277	#endif
278
279	#if NS
280	concat_domain(&nsdomain);
281	#endif
282	#if ISO
283	concat_domain(&isodomain);
284	#endif
285	#if CCITT
286	concat_domain(&ccittdomain);
287	#endif
288	concat_domain(&ndrvdomain);
289
290	concat_domain(&systemdomain);
291
292	/*
293	* Now ask them all to init (XXX including the routing domain,
294	* see above)
295	*/
296	for (dp = domains; dp; dp = dp->dom_next)
297	init_domain(dp);
298
299	timeout(pffasttimo, NULL, 1);
300	timeout(pfslowtimo, NULL, 1);
301	thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
302	}
303
304	struct protosw *
305	pffindtype(family, type)
306	int family, type;
307	{
308	register struct domain *dp;
309	register struct protosw *pr;
310
311	for (dp = domains; dp; dp = dp->dom_next)
312	if (dp->dom_family == family)
313	goto found;
314	return (0);
315	found:
316	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
317	if (pr->pr_type && pr->pr_type == type)
318	return (pr);
319	return (0);
320	}
321
322	struct domain *
323	pffinddomain(int pf)
324	{ struct domain *dp;
325
326	dp = domains;
327	while (dp)
328	{ if (dp->dom_family == pf)
329	return(dp);
330	dp = dp->dom_next;
331	}
332	return(NULL);
333	}
334
335	struct protosw *
336	pffindproto(family, protocol, type)
337	int family, protocol, type;
338	{
339	register struct domain *dp;
340	register struct protosw *pr;
341	struct protosw *maybe = 0;
342
343	if (family == 0)
344	return (0);
345	for (dp = domains; dp; dp = dp->dom_next)
346	if (dp->dom_family == family)
347	goto found;
348	return (0);
349	found:
350	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
351	if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
352	return (pr);
353
354	if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
355	pr->pr_protocol == 0 && maybe == (struct protosw *)0)
356	maybe = pr;
357	}
358	return (maybe);
359	}
360
361	int
362	net_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
363	int *name;
364	u_int namelen;
365	void *oldp;
366	size_t *oldlenp;
367	void *newp;
368	size_t newlen;
369	struct proc *p;
370	{
371	register struct domain *dp;
372	register struct protosw *pr;
373	int family, protocol;
374
375	/*
376	* All sysctl names at this level are nonterminal;
377	* next two components are protocol family and protocol number,
378	* then at least one addition component.
379	*/
380	if (namelen < 3)
381	return (EISDIR); /* overloaded */
382	family = name[0];
383	protocol = name[1];
384
385	if (family == 0)
386	return (0);
387	for (dp = domains; dp; dp = dp->dom_next)
388	if (dp->dom_family == family)
389	goto found;
390	return (ENOPROTOOPT);
391	found:
392	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
393	if (pr->pr_protocol == protocol && pr->pr_sysctl)
394	return ((*pr->pr_sysctl)(name + 2, namelen - 2,
395	oldp, oldlenp, newp, newlen));
396	return (ENOPROTOOPT);
397	}
398
399	void
400	pfctlinput(cmd, sa)
401	int cmd;
402	struct sockaddr *sa;
403	{
9bccf70c A	404	pfctlinput2(cmd, sa, (void*)0);
	405	}
	406
	407	void
	408	pfctlinput2(cmd, sa, ctlparam)
	409	int cmd;
	410	struct sockaddr *sa;
	411	void *ctlparam;
	412	{
	413	struct domain *dp;
	414	struct protosw *pr;
1c79356b	415
9bccf70c A	416	if (!sa)
9bccf70c A	417	return;
1c79356b A	418	for (dp = domains; dp; dp = dp->dom_next)
	419	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
	420	if (pr->pr_ctlinput)
9bccf70c	421	(*pr->pr_ctlinput)(cmd, sa, ctlparam);
1c79356b A	422	}
	423
	424	void
	425	pfslowtimo(arg)
	426	void *arg;
	427	{
	428	register struct domain *dp;
	429	register struct protosw *pr;
	430	boolean_t funnel_state;
	431
	432	funnel_state = thread_funnel_set(network_flock, TRUE);
	433
	434	for (dp = domains; dp; dp = dp->dom_next)
	435	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
	436	if (pr->pr_slowtimo)
	437	(*pr->pr_slowtimo)();
	438	timeout(pfslowtimo, NULL, hz/2);
	439
	440	(void) thread_funnel_set(network_flock, FALSE);
	441	}
	442
	443	void
	444	pffasttimo(arg)
	445	void *arg;
	446	{
	447	register struct domain *dp;
	448	register struct protosw *pr;
	449	boolean_t funnel_state;
	450
	451	funnel_state = thread_funnel_set(network_flock, TRUE);
	452
	453	for (dp = domains; dp; dp = dp->dom_next)
	454	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
	455	if (pr->pr_fasttimo)
	456	(*pr->pr_fasttimo)();
	457	timeout(pffasttimo, NULL, hz/5);
	458
	459	(void) thread_funnel_set(network_flock, FALSE);
	460	}