![[BACK]](/icons/back.gif){kind=icon}
Return to raw_usrreq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net|
Return to raw_usrreq.c CVS log | Up to [local] / sys / net |
1.1 nbrk 1: /* $OpenBSD: raw_usrreq.c,v 1.10 2004/01/03 14:08:53 espie Exp $ */
2: /* $NetBSD: raw_usrreq.c,v 1.11 1996/02/13 22:00:43 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1980, 1986, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)raw_usrreq.c 8.1 (Berkeley) 6/10/93
33: */
34:
35: #include <sys/param.h>
36: #include <sys/mbuf.h>
37: #include <sys/domain.h>
38: #include <sys/protosw.h>
39: #include <sys/socket.h>
40: #include <sys/socketvar.h>
41: #include <sys/errno.h>
42: #include <sys/systm.h>
43:
44: #include <net/if.h>
45: #include <net/route.h>
46: #include <net/netisr.h>
47: #include <net/raw_cb.h>
48:
49: #include <sys/stdarg.h>
50: /*
51: * Initialize raw connection block q.
52: */
53: void
54: raw_init()
55: {
56:
57: LIST_INIT(&rawcb);
58: }
59:
60:
61: /*
62: * Raw protocol input routine. Find the socket
63: * associated with the packet(s) and move them over. If
64: * nothing exists for this packet, drop it.
65: */
66: /*
67: * Raw protocol interface.
68: */
69: void
70: raw_input(struct mbuf *m0, ...)
71: {
72: struct rawcb *rp;
73: struct mbuf *m = m0;
74: int sockets = 0;
75: struct socket *last;
76: va_list ap;
77: struct sockproto *proto;
78: struct sockaddr *src, *dst;
79:
80: va_start(ap, m0);
81: proto = va_arg(ap, struct sockproto *);
82: src = va_arg(ap, struct sockaddr *);
83: dst = va_arg(ap, struct sockaddr *);
84: va_end(ap);
85:
86: last = 0;
87: LIST_FOREACH(rp, &rawcb, rcb_list) {
88: if (rp->rcb_proto.sp_family != proto->sp_family)
89: continue;
90: if (rp->rcb_proto.sp_protocol &&
91: rp->rcb_proto.sp_protocol != proto->sp_protocol)
92: continue;
93: /*
94: * We assume the lower level routines have
95: * placed the address in a canonical format
96: * suitable for a structure comparison.
97: *
98: * Note that if the lengths are not the same
99: * the comparison will fail at the first byte.
100: */
101: #define equal(a1, a2) \
102: (bcmp((caddr_t)(a1), (caddr_t)(a2), a1->sa_len) == 0)
103: if (rp->rcb_laddr && !equal(rp->rcb_laddr, dst))
104: continue;
105: if (rp->rcb_faddr && !equal(rp->rcb_faddr, src))
106: continue;
107: if (last) {
108: struct mbuf *n;
109: if ((n = m_copy(m, 0, (int)M_COPYALL)) != NULL) {
110: if (sbappendaddr(&last->so_rcv, src,
111: n, (struct mbuf *)0) == 0)
112: /* should notify about lost packet */
113: m_freem(n);
114: else {
115: sorwakeup(last);
116: sockets++;
117: }
118: }
119: }
120: last = rp->rcb_socket;
121: }
122: if (last) {
123: if (sbappendaddr(&last->so_rcv, src,
124: m, (struct mbuf *)0) == 0)
125: m_freem(m);
126: else {
127: sorwakeup(last);
128: sockets++;
129: }
130: } else
131: m_freem(m);
132: }
133:
134: /*ARGSUSED*/
135: void *
136: raw_ctlinput(cmd, arg, d)
137: int cmd;
138: struct sockaddr *arg;
139: void *d;
140: {
141:
142: if (cmd < 0 || cmd >= PRC_NCMDS)
143: return NULL;
144: return NULL;
145: /* INCOMPLETE */
146: }
147:
148: /*ARGSUSED*/
149: int
150: raw_usrreq(so, req, m, nam, control)
151: struct socket *so;
152: int req;
153: struct mbuf *m, *nam, *control;
154: {
155: struct rawcb *rp = sotorawcb(so);
156: int error = 0;
157: int len;
158:
159: if (req == PRU_CONTROL)
160: return (EOPNOTSUPP);
161: if (control && control->m_len) {
162: error = EOPNOTSUPP;
163: goto release;
164: }
165: if (rp == 0) {
166: error = EINVAL;
167: goto release;
168: }
169: switch (req) {
170:
171: /*
172: * Allocate a raw control block and fill in the
173: * necessary info to allow packets to be routed to
174: * the appropriate raw interface routine.
175: */
176: case PRU_ATTACH:
177: if ((so->so_state & SS_PRIV) == 0) {
178: error = EACCES;
179: break;
180: }
181: error = raw_attach(so, (int)(long)nam);
182: break;
183:
184: /*
185: * Destroy state just before socket deallocation.
186: * Flush data or not depending on the options.
187: */
188: case PRU_DETACH:
189: if (rp == 0) {
190: error = ENOTCONN;
191: break;
192: }
193: raw_detach(rp);
194: break;
195:
196: #ifdef notdef
197: /*
198: * If a socket isn't bound to a single address,
199: * the raw input routine will hand it anything
200: * within that protocol family (assuming there's
201: * nothing else around it should go to).
202: */
203: case PRU_CONNECT:
204: if (rp->rcb_faddr) {
205: error = EISCONN;
206: break;
207: }
208: nam = m_copym(nam, 0, M_COPYALL, M_WAIT);
209: rp->rcb_faddr = mtod(nam, struct sockaddr *);
210: soisconnected(so);
211: break;
212:
213: case PRU_BIND:
214: if (rp->rcb_laddr) {
215: error = EINVAL; /* XXX */
216: break;
217: }
218: error = raw_bind(so, nam);
219: break;
220: #else
221: case PRU_CONNECT:
222: case PRU_BIND:
223: #endif
224: case PRU_CONNECT2:
225: error = EOPNOTSUPP;
226: goto release;
227:
228: case PRU_DISCONNECT:
229: if (rp->rcb_faddr == 0) {
230: error = ENOTCONN;
231: break;
232: }
233: raw_disconnect(rp);
234: soisdisconnected(so);
235: break;
236:
237: /*
238: * Mark the connection as being incapable of further input.
239: */
240: case PRU_SHUTDOWN:
241: socantsendmore(so);
242: break;
243:
244: /*
245: * Ship a packet out. The appropriate raw output
246: * routine handles any massaging necessary.
247: */
248: case PRU_SEND:
249: if (nam) {
250: if (rp->rcb_faddr) {
251: error = EISCONN;
252: break;
253: }
254: rp->rcb_faddr = mtod(nam, struct sockaddr *);
255: } else if (rp->rcb_faddr == 0) {
256: error = ENOTCONN;
257: break;
258: }
259: error = (*so->so_proto->pr_output)(m, so);
260: m = NULL;
261: if (nam)
262: rp->rcb_faddr = 0;
263: break;
264:
265: case PRU_ABORT:
266: raw_disconnect(rp);
267: sofree(so);
268: soisdisconnected(so);
269: break;
270:
271: case PRU_SENSE:
272: /*
273: * stat: don't bother with a blocksize.
274: */
275: return (0);
276:
277: /*
278: * Not supported.
279: */
280: case PRU_RCVOOB:
281: case PRU_RCVD:
282: return (EOPNOTSUPP);
283:
284: case PRU_LISTEN:
285: case PRU_ACCEPT:
286: case PRU_SENDOOB:
287: error = EOPNOTSUPP;
288: break;
289:
290: case PRU_SOCKADDR:
291: if (rp->rcb_laddr == 0) {
292: error = EINVAL;
293: break;
294: }
295: len = rp->rcb_laddr->sa_len;
296: bcopy((caddr_t)rp->rcb_laddr, mtod(nam, caddr_t), (unsigned)len);
297: nam->m_len = len;
298: break;
299:
300: case PRU_PEERADDR:
301: if (rp->rcb_faddr == 0) {
302: error = ENOTCONN;
303: break;
304: }
305: len = rp->rcb_faddr->sa_len;
306: bcopy((caddr_t)rp->rcb_faddr, mtod(nam, caddr_t), (unsigned)len);
307: nam->m_len = len;
308: break;
309:
310: default:
311: panic("raw_usrreq");
312: }
313: release:
314: if (m != NULL)
315: m_freem(m);
316: return (error);
317: }