![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_domain.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to uipc_domain.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
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.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
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.
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>
67: #include <sys/proc.h>
68: #include <sys/sysctl.h>
69: #include <sys/syslog.h>
70: #include <sys/queue.h>
71:
72: void pffasttimo __P((void *));
73: void pfslowtimo __P((void *));
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:
81:
82: void init_domain(register struct domain *dp)
83: {
84: struct protosw *pr;
85:
86: if (dp->dom_init)
87: (*dp->dom_init)();
88:
89: /* and then init the currently installed protos in this domain */
90:
91: for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
92: if (pr->pr_usrreqs == 0)
93: panic("domaininit: %ssw[%d] has no usrreqs!",
94: dp->dom_name,
95: (int)(pr - dp->dom_protosw));
96:
97: if (pr->pr_init)
98: (*pr->pr_init)();
99: }
100:
101: /* Recompute for new protocol */
102: if (max_linkhdr < 16) /* XXX - Sheesh; everything's ether? */
103: max_linkhdr = 16;
104: if (dp->dom_protohdrlen > max_protohdr)
105: max_protohdr = dp->dom_protohdrlen;
106: max_hdr = max_linkhdr + max_protohdr;
107: max_datalen = MHLEN - max_hdr;
108: }
109:
110: void concat_domain(struct domain *dp)
111: {
112: dp->dom_next = domains;
113: domains = dp;
114: }
115:
116: void
117: net_add_domain(register struct domain *dp)
118: { register struct protosw *pr;
119: register int s;
120: extern int splhigh(void);
121: extern int splx(int);
122:
123: kprintf("Adding domain %s (family %d)\n", dp->dom_name,
124: dp->dom_family);
125: /* First, link in the domain */
126: s = splhigh();
127:
128: concat_domain(dp);
129:
130: init_domain(dp);
131:
132: splx(s);
133: }
134:
135: int
136: net_del_domain(register struct domain *dp)
137: { register struct domain *dp1, *dp2;
138: register int s, retval = 0;
139: extern int splhigh(void);
140: extern int splx(int);
141:
142: if (dp->dom_refs)
143: return(EBUSY);
144:
145: s = splhigh();
146:
147: for (dp2 = NULL, dp1 = domains; dp1; dp2 = dp1, dp1 = dp1->dom_next)
148: { if (dp == dp1)
149: break;
150: }
151: if (dp1)
152: { if (dp2)
153: dp2->dom_next = dp1->dom_next;
154: else
155: domains = dp1->dom_next;
156: } else
157: retval = EPFNOSUPPORT;
158: splx(s);
159:
160: return(retval);
161: }
162:
163: /*
164: * net_add_proto - link a protosw into a domain's protosw chain
165: */
166: int
167: net_add_proto(register struct protosw *pp,
168: register struct domain *dp)
169: { register struct protosw *pp1, *pp2;
170: register int s;
171: extern int splhigh(void);
172: extern int splx(int);
173:
174: s = splhigh();
175: for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
176: { if (pp1->pr_type == pp->pr_type &&
177: pp1->pr_protocol == pp->pr_protocol)
178: return(EEXIST);
179: pp2 = pp1;
180: }
181: if (pp2 == NULL)
182: dp->dom_protosw = pp;
183: else
184: pp2->pr_next = pp;
185: pp->pr_next = NULL;
186: TAILQ_INIT(&pp->pr_sfilter);
187: if (pp->pr_init)
188: (*pp->pr_init)();
189:
190: /* Make sure pr_init isn't called again!! */
191: pp->pr_init = 0;
192: splx(s);
193: return(0);
194: }
195:
196: /*
197: * net_del_proto - remove a protosw from a domain's protosw chain.
198: * Search the protosw chain for the element with matching data.
199: * Then unlink and return.
200: */
201: int
202: net_del_proto(register int type,
203: register int protocol,
204: register struct domain *dp)
205: { register struct protosw *pp1, *pp2;
206: int s;
207: extern int splhigh(void);
208: extern int splx(int);
209:
210: s = splhigh();
211: for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
212: { if (pp1->pr_type == type &&
213: pp1->pr_protocol == protocol)
214: break;
215: pp2 = pp1;
216: }
217: if (pp1 == NULL)
218: return(ENXIO);
219: if (pp2)
220: pp2->pr_next = pp1->pr_next;
221: else
222: dp->dom_protosw = pp1->pr_next;
223: splx(s);
224: return(0);
225: }
226:
227:
228: void
229: domaininit()
230: { register struct domain *dp;
231: register struct protosw *pr;
232: extern struct domain localdomain, routedomain, ndrvdomain, inetdomain;
233: #if NS
234: extern struct domain nsdomain;
235: #endif
236: #if ISO
237: extern struct domain isodomain;
238: #endif
239: #if CCITT
240: extern struct domain ccittdomain;
241: #endif
242:
243: #if NETAT
244: extern struct domain atalkdomain;
245: #endif
246:
247: /*
248: * Add all the static domains to the domains list
249: */
250:
251: concat_domain(&localdomain);
252: concat_domain(&routedomain);
253: concat_domain(&inetdomain);
254: #if NETAT
255: concat_domain(&atalkdomain);
256: #endif
257:
258: #if NS
259: concat_domain(&nsdomain);
260: #endif
261: #if ISO
262: concat_domain(&isodomain);
263: #endif
264: #if CCITT
265: concat_domain(&ccittdomain);
266: #endif
267: concat_domain(&ndrvdomain);
268:
269: /*
270: * Now ask them all to init (XXX including the routing domain,
271: * see above)
272: */
273: for (dp = domains; dp; dp = dp->dom_next)
274: init_domain(dp);
275:
276: timeout(pffasttimo, NULL, 1);
277: timeout(pfslowtimo, NULL, 1);
278: }
279:
280: struct protosw *
281: pffindtype(family, type)
282: int family, type;
283: {
284: register struct domain *dp;
285: register struct protosw *pr;
286:
287: for (dp = domains; dp; dp = dp->dom_next)
288: if (dp->dom_family == family)
289: goto found;
290: return (0);
291: found:
292: for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
293: if (pr->pr_type && pr->pr_type == type)
294: return (pr);
295: return (0);
296: }
297:
298: struct domain *
299: pffinddomain(int pf)
300: { struct domain *dp;
301:
302: dp = domains;
303: while (dp)
304: { if (dp->dom_family == pf)
305: return(dp);
306: dp = dp->dom_next;
307: }
308: return(NULL);
309: }
310:
311: struct protosw *
312: pffindproto(family, protocol, type)
313: int family, protocol, type;
314: {
315: register struct domain *dp;
316: register struct protosw *pr;
317: struct protosw *maybe = 0;
318:
319: if (family == 0)
320: return (0);
321: for (dp = domains; dp; dp = dp->dom_next)
322: if (dp->dom_family == family)
323: goto found;
324: return (0);
325: found:
326: for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
327: if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
328: return (pr);
329:
330: if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
331: pr->pr_protocol == 0 && maybe == (struct protosw *)0)
332: maybe = pr;
333: }
334: return (maybe);
335: }
336:
337: int
338: net_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
339: int *name;
340: u_int namelen;
341: void *oldp;
342: size_t *oldlenp;
343: void *newp;
344: size_t newlen;
345: struct proc *p;
346: {
347: register struct domain *dp;
348: register struct protosw *pr;
349: int family, protocol;
350:
351: /*
352: * All sysctl names at this level are nonterminal;
353: * next two components are protocol family and protocol number,
354: * then at least one addition component.
355: */
356: if (namelen < 3)
357: return (EISDIR); /* overloaded */
358: family = name[0];
359: protocol = name[1];
360:
361: if (family == 0)
362: return (0);
363: for (dp = domains; dp; dp = dp->dom_next)
364: if (dp->dom_family == family)
365: goto found;
366: return (ENOPROTOOPT);
367: found:
368: for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
369: if (pr->pr_protocol == protocol && pr->pr_sysctl)
370: return ((*pr->pr_sysctl)(name + 2, namelen - 2,
371: oldp, oldlenp, newp, newlen));
372: return (ENOPROTOOPT);
373: }
374:
375: void
376: pfctlinput(cmd, sa)
377: int cmd;
378: struct sockaddr *sa;
379: {
380: register struct domain *dp;
381: register struct protosw *pr;
382:
383: for (dp = domains; dp; dp = dp->dom_next)
384: for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
385: if (pr->pr_ctlinput)
386: (*pr->pr_ctlinput)(cmd, sa, (caddr_t)0);
387: }
388:
389: void
390: pfslowtimo(arg)
391: void *arg;
392: {
393: register struct domain *dp;
394: register struct protosw *pr;
395:
396: for (dp = domains; dp; dp = dp->dom_next)
397: for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
398: if (pr->pr_slowtimo)
399: (*pr->pr_slowtimo)();
400: timeout(pfslowtimo, NULL, hz/2);
401: }
402:
403: void
404: pffasttimo(arg)
405: void *arg;
406: {
407: register struct domain *dp;
408: register struct protosw *pr;
409:
410: for (dp = domains; dp; dp = dp->dom_next)
411: for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
412: if (pr->pr_fasttimo)
413: (*pr->pr_fasttimo)();
414: timeout(pffasttimo, NULL, hz/5);
415: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.