Change pr_output's signature to take two fixed arguments and possible
[dragonfly.git] / sys / netproto / key / keysock.c
1 /*      $FreeBSD: src/sys/netkey/keysock.c,v 1.1.2.4 2003/01/11 19:10:59 ume Exp $      */
2 /*      $DragonFly: src/sys/netproto/key/keysock.c,v 1.11 2004/06/03 15:04:51 joerg Exp $       */
3 /*      $KAME: keysock.c,v 1.25 2001/08/13 20:07:41 itojun Exp $        */
4
5 /*
6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. Neither the name of the project nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include "opt_ipsec.h"
35
36 /* This code has derived from sys/net/rtsock.c on FreeBSD2.2.5 */
37
38 #include <sys/types.h>
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/sysctl.h>
43 #include <sys/mbuf.h>
44 #include <sys/malloc.h>
45 #include <sys/socket.h>
46 #include <sys/socketvar.h>
47 #include <sys/domain.h>
48 #include <sys/protosw.h>
49 #include <sys/errno.h>
50
51 #include <machine/ipl.h>
52
53 #include <net/raw_cb.h>
54 #include <net/route.h>
55 #include <netinet/in.h>
56
57 #include <net/pfkeyv2.h>
58 #include "keydb.h"
59 #include "key.h"
60 #include "keysock.h"
61 #include "key_debug.h"
62
63 #include <machine/stdarg.h>
64
65 struct sockaddr key_dst = { 2, PF_KEY, };
66 struct sockaddr key_src = { 2, PF_KEY, };
67
68 static int key_sendup0 (struct rawcb *, struct mbuf *, int);
69
70 struct pfkeystat pfkeystat;
71
72 /*
73  * key_output()
74  */
75 int
76 key_output(struct mbuf *m, struct socket *so, ...)
77 {
78         struct sadb_msg *msg;
79         int len, error = 0;
80         int s;
81
82         if (m == 0)
83                 panic("key_output: NULL pointer was passed.\n");
84
85         pfkeystat.out_total++;
86         pfkeystat.out_bytes += m->m_pkthdr.len;
87
88         len = m->m_pkthdr.len;
89         if (len < sizeof(struct sadb_msg)) {
90                 pfkeystat.out_tooshort++;
91                 error = EINVAL;
92                 goto end;
93         }
94
95         if (m->m_len < sizeof(struct sadb_msg)) {
96                 if ((m = m_pullup(m, sizeof(struct sadb_msg))) == 0) {
97                         pfkeystat.out_nomem++;
98                         error = ENOBUFS;
99                         goto end;
100                 }
101         }
102
103         if ((m->m_flags & M_PKTHDR) == 0)
104                 panic("key_output: not M_PKTHDR ??");
105
106         KEYDEBUG(KEYDEBUG_KEY_DUMP, kdebug_mbuf(m));
107
108         msg = mtod(m, struct sadb_msg *);
109         pfkeystat.out_msgtype[msg->sadb_msg_type]++;
110         if (len != PFKEY_UNUNIT64(msg->sadb_msg_len)) {
111                 pfkeystat.out_invlen++;
112                 error = EINVAL;
113                 goto end;
114         }
115
116         /*XXX giant lock*/
117         s = splnet();
118         error = key_parse(m, so);
119         m = NULL;
120         splx(s);
121 end:
122         if (m)
123                 m_freem(m);
124         return error;
125 }
126
127 /*
128  * send message to the socket.
129  */
130 static int
131 key_sendup0(rp, m, promisc)
132         struct rawcb *rp;
133         struct mbuf *m;
134         int promisc;
135 {
136         int error;
137
138         if (promisc) {
139                 struct sadb_msg *pmsg;
140
141                 M_PREPEND(m, sizeof(struct sadb_msg), MB_DONTWAIT);
142                 if (m && m->m_len < sizeof(struct sadb_msg))
143                         m = m_pullup(m, sizeof(struct sadb_msg));
144                 if (!m) {
145                         pfkeystat.in_nomem++;
146                         m_freem(m);
147                         return ENOBUFS;
148                 }
149                 m->m_pkthdr.len += sizeof(*pmsg);
150
151                 pmsg = mtod(m, struct sadb_msg *);
152                 bzero(pmsg, sizeof(*pmsg));
153                 pmsg->sadb_msg_version = PF_KEY_V2;
154                 pmsg->sadb_msg_type = SADB_X_PROMISC;
155                 pmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
156                 /* pid and seq? */
157
158                 pfkeystat.in_msgtype[pmsg->sadb_msg_type]++;
159         }
160
161         if (!sbappendaddr(&rp->rcb_socket->so_rcv, (struct sockaddr *)&key_src,
162             m, NULL)) {
163                 pfkeystat.in_nomem++;
164                 m_freem(m);
165                 error = ENOBUFS;
166         } else
167                 error = 0;
168         sorwakeup(rp->rcb_socket);
169         return error;
170 }
171
172 /* XXX this interface should be obsoleted. */
173 int
174 key_sendup(so, msg, len, target)
175         struct socket *so;
176         struct sadb_msg *msg;
177         u_int len;
178         int target;     /*target of the resulting message*/
179 {
180         struct mbuf *m, *n, *mprev;
181         int tlen;
182
183         /* sanity check */
184         if (so == 0 || msg == 0)
185                 panic("key_sendup: NULL pointer was passed.\n");
186
187         KEYDEBUG(KEYDEBUG_KEY_DUMP,
188                 printf("key_sendup: \n");
189                 kdebug_sadb(msg));
190
191         /*
192          * we increment statistics here, just in case we have ENOBUFS
193          * in this function.
194          */
195         pfkeystat.in_total++;
196         pfkeystat.in_bytes += len;
197         pfkeystat.in_msgtype[msg->sadb_msg_type]++;
198
199         /*
200          * Get mbuf chain whenever possible (not clusters),
201          * to save socket buffer.  We'll be generating many SADB_ACQUIRE
202          * messages to listening key sockets.  If we simply allocate clusters,
203          * sbappendaddr() will raise ENOBUFS due to too little sbspace().
204          * sbspace() computes # of actual data bytes AND mbuf region.
205          *
206          * TODO: SADB_ACQUIRE filters should be implemented.
207          */
208         tlen = len;
209         m = mprev = NULL;
210         while (tlen > 0) {
211                 if (tlen == len) {
212                         MGETHDR(n, MB_DONTWAIT, MT_DATA);
213                         n->m_len = MHLEN;
214                 } else {
215                         MGET(n, MB_DONTWAIT, MT_DATA);
216                         n->m_len = MLEN;
217                 }
218                 if (!n) {
219                         pfkeystat.in_nomem++;
220                         return ENOBUFS;
221                 }
222                 if (tlen >= MCLBYTES) { /*XXX better threshold? */
223                         MCLGET(n, MB_DONTWAIT);
224                         if ((n->m_flags & M_EXT) == 0) {
225                                 m_free(n);
226                                 m_freem(m);
227                                 pfkeystat.in_nomem++;
228                                 return ENOBUFS;
229                         }
230                         n->m_len = MCLBYTES;
231                 }
232
233                 if (tlen < n->m_len)
234                         n->m_len = tlen;
235                 n->m_next = NULL;
236                 if (m == NULL)
237                         m = mprev = n;
238                 else {
239                         mprev->m_next = n;
240                         mprev = n;
241                 }
242                 tlen -= n->m_len;
243                 n = NULL;
244         }
245         m->m_pkthdr.len = len;
246         m->m_pkthdr.rcvif = NULL;
247         m_copyback(m, 0, len, (caddr_t)msg);
248
249         /* avoid duplicated statistics */
250         pfkeystat.in_total--;
251         pfkeystat.in_bytes -= len;
252         pfkeystat.in_msgtype[msg->sadb_msg_type]--;
253
254         return key_sendup_mbuf(so, m, target);
255 }
256
257 /* so can be NULL if target != KEY_SENDUP_ONE */
258 int
259 key_sendup_mbuf(so, m, target)
260         struct socket *so;
261         struct mbuf *m;
262         int target;
263 {
264         struct mbuf *n;
265         struct keycb *kp;
266         int sendup;
267         struct rawcb *rp;
268         int error = 0;
269
270         if (m == NULL)
271                 panic("key_sendup_mbuf: NULL pointer was passed.\n");
272         if (so == NULL && target == KEY_SENDUP_ONE)
273                 panic("key_sendup_mbuf: NULL pointer was passed.\n");
274
275         pfkeystat.in_total++;
276         pfkeystat.in_bytes += m->m_pkthdr.len;
277         if (m->m_len < sizeof(struct sadb_msg)) {
278 #if 1
279                 m = m_pullup(m, sizeof(struct sadb_msg));
280                 if (m == NULL) {
281                         pfkeystat.in_nomem++;
282                         return ENOBUFS;
283                 }
284 #else
285                 /* don't bother pulling it up just for stats */
286 #endif
287         }
288         if (m->m_len >= sizeof(struct sadb_msg)) {
289                 struct sadb_msg *msg;
290                 msg = mtod(m, struct sadb_msg *);
291                 pfkeystat.in_msgtype[msg->sadb_msg_type]++;
292         }
293
294         LIST_FOREACH(rp, &rawcb_list, list)
295         {
296                 if (rp->rcb_proto.sp_family != PF_KEY)
297                         continue;
298                 if (rp->rcb_proto.sp_protocol
299                  && rp->rcb_proto.sp_protocol != PF_KEY_V2) {
300                         continue;
301                 }
302
303                 kp = (struct keycb *)rp;
304
305                 /*
306                  * If you are in promiscuous mode, and when you get broadcasted
307                  * reply, you'll get two PF_KEY messages.
308                  * (based on pf_key@inner.net message on 14 Oct 1998)
309                  */
310                 if (((struct keycb *)rp)->kp_promisc) {
311                         if ((n = m_copy(m, 0, (int)M_COPYALL)) != NULL) {
312                                 (void)key_sendup0(rp, n, 1);
313                                 n = NULL;
314                         }
315                 }
316
317                 /* the exact target will be processed later */
318                 if (so && sotorawcb(so) == rp)
319                         continue;
320
321                 sendup = 0;
322                 switch (target) {
323                 case KEY_SENDUP_ONE:
324                         /* the statement has no effect */
325                         if (so && sotorawcb(so) == rp)
326                                 sendup++;
327                         break;
328                 case KEY_SENDUP_ALL:
329                         sendup++;
330                         break;
331                 case KEY_SENDUP_REGISTERED:
332                         if (kp->kp_registered)
333                                 sendup++;
334                         break;
335                 }
336                 pfkeystat.in_msgtarget[target]++;
337
338                 if (!sendup)
339                         continue;
340
341                 if ((n = m_copy(m, 0, (int)M_COPYALL)) == NULL) {
342                         m_freem(m);
343                         pfkeystat.in_nomem++;
344                         return ENOBUFS;
345                 }
346
347                 if ((error = key_sendup0(rp, n, 0)) != 0) {
348                         m_freem(m);
349                         return error;
350                 }
351
352                 n = NULL;
353         }
354
355         if (so) {
356                 error = key_sendup0(sotorawcb(so), m, 0);
357                 m = NULL;
358         } else {
359                 error = 0;
360                 m_freem(m);
361         }
362         return error;
363 }
364
365 /*
366  * key_abort()
367  * derived from net/rtsock.c:rts_abort()
368  */
369 static int
370 key_abort(struct socket *so)
371 {
372         int s, error;
373         s = splnet();
374         error = raw_usrreqs.pru_abort(so);
375         splx(s);
376         return error;
377 }
378
379 /*
380  * key_attach()
381  * derived from net/rtsock.c:rts_attach()
382  */
383 static int
384 key_attach(struct socket *so, int proto, struct pru_attach_info *ai)
385 {
386         struct keycb *kp;
387         int s, error;
388
389         if (sotorawcb(so) != 0)
390                 return EISCONN; /* XXX panic? */
391         kp = (struct keycb *)malloc(sizeof *kp, M_PCB, M_WAITOK); /* XXX */
392         if (kp == 0)
393                 return ENOBUFS;
394         bzero(kp, sizeof *kp);
395
396         /*
397          * The splnet() is necessary to block protocols from sending
398          * error notifications (like RTM_REDIRECT or RTM_LOSING) while
399          * this PCB is extant but incompletely initialized.
400          * Probably we should try to do more of this work beforehand and
401          * eliminate the spl.
402          */
403         s = splnet();
404         so->so_pcb = (caddr_t)kp;
405         error = raw_usrreqs.pru_attach(so, proto, ai);
406         kp = (struct keycb *)sotorawcb(so);
407         if (error) {
408                 free(kp, M_PCB);
409                 so->so_pcb = (caddr_t) 0;
410                 splx(s);
411                 return error;
412         }
413
414         kp->kp_promisc = kp->kp_registered = 0;
415
416         if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
417                 key_cb.key_count++;
418         key_cb.any_count++;
419         kp->kp_raw.rcb_laddr = &key_src;
420         kp->kp_raw.rcb_faddr = &key_dst;
421         soisconnected(so);
422         so->so_options |= SO_USELOOPBACK;
423
424         splx(s);
425         return 0;
426 }
427
428 /*
429  * key_bind()
430  * derived from net/rtsock.c:rts_bind()
431  */
432 static int
433 key_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
434 {
435         int s, error;
436         s = splnet();
437         error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */
438         splx(s);
439         return error;
440 }
441
442 /*
443  * key_connect()
444  * derived from net/rtsock.c:rts_connect()
445  */
446 static int
447 key_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
448 {
449         int s, error;
450         s = splnet();
451         error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */
452         splx(s);
453         return error;
454 }
455
456 /*
457  * key_detach()
458  * derived from net/rtsock.c:rts_detach()
459  */
460 static int
461 key_detach(struct socket *so)
462 {
463         struct keycb *kp = (struct keycb *)sotorawcb(so);
464         int s, error;
465
466         s = splnet();
467         if (kp != 0) {
468                 if (kp->kp_raw.rcb_proto.sp_protocol
469                     == PF_KEY) /* XXX: AF_KEY */
470                         key_cb.key_count--;
471                 key_cb.any_count--;
472
473                 key_freereg(so);
474         }
475         error = raw_usrreqs.pru_detach(so);
476         splx(s);
477         return error;
478 }
479
480 /*
481  * key_disconnect()
482  * derived from net/rtsock.c:key_disconnect()
483  */
484 static int
485 key_disconnect(struct socket *so)
486 {
487         int s, error;
488         s = splnet();
489         error = raw_usrreqs.pru_disconnect(so);
490         splx(s);
491         return error;
492 }
493
494 /*
495  * key_peeraddr()
496  * derived from net/rtsock.c:rts_peeraddr()
497  */
498 static int
499 key_peeraddr(struct socket *so, struct sockaddr **nam)
500 {
501         int s, error;
502         s = splnet();
503         error = raw_usrreqs.pru_peeraddr(so, nam);
504         splx(s);
505         return error;
506 }
507
508 /*
509  * key_send()
510  * derived from net/rtsock.c:rts_send()
511  */
512 static int
513 key_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
514          struct mbuf *control, struct thread *td)
515 {
516         int s, error;
517         s = splnet();
518         error = raw_usrreqs.pru_send(so, flags, m, nam, control, td);
519         splx(s);
520         return error;
521 }
522
523 /*
524  * key_shutdown()
525  * derived from net/rtsock.c:rts_shutdown()
526  */
527 static int
528 key_shutdown(struct socket *so)
529 {
530         int s, error;
531         s = splnet();
532         error = raw_usrreqs.pru_shutdown(so);
533         splx(s);
534         return error;
535 }
536
537 /*
538  * key_sockaddr()
539  * derived from net/rtsock.c:rts_sockaddr()
540  */
541 static int
542 key_sockaddr(struct socket *so, struct sockaddr **nam)
543 {
544         int s, error;
545         s = splnet();
546         error = raw_usrreqs.pru_sockaddr(so, nam);
547         splx(s);
548         return error;
549 }
550
551 struct pr_usrreqs key_usrreqs = {
552         key_abort, pru_accept_notsupp, key_attach, key_bind,
553         key_connect,
554         pru_connect2_notsupp, pru_control_notsupp, key_detach,
555         key_disconnect, pru_listen_notsupp, key_peeraddr,
556         pru_rcvd_notsupp,
557         pru_rcvoob_notsupp, key_send, pru_sense_null, key_shutdown,
558         key_sockaddr, sosend, soreceive, sopoll
559 };
560
561 /* sysctl */
562 SYSCTL_NODE(_net, PF_KEY, key, CTLFLAG_RW, 0, "Key Family");
563
564 /*
565  * Definitions of protocols supported in the KEY domain.
566  */
567
568 extern struct domain keydomain;
569
570 struct protosw keysw[] = {
571 { SOCK_RAW,     &keydomain,     PF_KEY_V2,      PR_ATOMIC|PR_ADDR,
572   0,            key_output,     raw_ctlinput,   0,
573   cpu0_soport,
574   raw_init,     0,              0,              0,
575   &key_usrreqs
576 }
577 };
578
579 struct domain keydomain =
580     { PF_KEY, "key", key_init, 0, 0,
581       keysw, &keysw[sizeof(keysw)/sizeof(keysw[0])] };
582
583 DOMAIN_SET(key);