![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raw_ip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to raw_ip.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1988, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)raw_ip.c 8.7 (Berkeley) 5/15/95
59: */
60:
61: #include <sys/param.h>
62: #include <sys/malloc.h>
63: #include <sys/mbuf.h>
64: #include <sys/socket.h>
65: #include <sys/protosw.h>
66: #include <sys/socketvar.h>
67: #include <sys/errno.h>
68: #include <sys/systm.h>
69:
70: #include <net/if.h>
71: #include <net/route.h>
72:
73: #include <netinet/in.h>
74: #include <netinet/in_systm.h>
75: #include <netinet/ip.h>
76: #include <netinet/ip_var.h>
77: #include <netinet/ip_mroute.h>
78: #include <netinet/in_pcb.h>
79:
80: struct inpcb rawinpcb;
81:
82: /*
83: * Nominal space allocated to a raw ip socket.
84: */
85: #define RIPSNDQ 8192
86: #define RIPRCVQ 8192
87:
88: /*
89: * Raw interface to IP protocol.
90: */
91:
92: /*
93: * Initialize raw connection block q.
94: */
95: void
96: rip_init()
97: {
98:
99: rawinpcb.inp_next = rawinpcb.inp_prev = &rawinpcb;
100: }
101:
102: struct sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET };
103: /*
104: * Setup generic address and protocol structures
105: * for raw_input routine, then pass them along with
106: * mbuf chain.
107: */
108: void
109: rip_input(m)
110: struct mbuf *m;
111: {
112: register struct ip *ip = mtod(m, struct ip *);
113: register struct inpcb *inp;
114: struct socket *last = 0;
115:
116: ripsrc.sin_addr = ip->ip_src;
117: for (inp = rawinpcb.inp_next; inp != &rawinpcb; inp = inp->inp_next) {
118: if (inp->inp_ip.ip_p && inp->inp_ip.ip_p != ip->ip_p)
119: continue;
120: if (inp->inp_laddr.s_addr &&
121: inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
122: continue;
123: if (inp->inp_faddr.s_addr &&
124: inp->inp_faddr.s_addr != ip->ip_src.s_addr)
125: continue;
126: if (last) {
127: struct mbuf *n;
128: if (n = m_copy(m, 0, (int)M_COPYALL)) {
129: if (sbappendaddr(&last->so_rcv,
130: (struct sockaddr *)&ripsrc, n,
131: (struct mbuf *)0) == 0)
132: /* should notify about lost packet */
133: m_freem(n);
134: else
135: sorwakeup(last);
136: }
137: }
138: last = inp->inp_socket;
139: }
140: if (last) {
141: if (sbappendaddr(&last->so_rcv, (struct sockaddr *)&ripsrc,
142: m, (struct mbuf *)0) == 0)
143: m_freem(m);
144: else
145: sorwakeup(last);
146: } else {
147: m_freem(m);
148: ipstat.ips_noproto++;
149: ipstat.ips_delivered--;
150: }
151: }
152:
153: /*
154: * Generate IP header and pass packet to ip_output.
155: * Tack on options user may have setup with control call.
156: */
157: int
158: rip_output(m, so, dst)
159: register struct mbuf *m;
160: struct socket *so;
161: u_long dst;
162: {
163: register struct ip *ip;
164: register struct inpcb *inp = sotoinpcb(so);
165: struct mbuf *opts;
166: int flags = (so->so_options & SO_DONTROUTE) | IP_ALLOWBROADCAST;
167:
168: /*
169: * If the user handed us a complete IP packet, use it.
170: * Otherwise, allocate an mbuf for a header and fill it in.
171: */
172: if ((inp->inp_flags & INP_HDRINCL) == 0) {
173: M_PREPEND(m, sizeof(struct ip), M_WAIT);
174: ip = mtod(m, struct ip *);
175: ip->ip_tos = 0;
176: ip->ip_off = 0;
177: ip->ip_p = inp->inp_ip.ip_p;
178: ip->ip_len = m->m_pkthdr.len;
179: ip->ip_src = inp->inp_laddr;
180: ip->ip_dst.s_addr = dst;
181: ip->ip_ttl = MAXTTL;
182: opts = inp->inp_options;
183: } else {
184: ip = mtod(m, struct ip *);
185: if (ip->ip_id == 0)
186: ip->ip_id = htons(ip_id++);
187: opts = NULL;
188: /* XXX prevent ip_output from overwriting header fields */
189: flags |= IP_RAWOUTPUT;
190: ipstat.ips_rawout++;
191: }
192: return (ip_output(m, opts, &inp->inp_route, flags, inp->inp_moptions));
193: }
194:
195: /*
196: * Raw IP socket option processing.
197: */
198: int
199: rip_ctloutput(op, so, level, optname, m)
200: int op;
201: struct socket *so;
202: int level, optname;
203: struct mbuf **m;
204: {
205: register struct inpcb *inp = sotoinpcb(so);
206: register int error;
207:
208: if (level != IPPROTO_IP) {
209: if (op == PRCO_SETOPT && *m)
210: (void) m_free(*m);
211: return (EINVAL);
212: }
213:
214: switch (optname) {
215:
216: case IP_HDRINCL:
217: error = 0;
218: if (op == PRCO_SETOPT) {
219: if (*m == 0 || (*m)->m_len < sizeof (int))
220: error = EINVAL;
221: else if (*mtod(*m, int *))
222: inp->inp_flags |= INP_HDRINCL;
223: else
224: inp->inp_flags &= ~INP_HDRINCL;
225: if (*m)
226: (void)m_free(*m);
227: } else {
228: *m = m_get(M_WAIT, MT_SOOPTS);
229: (*m)->m_len = sizeof (int);
230: *mtod(*m, int *) = inp->inp_flags & INP_HDRINCL;
231: }
232: return (error);
233:
234: case DVMRP_INIT:
235: case DVMRP_DONE:
236: case DVMRP_ADD_VIF:
237: case DVMRP_DEL_VIF:
238: case DVMRP_ADD_LGRP:
239: case DVMRP_DEL_LGRP:
240: case DVMRP_ADD_MRT:
241: case DVMRP_DEL_MRT:
242: #if MROUTING
243: if (op == PRCO_SETOPT) {
244: error = ip_mrouter_cmd(optname, so, *m);
245: if (*m)
246: (void)m_free(*m);
247: } else
248: error = EINVAL;
249: return (error);
250: #else
251: if (op == PRCO_SETOPT && *m)
252: (void)m_free(*m);
253: return (EOPNOTSUPP);
254: #endif
255:
256: default:
257: if (optname >= DVMRP_INIT) {
258: #if MROUTING
259: if (op == PRCO_SETOPT) {
260: error = ip_mrouter_cmd(optname, so, *m);
261: if (*m)
262: (void)m_free(*m);
263: } else
264: error = EINVAL;
265: return (error);
266: #else
267: if (op == PRCO_SETOPT && *m)
268: (void)m_free(*m);
269: return (EOPNOTSUPP);
270: #endif
271: }
272:
273: }
274: return (ip_ctloutput(op, so, level, optname, m));
275: }
276:
277: u_long rip_sendspace = RIPSNDQ;
278: u_long rip_recvspace = RIPRCVQ;
279:
280: /*ARGSUSED*/
281: int
282: rip_usrreq(so, req, m, nam, control)
283: register struct socket *so;
284: int req;
285: struct mbuf *m, *nam, *control;
286: {
287: register int error = 0;
288: register struct inpcb *inp = sotoinpcb(so);
289: #if MROUTING
290: extern struct socket *ip_mrouter;
291: #endif
292: switch (req) {
293:
294: case PRU_ATTACH:
295: if (inp)
296: panic("rip_attach");
297: if ((so->so_state & SS_PRIV) == 0) {
298: error = EACCES;
299: break;
300: }
301: if ((error = soreserve(so, rip_sendspace, rip_recvspace)) ||
302: (error = in_pcballoc(so, &rawinpcb, 0, 0)))
303: break;
304: inp = (struct inpcb *)so->so_pcb;
305: inp->inp_ip.ip_p = (int)nam;
306: break;
307:
308: case PRU_DISCONNECT:
309: if ((so->so_state & SS_ISCONNECTED) == 0) {
310: error = ENOTCONN;
311: break;
312: }
313: /* FALLTHROUGH */
314: case PRU_ABORT:
315: soisdisconnected(so);
316: /* FALLTHROUGH */
317: case PRU_DETACH:
318: if (inp == 0)
319: panic("rip_detach");
320: #if MROUTING
321: if (so == ip_mrouter)
322: ip_mrouter_done();
323: #endif
324: in_pcbdetach(inp);
325: break;
326:
327: case PRU_BIND:
328: {
329: struct sockaddr_in *addr = mtod(nam, struct sockaddr_in *);
330:
331: if (nam->m_len != sizeof(*addr)) {
332: error = EINVAL;
333: break;
334: }
335: if ((ifnet == 0) ||
336: ((addr->sin_family != AF_INET) &&
337: (addr->sin_family != AF_IMPLINK)) ||
338: (addr->sin_addr.s_addr &&
339: ifa_ifwithaddr((struct sockaddr *)addr) == 0)) {
340: error = EADDRNOTAVAIL;
341: break;
342: }
343: inp->inp_laddr = addr->sin_addr;
344: break;
345: }
346: case PRU_CONNECT:
347: {
348: struct sockaddr_in *addr = mtod(nam, struct sockaddr_in *);
349:
350: if (nam->m_len != sizeof(*addr)) {
351: error = EINVAL;
352: break;
353: }
354: if (ifnet == 0) {
355: error = EADDRNOTAVAIL;
356: break;
357: }
358: if ((addr->sin_family != AF_INET) &&
359: (addr->sin_family != AF_IMPLINK)) {
360: error = EAFNOSUPPORT;
361: break;
362: }
363: inp->inp_faddr = addr->sin_addr;
364: soisconnected(so);
365: break;
366: }
367:
368: case PRU_CONNECT2:
369: error = EOPNOTSUPP;
370: break;
371:
372: /*
373: * Mark the connection as being incapable of further input.
374: */
375: case PRU_SHUTDOWN:
376: socantsendmore(so);
377: break;
378:
379: /*
380: * Ship a packet out. The appropriate raw output
381: * routine handles any massaging necessary.
382: */
383: case PRU_SEND:
384: {
385: register u_long dst;
386:
387: if (so->so_state & SS_ISCONNECTED) {
388: if (nam) {
389: error = EISCONN;
390: break;
391: }
392: dst = inp->inp_faddr.s_addr;
393: } else {
394: if (nam == NULL) {
395: error = ENOTCONN;
396: break;
397: }
398: dst = mtod(nam, struct sockaddr_in *)->sin_addr.s_addr;
399: }
400: error = rip_output(m, so, dst);
401: m = NULL;
402: break;
403: }
404:
405: case PRU_SENSE:
406: /*
407: * stat: don't bother with a blocksize.
408: */
409: return (0);
410:
411: /*
412: * Not supported.
413: */
414: case PRU_RCVOOB:
415: case PRU_RCVD:
416: case PRU_LISTEN:
417: case PRU_ACCEPT:
418: case PRU_SENDOOB:
419: error = EOPNOTSUPP;
420: break;
421:
422: case PRU_SOCKADDR:
423: in_setsockaddr(inp, nam);
424: break;
425:
426: case PRU_PEERADDR:
427: in_setpeeraddr(inp, nam);
428: break;
429:
430: default:
431: panic("rip_usrreq");
432: }
433: if (m != NULL)
434: m_freem(m);
435: return (error);
436: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.