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