9d3186b6a38a9d3a4470a73dc2edb9d37a544696
[dragonfly.git] / sys / net / raw_usrreq.c
1 /*
2  * Copyright (c) 1980, 1986, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *      @(#)raw_usrreq.c        8.1 (Berkeley) 6/10/93
30  * $FreeBSD: src/sys/net/raw_usrreq.c,v 1.18 1999/08/28 00:48:28 peter Exp $
31  */
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/mbuf.h>
36 #include <sys/proc.h>
37 #include <sys/priv.h>
38 #include <sys/protosw.h>
39 #include <sys/socket.h>
40 #include <sys/socketvar.h>
41
42 #include <sys/socketvar2.h>
43 #include <sys/msgport2.h>
44
45 #include <net/raw_cb.h>
46
47
48 static struct lwkt_token raw_token = LWKT_TOKEN_INITIALIZER(raw_token);
49
50 /*
51  * Initialize raw connection block q.
52  */
53 void
54 raw_init(void)
55 {
56         LIST_INIT(&rawcb_list);
57 }
58
59 /************************************************************************
60  *                       RAW PROTOCOL INTERFACE                         *
61  ************************************************************************/
62
63 /*
64  * Raw protocol input routine.  Find the socket associated with the packet(s)
65  * and move them over.  If nothing exists for this packet, drop it.  This
66  * routine is indirect called via rts_input() and will be serialized on
67  * cpu 0.
68  *
69  * Most other raw protocol interface functions are also serialized XXX.
70  */
71 void
72 raw_input(struct mbuf *m0, const struct sockproto *proto,
73           const struct sockaddr *src, const struct sockaddr *dst,
74           const struct rawcb *skip)
75 {
76         struct rawcb *rp;
77         struct mbuf *m = m0;
78         struct socket *last;
79
80         lwkt_gettoken(&raw_token);
81
82         last = NULL;
83         LIST_FOREACH(rp, &rawcb_list, list) {
84                 if (rp == skip)
85                         continue;
86                 if (rp->rcb_proto.sp_family != proto->sp_family)
87                         continue;
88                 if (rp->rcb_proto.sp_protocol  &&
89                     rp->rcb_proto.sp_protocol != proto->sp_protocol)
90                         continue;
91                 /*
92                  * We assume the lower level routines have
93                  * placed the address in a canonical format
94                  * suitable for a structure comparison.
95                  *
96                  * Note that if the lengths are not the same
97                  * the comparison will fail at the first byte.
98                  */
99                 if (rp->rcb_laddr && !sa_equal(rp->rcb_laddr, dst))
100                         continue;
101                 if (rp->rcb_faddr && !sa_equal(rp->rcb_faddr, src))
102                         continue;
103                 if (last) {
104                         struct mbuf *n;
105
106                         n = m_copypacket(m, M_NOWAIT);
107                         if (n != NULL) {
108                                 lwkt_gettoken(&last->so_rcv.ssb_token);
109                                 if (ssb_appendaddr(&last->so_rcv, src, n,
110                                                  NULL) == 0) {
111                                         m_freem(n);
112                                         soroverflow(last);
113                                 } else {
114                                         sorwakeup(last);
115                                 }
116                                 lwkt_reltoken(&last->so_rcv.ssb_token);
117                         }
118                 }
119                 last = rp->rcb_socket;
120         }
121         if (last) {
122                 lwkt_gettoken(&last->so_rcv.ssb_token);
123                 if (ssb_appendaddr(&last->so_rcv, src, m, NULL) == 0) {
124                         m_freem(m);
125                         soroverflow(last);
126                 } else
127                         sorwakeup(last);
128                 lwkt_reltoken(&last->so_rcv.ssb_token);
129         } else {
130                 m_freem(m);
131         }
132         lwkt_reltoken(&raw_token);
133 }
134
135 /*
136  * nm_cmd, nm_arg, nm_extra
137  */
138 void
139 raw_ctlinput(netmsg_t msg)
140 {
141         int error = 0;
142
143         if (msg->ctlinput.nm_cmd < 0 || msg->ctlinput.nm_cmd > PRC_NCMDS) {
144                 ; /* no-op */
145         }
146         lwkt_replymsg(&msg->lmsg, error);
147 }
148
149 /*
150  * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
151  *       will sofree() it when we return.
152  */
153 static void
154 raw_uabort(netmsg_t msg)
155 {
156         struct rawcb *rp = sotorawcb(msg->base.nm_so);
157         int error;
158
159         if (rp) {
160                 raw_disconnect(rp);
161                 soisdisconnected(msg->base.nm_so);
162                 error = 0;
163         } else {
164                 error = EINVAL;
165         }
166         lwkt_replymsg(&msg->lmsg, error);
167 }
168
169 /* pru_accept is EOPNOTSUPP */
170
171 static void
172 raw_uattach(netmsg_t msg)
173 {
174         struct socket *so = msg->base.nm_so;
175         int proto = msg->attach.nm_proto;
176         struct pru_attach_info *ai = msg->attach.nm_ai;
177         struct rawcb *rp;
178         int error;
179
180         rp = sotorawcb(so);
181         if (rp) {
182                 error = priv_check_cred(ai->p_ucred, PRIV_ROOT, NULL_CRED_OKAY);
183                 if (error == 0)
184                         error = raw_attach(so, proto, ai->sb_rlimit);
185         } else {
186                 error = EINVAL;
187         }
188         lwkt_replymsg(&msg->lmsg, error);
189 }
190
191 static void
192 raw_ubind(netmsg_t msg)
193 {
194         lwkt_replymsg(&msg->lmsg, EINVAL);
195 }
196
197 static void
198 raw_uconnect(netmsg_t msg)
199 {
200         lwkt_replymsg(&msg->lmsg, EINVAL);
201 }
202
203 /* pru_connect2 is EOPNOTSUPP */
204 /* pru_control is EOPNOTSUPP */
205
206 static void
207 raw_udetach(netmsg_t msg)
208 {
209         struct rawcb *rp = sotorawcb(msg->base.nm_so);
210         int error;
211
212         if (rp) {
213                 raw_detach(rp);
214                 error = 0;
215         } else {
216                 error = EINVAL;
217         }
218         lwkt_replymsg(&msg->lmsg, error);
219 }
220
221 static void
222 raw_udisconnect(netmsg_t msg)
223 {
224         struct socket *so = msg->base.nm_so;
225         struct rawcb *rp;
226         int error;
227
228         rp = sotorawcb(so);
229         if (rp == NULL) {
230                 error = EINVAL;
231         } else if (rp->rcb_faddr == NULL) {
232                 error = ENOTCONN;
233         } else {
234                 soreference(so);
235                 raw_disconnect(rp);
236                 soisdisconnected(so);
237                 sofree(so);
238                 error = 0;
239         }
240         lwkt_replymsg(&msg->lmsg, error);
241 }
242
243 /* pru_listen is EOPNOTSUPP */
244
245 static void
246 raw_upeeraddr(netmsg_t msg)
247 {
248         struct rawcb *rp = sotorawcb(msg->base.nm_so);
249         int error;
250
251         if (rp == NULL) {
252                 error = EINVAL;
253         } else if (rp->rcb_faddr == NULL) {
254                 error = ENOTCONN;
255         } else {
256                 *msg->peeraddr.nm_nam = dup_sockaddr(rp->rcb_faddr);
257                 error = 0;
258         }
259         lwkt_replymsg(&msg->lmsg, error);
260 }
261
262 /* pru_rcvd is EOPNOTSUPP */
263 /* pru_rcvoob is EOPNOTSUPP */
264
265 static void
266 raw_usend(netmsg_t msg)
267 {
268         struct socket *so = msg->base.nm_so;
269         struct mbuf *m = msg->send.nm_m;
270         struct mbuf *control = msg->send.nm_control;
271         struct rawcb *rp = sotorawcb(so);
272         struct pr_output_info oi;
273         int flags = msg->send.nm_flags;
274         int error;
275
276         if (rp == NULL) {
277                 error = EINVAL;
278                 goto release;
279         }
280
281         if (flags & PRUS_OOB) {
282                 error = EOPNOTSUPP;
283                 goto release;
284         }
285
286         if (control && control->m_len) {
287                 error = EOPNOTSUPP;
288                 goto release;
289         }
290         if (msg->send.nm_addr) {
291                 if (rp->rcb_faddr) {
292                         error = EISCONN;
293                         goto release;
294                 }
295                 rp->rcb_faddr = msg->send.nm_addr;
296         } else if (rp->rcb_faddr == NULL) {
297                 error = ENOTCONN;
298                 goto release;
299         }
300         oi.p_pid = msg->send.nm_td->td_proc->p_pid;
301         error = (*so->so_proto->pr_output)(m, so, &oi);
302         m = NULL;
303         if (msg->send.nm_addr)
304                 rp->rcb_faddr = NULL;
305 release:
306         if (m != NULL)
307                 m_freem(m);
308         lwkt_replymsg(&msg->lmsg, error);
309 }
310
311 /* pru_sense is null */
312
313 static void
314 raw_ushutdown(netmsg_t msg)
315 {
316         struct rawcb *rp = sotorawcb(msg->base.nm_so);
317         int error;
318
319         if (rp) {
320                 socantsendmore(msg->base.nm_so);
321                 error = 0;
322         } else {
323                 error = EINVAL;
324         }
325         lwkt_replymsg(&msg->lmsg, error);
326 }
327
328 static void
329 raw_usockaddr(netmsg_t msg)
330 {
331         struct rawcb *rp = sotorawcb(msg->base.nm_so);
332         int error;
333
334         if (rp == NULL) {
335                 error = EINVAL;
336         } else if (rp->rcb_laddr == NULL) {
337                 error = EINVAL;
338         } else {
339                 *msg->sockaddr.nm_nam = dup_sockaddr(rp->rcb_laddr);
340                 error = 0;
341         }
342         lwkt_replymsg(&msg->lmsg, error);
343 }
344
345 struct pr_usrreqs raw_usrreqs = {
346         .pru_abort = raw_uabort,
347         .pru_accept = pr_generic_notsupp,
348         .pru_attach = raw_uattach,
349         .pru_bind = raw_ubind,
350         .pru_connect = raw_uconnect,
351         .pru_connect2 = pr_generic_notsupp,
352         .pru_control = pr_generic_notsupp,
353         .pru_detach = raw_udetach, 
354         .pru_disconnect = raw_udisconnect,
355         .pru_listen = pr_generic_notsupp,
356         .pru_peeraddr = raw_upeeraddr,
357         .pru_rcvd = pr_generic_notsupp,
358         .pru_rcvoob = pr_generic_notsupp,
359         .pru_send = raw_usend,
360         .pru_sense = pru_sense_null,
361         .pru_shutdown = raw_ushutdown,
362         .pru_sockaddr = raw_usockaddr,
363         .pru_sosend = sosend,
364         .pru_soreceive = soreceive
365 };