Install pr_ctlport for the rest of the protocols.
[dragonfly.git] / sys / netproto / ipsec / keysock.c
1 /*      $FreeBSD: src/sys/netipsec/keysock.c,v 1.3.2.1 2003/01/24 05:11:36 sam Exp $    */
2 /*      $DragonFly: src/sys/netproto/ipsec/keysock.c,v 1.19 2008/11/01 04:22:15 sephe 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/domain.h>
41 #include <sys/errno.h>
42 #include <sys/kernel.h>
43 #include <sys/malloc.h>
44 #include <sys/mbuf.h>
45 #include <sys/protosw.h>
46 #include <sys/signalvar.h>
47 #include <sys/socket.h>
48 #include <sys/socketvar.h>
49 #include <sys/sysctl.h>
50 #include <sys/systm.h>
51 #include <sys/thread2.h>
52
53 #include <net/raw_cb.h>
54 #include <net/route.h>
55
56 #include <net/pfkeyv2.h>
57 #include <netproto/ipsec/key.h>
58 #include <netproto/ipsec/keysock.h>
59 #include <netproto/ipsec/key_debug.h>
60
61 #include <machine/stdarg.h>
62
63 typedef int     pr_output_t (struct mbuf *, struct socket *);
64
65 struct key_cb {
66         int key_count;
67         int any_count;
68 };
69 static struct key_cb key_cb;
70
71 static struct sockaddr key_dst = { 2, PF_KEY, };
72 static struct sockaddr key_src = { 2, PF_KEY, };
73
74 static int key_sendup0 (struct rawcb *, struct mbuf *, int);
75
76 struct pfkeystat pfkeystat;
77
78 /*
79  * key_output()
80  */
81 int
82 key_output(struct mbuf *m, struct socket *so, ...)
83 {
84         struct sadb_msg *msg;
85         int len, error = 0;
86         
87
88         if (m == 0)
89                 panic("key_output: NULL pointer was passed.\n");
90
91         pfkeystat.out_total++;
92         pfkeystat.out_bytes += m->m_pkthdr.len;
93
94         len = m->m_pkthdr.len;
95         if (len < sizeof(struct sadb_msg)) {
96                 pfkeystat.out_tooshort++;
97                 error = EINVAL;
98                 goto end;
99         }
100
101         if (m->m_len < sizeof(struct sadb_msg)) {
102                 if ((m = m_pullup(m, sizeof(struct sadb_msg))) == 0) {
103                         pfkeystat.out_nomem++;
104                         error = ENOBUFS;
105                         goto end;
106                 }
107         }
108
109         if ((m->m_flags & M_PKTHDR) == 0)
110                 panic("key_output: not M_PKTHDR ??");
111
112         KEYDEBUG(KEYDEBUG_KEY_DUMP, kdebug_mbuf(m));
113
114         msg = mtod(m, struct sadb_msg *);
115         pfkeystat.out_msgtype[msg->sadb_msg_type]++;
116         if (len != PFKEY_UNUNIT64(msg->sadb_msg_len)) {
117                 pfkeystat.out_invlen++;
118                 error = EINVAL;
119                 goto end;
120         }
121
122         /*XXX giant lock*/
123         crit_enter();
124         error = key_parse(m, so);
125         m = NULL;
126         crit_exit();
127 end:
128         if (m)
129                 m_freem(m);
130         return error;
131 }
132
133 /*
134  * send message to the socket.
135  */
136 static int
137 key_sendup0(struct rawcb *rp, struct mbuf *m, int promisc)
138 {
139         int error;
140
141         if (promisc) {
142                 struct sadb_msg *pmsg;
143
144                 M_PREPEND(m, sizeof(struct sadb_msg), MB_DONTWAIT);
145                 if (m && m->m_len < sizeof(struct sadb_msg))
146                         m = m_pullup(m, sizeof(struct sadb_msg));
147                 if (!m) {
148                         pfkeystat.in_nomem++;
149                         m_freem(m);
150                         return ENOBUFS;
151                 }
152                 m->m_pkthdr.len += sizeof(*pmsg);
153
154                 pmsg = mtod(m, struct sadb_msg *);
155                 bzero(pmsg, sizeof(*pmsg));
156                 pmsg->sadb_msg_version = PF_KEY_V2;
157                 pmsg->sadb_msg_type = SADB_X_PROMISC;
158                 pmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
159                 /* pid and seq? */
160
161                 pfkeystat.in_msgtype[pmsg->sadb_msg_type]++;
162         }
163
164         if (!ssb_appendaddr(&rp->rcb_socket->so_rcv, (struct sockaddr *)&key_src,
165             m, NULL)) {
166                 pfkeystat.in_nomem++;
167                 m_freem(m);
168                 error = ENOBUFS;
169         } else
170                 error = 0;
171         sorwakeup(rp->rcb_socket);
172         return error;
173 }
174
175 /*
176  * XXX this interface should be obsoleted. 
177  *
178  * Parameters:
179  *      target: target of the resulting message
180  */
181 int
182 key_sendup(struct socket *so, struct sadb_msg *msg, u_int len, int target)
183 {
184         struct mbuf *m, *n, *mprev;
185         int tlen;
186
187         /* sanity check */
188         if (so == 0 || msg == 0)
189                 panic("key_sendup: NULL pointer was passed.\n");
190
191         KEYDEBUG(KEYDEBUG_KEY_DUMP,
192                 kprintf("key_sendup: \n");
193                 kdebug_sadb(msg));
194
195         /*
196          * we increment statistics here, just in case we have ENOBUFS
197          * in this function.
198          */
199         pfkeystat.in_total++;
200         pfkeystat.in_bytes += len;
201         pfkeystat.in_msgtype[msg->sadb_msg_type]++;
202
203         /*
204          * Get mbuf chain whenever possible (not clusters),
205          * to save socket buffer.  We'll be generating many SADB_ACQUIRE
206          * messages to listening key sockets.  If we simply allocate clusters,
207          * ssb_appendaddr() will raise ENOBUFS due to too little ssb_space().
208          * ssb_space() computes # of actual data bytes AND mbuf region.
209          *
210          * TODO: SADB_ACQUIRE filters should be implemented.
211          */
212         tlen = len;
213         m = mprev = NULL;
214         while (tlen > 0) {
215                 int nsize;
216
217                 n = m_getl(tlen, MB_DONTWAIT, MT_DATA,
218                            (tlen == len) ? M_PKTHDR : 0, &nsize);
219                 if (n == NULL) {
220                         m_freem(m);
221                         pfkeystat.in_nomem++;
222                         return ENOBUFS;
223                 }
224                 n->m_len = (tlen < n->m_len) ? tlen : nsize;
225
226                 if (m == NULL)
227                         m = mprev = n;
228                 else {
229                         mprev->m_next = n;
230                         mprev = n;
231                 }
232                 tlen -= n->m_len;
233         }
234         m->m_pkthdr.len = len;
235         m_copyback(m, 0, len, (caddr_t)msg);
236
237         /* avoid duplicated statistics */
238         pfkeystat.in_total--;
239         pfkeystat.in_bytes -= len;
240         pfkeystat.in_msgtype[msg->sadb_msg_type]--;
241
242         return key_sendup_mbuf(so, m, target);
243 }
244
245 /* so can be NULL if target != KEY_SENDUP_ONE */
246 int
247 key_sendup_mbuf(struct socket *so, struct mbuf *m, int target)
248 {
249         struct mbuf *n;
250         struct keycb *kp;
251         int sendup;
252         struct rawcb *rp;
253         int error = 0;
254
255         if (m == NULL)
256                 panic("key_sendup_mbuf: NULL pointer was passed.\n");
257         if (so == NULL && target == KEY_SENDUP_ONE)
258                 panic("key_sendup_mbuf: NULL pointer was passed.\n");
259
260         pfkeystat.in_total++;
261         pfkeystat.in_bytes += m->m_pkthdr.len;
262         if (m->m_len < sizeof(struct sadb_msg)) {
263 #if 1
264                 m = m_pullup(m, sizeof(struct sadb_msg));
265                 if (m == NULL) {
266                         pfkeystat.in_nomem++;
267                         return ENOBUFS;
268                 }
269 #else
270                 /* don't bother pulling it up just for stats */
271 #endif
272         }
273         if (m->m_len >= sizeof(struct sadb_msg)) {
274                 struct sadb_msg *msg;
275                 msg = mtod(m, struct sadb_msg *);
276                 pfkeystat.in_msgtype[msg->sadb_msg_type]++;
277         }
278
279         LIST_FOREACH(rp, &rawcb_list, list)
280         {
281                 if (rp->rcb_proto.sp_family != PF_KEY)
282                         continue;
283                 if (rp->rcb_proto.sp_protocol
284                  && rp->rcb_proto.sp_protocol != PF_KEY_V2) {
285                         continue;
286                 }
287
288                 kp = (struct keycb *)rp;
289
290                 /*
291                  * If you are in promiscuous mode, and when you get broadcasted
292                  * reply, you'll get two PF_KEY messages.
293                  * (based on pf_key@inner.net message on 14 Oct 1998)
294                  */
295                 if (((struct keycb *)rp)->kp_promisc) {
296                         if ((n = m_copy(m, 0, (int)M_COPYALL)) != NULL) {
297                                 key_sendup0(rp, n, 1);
298                                 n = NULL;
299                         }
300                 }
301
302                 /* the exact target will be processed later */
303                 if (so && sotorawcb(so) == rp)
304                         continue;
305
306                 sendup = 0;
307                 switch (target) {
308                 case KEY_SENDUP_ONE:
309                         /* the statement has no effect */
310                         if (so && sotorawcb(so) == rp)
311                                 sendup++;
312                         break;
313                 case KEY_SENDUP_ALL:
314                         sendup++;
315                         break;
316                 case KEY_SENDUP_REGISTERED:
317                         if (kp->kp_registered)
318                                 sendup++;
319                         break;
320                 }
321                 pfkeystat.in_msgtarget[target]++;
322
323                 if (!sendup)
324                         continue;
325
326                 if ((n = m_copy(m, 0, (int)M_COPYALL)) == NULL) {
327                         m_freem(m);
328                         pfkeystat.in_nomem++;
329                         return ENOBUFS;
330                 }
331
332                 if ((error = key_sendup0(rp, n, 0)) != 0) {
333                         m_freem(m);
334                         return error;
335                 }
336
337                 n = NULL;
338         }
339
340         if (so) {
341                 error = key_sendup0(sotorawcb(so), m, 0);
342                 m = NULL;
343         } else {
344                 error = 0;
345                 m_freem(m);
346         }
347         return error;
348 }
349
350 /*
351  * key_abort()
352  * derived from net/rtsock.c:rts_abort()
353  */
354 static int
355 key_abort(struct socket *so)
356 {
357         int error;
358         crit_enter();
359         error = raw_usrreqs.pru_abort(so);
360         crit_exit();
361         return error;
362 }
363
364 /*
365  * key_attach()
366  * derived from net/rtsock.c:rts_attach()
367  */
368 static int
369 key_attach(struct socket *so, int proto, struct pru_attach_info *ai)
370 {
371         struct keycb *kp;
372         int error;
373
374         if (sotorawcb(so) != 0)
375                 return EISCONN; /* XXX panic? */
376         kp = (struct keycb *)kmalloc(sizeof *kp, M_PCB, M_WAITOK|M_ZERO); /* XXX */
377
378         /*
379          * The critical section is necessary to block protocols from sending
380          * error notifications (like RTM_REDIRECT or RTM_LOSING) while
381          * this PCB is extant but incompletely initialized.
382          * Probably we should try to do more of this work beforehand and
383          * eliminate the spl.
384          */
385         crit_enter();
386         so->so_pcb = (caddr_t)kp;
387         error = raw_usrreqs.pru_attach(so, proto, ai);
388         kp = (struct keycb *)sotorawcb(so);
389         if (error) {
390                 kfree(kp, M_PCB);
391                 so->so_pcb = (caddr_t) 0;
392                 crit_exit();
393                 return error;
394         }
395
396         kp->kp_promisc = kp->kp_registered = 0;
397
398         if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
399                 key_cb.key_count++;
400         key_cb.any_count++;
401         kp->kp_raw.rcb_laddr = &key_src;
402         kp->kp_raw.rcb_faddr = &key_dst;
403         soisconnected(so);
404         so->so_options |= SO_USELOOPBACK;
405
406         crit_exit();
407         return 0;
408 }
409
410 /*
411  * key_bind()
412  * derived from net/rtsock.c:rts_bind()
413  */
414 static int
415 key_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
416 {
417         int error;
418         crit_enter();
419         error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */
420         crit_exit();
421         return error;
422 }
423
424 /*
425  * key_connect()
426  * derived from net/rtsock.c:rts_connect()
427  */
428 static int
429 key_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
430 {
431         int error;
432         crit_enter();
433         error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */
434         crit_exit();
435         return error;
436 }
437
438 /*
439  * key_detach()
440  * derived from net/rtsock.c:rts_detach()
441  */
442 static int
443 key_detach(struct socket *so)
444 {
445         struct keycb *kp = (struct keycb *)sotorawcb(so);
446         int error;
447
448         crit_enter();
449         if (kp != 0) {
450                 if (kp->kp_raw.rcb_proto.sp_protocol
451                     == PF_KEY) /* XXX: AF_KEY */
452                         key_cb.key_count--;
453                 key_cb.any_count--;
454
455                 key_freereg(so);
456         }
457         error = raw_usrreqs.pru_detach(so);
458         crit_exit();
459         return error;
460 }
461
462 /*
463  * key_disconnect()
464  * derived from net/rtsock.c:key_disconnect()
465  */
466 static int
467 key_disconnect(struct socket *so)
468 {
469         int error;
470         crit_enter();
471         error = raw_usrreqs.pru_disconnect(so);
472         crit_exit();
473         return error;
474 }
475
476 /*
477  * key_peeraddr()
478  * derived from net/rtsock.c:rts_peeraddr()
479  */
480 static int
481 key_peeraddr(struct socket *so, struct sockaddr **nam)
482 {
483         int error;
484         crit_enter();
485         error = raw_usrreqs.pru_peeraddr(so, nam);
486         crit_exit();
487         return error;
488 }
489
490 /*
491  * key_send()
492  * derived from net/rtsock.c:rts_send()
493  */
494 static int
495 key_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
496          struct mbuf *control, struct thread *td)
497 {
498         int error;
499         crit_enter();
500         error = raw_usrreqs.pru_send(so, flags, m, nam, control, td);
501         crit_exit();
502         return error;
503 }
504
505 /*
506  * key_shutdown()
507  * derived from net/rtsock.c:rts_shutdown()
508  */
509 static int
510 key_shutdown(struct socket *so)
511 {
512         int error;
513         crit_enter();
514         error = raw_usrreqs.pru_shutdown(so);
515         crit_exit();
516         return error;
517 }
518
519 /*
520  * key_sockaddr()
521  * derived from net/rtsock.c:rts_sockaddr()
522  */
523 static int
524 key_sockaddr(struct socket *so, struct sockaddr **nam)
525 {
526         int error;
527         crit_enter();
528         error = raw_usrreqs.pru_sockaddr(so, nam);
529         crit_exit();
530         return error;
531 }
532
533 struct pr_usrreqs key_usrreqs = {
534         .pru_abort = key_abort,
535         .pru_accept = pru_accept_notsupp,
536         .pru_attach = key_attach,
537         .pru_bind = key_bind,
538         .pru_connect = key_connect,
539         .pru_connect2 = pru_connect2_notsupp,
540         .pru_control = pru_control_notsupp,
541         .pru_detach = key_detach,
542         .pru_disconnect = key_disconnect,
543         .pru_listen = pru_listen_notsupp,
544         .pru_peeraddr = key_peeraddr,
545         .pru_rcvd = pru_rcvd_notsupp,
546         .pru_rcvoob = pru_rcvoob_notsupp,
547         .pru_send = key_send,
548         .pru_sense = pru_sense_null,
549         .pru_shutdown = key_shutdown,
550         .pru_sockaddr = key_sockaddr,
551         .pru_sosend = sosend,
552         .pru_soreceive = soreceive,
553         .pru_sopoll = sopoll
554 };
555
556 /* sysctl */
557 SYSCTL_NODE(_net, PF_KEY, key, CTLFLAG_RW, 0, "Key Family");
558
559 /*
560  * Definitions of protocols supported in the KEY domain.
561  */
562
563 extern struct domain keydomain;
564
565 struct protosw keysw[] = {
566 { SOCK_RAW,     &keydomain,     PF_KEY_V2,      PR_ATOMIC|PR_ADDR,
567   0,            key_output,     raw_ctlinput,   0,
568   cpu0_soport,  cpu0_ctlport,
569   raw_init,     0,              0,              0,
570   &key_usrreqs
571 }
572 };
573
574 static void
575 key_init0(void)
576 {
577         bzero((caddr_t)&key_cb, sizeof(key_cb));
578         key_init();
579 }
580
581 struct domain keydomain = {
582         PF_KEY, "key", key_init0, NULL, NULL,
583         keysw, &keysw[sizeof(keysw)/sizeof(keysw[0])],
584 };
585
586 DOMAIN_SET(key);