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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 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_internal.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/queue.h>

void	pffasttimo(void *);
void	pfslowtimo(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)
 */

lck_grp_t		*domain_proto_mtx_grp;
lck_attr_t	*domain_proto_mtx_attr;
static lck_grp_attr_t	*domain_proto_mtx_grp_attr;
lck_mtx_t		*domain_proto_mtx;
extern int		do_reclaim;

void init_domain(register struct domain *dp)
{
	struct protosw  *pr;
	
	if ((dp->dom_mtx = lck_mtx_alloc_init(domain_proto_mtx_grp, domain_proto_mtx_attr)) == NULL) {
		printf("init_domain: can't init domain mtx for domain=%s\n", dp->dom_name);
		return;	/* we have a problem... */
	}

	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) 
{
	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_OWNED);
	dp->dom_next = domains; 
	domains = dp; 
}

void
net_add_domain(register struct domain *dp)
{	register struct protosw *pr;

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

	lck_mtx_lock(domain_proto_mtx);
	concat_domain(dp);

	init_domain(dp);
	lck_mtx_unlock(domain_proto_mtx);

}

int
net_del_domain(register struct domain *dp)
{	register struct domain *dp1, *dp2;
	register int retval = 0;

	lck_mtx_lock(domain_proto_mtx);
 
	if (dp->dom_refs) {
		lck_mtx_unlock(domain_proto_mtx);
		return(EBUSY);
     }

	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;
	lck_mtx_unlock(domain_proto_mtx);

	return(retval);
}

/*
 * net_add_proto - link a protosw into a domain's protosw chain
 * 
 * note: protocols must use their own domain lock before calling net_add_proto
 */
int
net_add_proto(register struct protosw *pp,
	      register struct domain *dp)
{	register struct protosw *pp1, *pp2;

	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) {
			return(EEXIST);
		}
		pp2 = pp1;
	}
	if (pp2 == NULL)
		dp->dom_protosw = pp;
	else
		pp2->pr_next = pp;
	pp->pr_next = NULL;
	TAILQ_INIT(&pp->pr_filter_head);
	if (pp->pr_init)
		(*pp->pr_init)();

	/* Make sure pr_init isn't called again!! */
	pp->pr_init = 0;
	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.
 *
 * note: protocols must use their own domain lock before calling net_del_proto
 */
int
net_del_proto(register int type,
	      register int protocol,
	      register struct domain *dp)
{	register struct protosw *pp1, *pp2;

	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) {
			return(ENXIO);
		}
	if (pp2)
		pp2->pr_next = pp1->pr_next;
	else
		dp->dom_protosw = pp1->pr_next;
	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

	/*
	 * allocate lock group attribute and group for domain mutexes
	 */
	domain_proto_mtx_grp_attr = lck_grp_attr_alloc_init();
	lck_grp_attr_setdefault(domain_proto_mtx_grp_attr);

	domain_proto_mtx_grp = lck_grp_alloc_init("domain", domain_proto_mtx_grp_attr);
		
	/*
	 * allocate the lock attribute for per domain mutexes
	 */
	domain_proto_mtx_attr = lck_attr_alloc_init();
	lck_attr_setdefault(domain_proto_mtx_attr);

	if ((domain_proto_mtx = lck_mtx_alloc_init(domain_proto_mtx_grp, domain_proto_mtx_attr)) == NULL) {
		printf("domaininit: can't init domain mtx for domain list\n");
		return;	/* we have a problem... */
	}
	/*
	 * Add all the static domains to the domains list
	 */

	lck_mtx_lock(domain_proto_mtx);

	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);

	lck_mtx_unlock(domain_proto_mtx);
	timeout(pffasttimo, NULL, 1);
	timeout(pfslowtimo, NULL, 1);
}

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

	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(domain_proto_mtx);
	for (dp = domains; dp; dp = dp->dom_next)
		if (dp->dom_family == family)
			goto found;
	lck_mtx_unlock(domain_proto_mtx);
	return (0);
found:
	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
		if (pr->pr_type && pr->pr_type == type) {
			lck_mtx_unlock(domain_proto_mtx);
			return (pr);
		}
	lck_mtx_unlock(domain_proto_mtx);
	return (0);
}

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

	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(domain_proto_mtx);
	dp = domains;
	while (dp)
	{	if (dp->dom_family == pf) {
			lck_mtx_unlock(domain_proto_mtx);
			return(dp);
		}
		dp = dp->dom_next;
	}
	lck_mtx_unlock(domain_proto_mtx);
	return(NULL);
}

struct protosw *
pffindproto(family, protocol, type)
	int family, protocol, type;
{
	register struct protosw *pr;
	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(domain_proto_mtx);
	pr = pffindproto_locked(family, protocol, type);
	lck_mtx_unlock(domain_proto_mtx);
	return (pr);
}

struct protosw *
pffindproto_locked(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(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
           user_addr_t newp, size_t newlen, struct proc *p)
{
	register struct domain *dp;
	register struct protosw *pr;
	int family, protocol, error;

	/*
	 * 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);
	lck_mtx_lock(domain_proto_mtx);
	for (dp = domains; dp; dp = dp->dom_next)
		if (dp->dom_family == family)
			goto found;
	lck_mtx_unlock(domain_proto_mtx);
	return (ENOPROTOOPT);
found:
	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
		if (pr->pr_protocol == protocol && pr->pr_sysctl) {
			error = (*pr->pr_sysctl)(name + 2, namelen - 2,
			    oldp, oldlenp, newp, newlen);
			lck_mtx_unlock(domain_proto_mtx);
			return (error);
		}
	lck_mtx_unlock(domain_proto_mtx);
	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;

	lck_mtx_lock(domain_proto_mtx);
	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);
	lck_mtx_unlock(domain_proto_mtx);
}

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

	lck_mtx_lock(domain_proto_mtx);
	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)();
			if (do_reclaim && pr->pr_drain)
				(*pr->pr_drain)();
		}
	do_reclaim = 0;
	lck_mtx_unlock(domain_proto_mtx);
	timeout(pfslowtimo, NULL, hz/2);
        
}

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

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