route: Add support for route(4) message filtering.
[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 #include <net/netisr2.h>
47
48 /*
49  * Except from the raw_init(), rest of interfaces must be called
50  * from netisr0.
51  */
52
53 /*
54  * Initialize raw connection block q.
55  */
56 void
57 raw_init(void)
58 {
59         LIST_INIT(&rawcb_list);
60 }
61
62 /************************************************************************
63  *                       RAW PROTOCOL INTERFACE                         *
64  ************************************************************************/
65
66 /*
67  * Raw protocol input routine.  Find the socket associated with the packet(s)
68  * and move them over.  If nothing exists for this packet, drop it.  This
69  * routine is indirect called via rts_input() and will be serialized on
70  * cpu 0.
71  *
72  * Most other raw protocol interface functions are also serialized XXX.
73  */
74 void
75 raw_input(struct mbuf *m0, const struct sockproto *proto,
76           const struct sockaddr *src, const struct sockaddr *dst,
77           const struct rawcb *skip)
78 {
79         struct rawcb *rp;
80         struct mbuf *m = m0;
81         struct socket *last;
82
83         ASSERT_NETISR0;
84
85         last = NULL;
86
87         LIST_FOREACH(rp, &rawcb_list, list) {
88                 if (rp == skip)
89                         continue;
90                 if (rp->rcb_proto.sp_family != proto->sp_family)
91                         continue;
92                 if (rp->rcb_proto.sp_protocol  &&
93                     rp->rcb_proto.sp_protocol != proto->sp_protocol)
94                         continue;
95                 /*
96                  * We assume the lower level routines have
97                  * placed the address in a canonical format
98                  * suitable for a structure comparison.
99                  *
100                  * Note that if the lengths are not the same
101                  * the comparison will fail at the first byte.
102                  */
103                 if (rp->rcb_laddr && !sa_equal(rp->rcb_laddr, dst))
104                         continue;
105                 if (rp->rcb_faddr && !sa_equal(rp->rcb_faddr, src))
106                         continue;
107                 /* Run any filtering that may have been installed. */
108                 if (rp->rcb_filter != NULL && rp->rcb_filter(m, proto, rp) != 0)
109                         continue;
110                 if (last) {
111                         struct mbuf *n;
112
113                         n = m_copypacket(m, M_NOWAIT);
114                         if (n != NULL) {
115                                 lwkt_gettoken(&last->so_rcv.ssb_token);
116                                 if (ssb_appendaddr(&last->so_rcv, src, n,
117                                                  NULL) == 0) {
118                                         m_freem(n);
119                                         soroverflow(last);
120                                 } else {
121                                         sorwakeup(last);
122                                 }
123                                 lwkt_reltoken(&last->so_rcv.ssb_token);
124                         }
125                 }
126                 last = rp->rcb_socket;
127         }
128         if (last) {
129                 lwkt_gettoken(&last->so_rcv.ssb_token);
130                 if (ssb_appendaddr(&last->so_rcv, src, m, NULL) == 0) {
131                         m_freem(m);
132                         soroverflow(last);
133                 } else
134                         sorwakeup(last);
135                 lwkt_reltoken(&last->so_rcv.ssb_token);
136         } else {
137                 m_freem(m);
138         }
139 }
140
141 /*
142  * nm_cmd, nm_arg, nm_extra
143  */
144 void
145 raw_ctlinput(netmsg_t msg)
146 {
147         int error = 0;
148
149         ASSERT_NETISR0;
150
151         if (msg->ctlinput.nm_cmd < 0 || msg->ctlinput.nm_cmd > PRC_NCMDS) {
152                 ; /* no-op */
153         }
154         lwkt_replymsg(&msg->lmsg, error);
155 }
156
157 /*
158  * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
159  *       will sofree() it when we return.
160  */
161 static void
162 raw_uabort(netmsg_t msg)
163 {
164         struct rawcb *rp = sotorawcb(msg->base.nm_so);
165         int error;
166
167         ASSERT_NETISR0;
168
169         if (rp) {
170                 raw_disconnect(rp);
171                 soisdisconnected(msg->base.nm_so);
172                 error = 0;
173         } else {
174                 error = EINVAL;
175         }
176         lwkt_replymsg(&msg->lmsg, error);
177 }
178
179 /* pru_accept is EOPNOTSUPP */
180
181 static void
182 raw_uattach(netmsg_t msg)
183 {
184         struct socket *so = msg->base.nm_so;
185         int proto = msg->attach.nm_proto;
186         struct pru_attach_info *ai = msg->attach.nm_ai;
187         struct rawcb *rp;
188         int error;
189
190         ASSERT_NETISR0;
191
192         rp = sotorawcb(so);
193         if (rp) {
194                 error = priv_check_cred(ai->p_ucred, PRIV_ROOT, NULL_CRED_OKAY);
195                 if (error == 0)
196                         error = raw_attach(so, proto, ai->sb_rlimit);
197         } else {
198                 error = EINVAL;
199         }
200         lwkt_replymsg(&msg->lmsg, error);
201 }
202
203 static void
204 raw_ubind(netmsg_t msg)
205 {
206         ASSERT_NETISR0;
207         lwkt_replymsg(&msg->lmsg, EINVAL);
208 }
209
210 static void
211 raw_uconnect(netmsg_t msg)
212 {
213         ASSERT_NETISR0;
214         lwkt_replymsg(&msg->lmsg, EINVAL);
215 }
216
217 /* pru_connect2 is EOPNOTSUPP */
218 /* pru_control is EOPNOTSUPP */
219
220 static void
221 raw_udetach(netmsg_t msg)
222 {
223         struct rawcb *rp = sotorawcb(msg->base.nm_so);
224         int error;
225
226         ASSERT_NETISR0;
227
228         if (rp) {
229                 raw_detach(rp);
230                 error = 0;
231         } else {
232                 error = EINVAL;
233         }
234         lwkt_replymsg(&msg->lmsg, error);
235 }
236
237 static void
238 raw_udisconnect(netmsg_t msg)
239 {
240         struct socket *so = msg->base.nm_so;
241         struct rawcb *rp;
242         int error;
243
244         ASSERT_NETISR0;
245
246         rp = sotorawcb(so);
247         if (rp == NULL) {
248                 error = EINVAL;
249         } else if (rp->rcb_faddr == NULL) {
250                 error = ENOTCONN;
251         } else {
252                 soreference(so);
253                 raw_disconnect(rp);
254                 soisdisconnected(so);
255                 sofree(so);
256                 error = 0;
257         }
258         lwkt_replymsg(&msg->lmsg, error);
259 }
260
261 /* pru_listen is EOPNOTSUPP */
262
263 static void
264 raw_upeeraddr(netmsg_t msg)
265 {
266         struct rawcb *rp = sotorawcb(msg->base.nm_so);
267         int error;
268
269         ASSERT_NETISR0;
270
271         if (rp == NULL) {
272                 error = EINVAL;
273         } else if (rp->rcb_faddr == NULL) {
274                 error = ENOTCONN;
275         } else {
276                 *msg->peeraddr.nm_nam = dup_sockaddr(rp->rcb_faddr);
277                 error = 0;
278         }
279         lwkt_replymsg(&msg->lmsg, error);
280 }
281
282 /* pru_rcvd is EOPNOTSUPP */
283 /* pru_rcvoob is EOPNOTSUPP */
284
285 static void
286 raw_usend(netmsg_t msg)
287 {
288         struct socket *so = msg->base.nm_so;
289         struct mbuf *m = msg->send.nm_m;
290         struct mbuf *control = msg->send.nm_control;
291         struct rawcb *rp = sotorawcb(so);
292         struct pr_output_info oi;
293         int flags = msg->send.nm_flags;
294         int error;
295
296         ASSERT_NETISR0;
297
298         if (rp == NULL) {
299                 error = EINVAL;
300                 goto release;
301         }
302
303         if (flags & PRUS_OOB) {
304                 error = EOPNOTSUPP;
305                 goto release;
306         }
307
308         if (control && control->m_len) {
309                 error = EOPNOTSUPP;
310                 goto release;
311         }
312         if (msg->send.nm_addr) {
313                 if (rp->rcb_faddr) {
314                         error = EISCONN;
315                         goto release;
316                 }
317                 rp->rcb_faddr = msg->send.nm_addr;
318         } else if (rp->rcb_faddr == NULL) {
319                 error = ENOTCONN;
320                 goto release;
321         }
322         oi.p_pid = msg->send.nm_td->td_proc->p_pid;
323         error = (*so->so_proto->pr_output)(m, so, &oi);
324         m = NULL;
325         if (msg->send.nm_addr)
326                 rp->rcb_faddr = NULL;
327 release:
328         if (m != NULL)
329                 m_freem(m);
330         lwkt_replymsg(&msg->lmsg, error);
331 }
332
333 /* pru_sense is null */
334
335 static void
336 raw_ushutdown(netmsg_t msg)
337 {
338         struct rawcb *rp = sotorawcb(msg->base.nm_so);
339         int error;
340
341         ASSERT_NETISR0;
342
343         if (rp) {
344                 socantsendmore(msg->base.nm_so);
345                 error = 0;
346         } else {
347                 error = EINVAL;
348         }
349         lwkt_replymsg(&msg->lmsg, error);
350 }
351
352 static void
353 raw_usockaddr(netmsg_t msg)
354 {
355         struct rawcb *rp = sotorawcb(msg->base.nm_so);
356         int error;
357
358         ASSERT_NETISR0;
359
360         if (rp == NULL) {
361                 error = EINVAL;
362         } else if (rp->rcb_laddr == NULL) {
363                 error = EINVAL;
364         } else {
365                 *msg->sockaddr.nm_nam = dup_sockaddr(rp->rcb_laddr);
366                 error = 0;
367         }
368         lwkt_replymsg(&msg->lmsg, error);
369 }
370
371 struct pr_usrreqs raw_usrreqs = {
372         .pru_abort = raw_uabort,
373         .pru_accept = pr_generic_notsupp,
374         .pru_attach = raw_uattach,
375         .pru_bind = raw_ubind,
376         .pru_connect = raw_uconnect,
377         .pru_connect2 = pr_generic_notsupp,
378         .pru_control = pr_generic_notsupp,
379         .pru_detach = raw_udetach, 
380         .pru_disconnect = raw_udisconnect,
381         .pru_listen = pr_generic_notsupp,
382         .pru_peeraddr = raw_upeeraddr,
383         .pru_rcvd = pr_generic_notsupp,
384         .pru_rcvoob = pr_generic_notsupp,
385         .pru_send = raw_usend,
386         .pru_sense = pru_sense_null,
387         .pru_shutdown = raw_ushutdown,
388         .pru_sockaddr = raw_usockaddr,
389         .pru_sosend = sosend,
390         .pru_soreceive = soreceive
391 };