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