keysock.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: keysock.c,v 1.70 2019/06/12 22:23:50 christos Exp $    */
    2 /*      $FreeBSD: keysock.c,v 1.3.2.1 2003/01/24 05:11:36 sam 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 <sys/cdefs.h>
   35 __KERNEL_RCSID(0, "$NetBSD: keysock.c,v 1.70 2019/06/12 22:23:50 christos Exp $");
   36 
   37 /* This code has derived from sys/net/rtsock.c on FreeBSD2.2.5 */
   38 
   39 #include <sys/types.h>
   40 #include <sys/param.h>
   41 #include <sys/domain.h>
   42 #include <sys/errno.h>
   43 #include <sys/kernel.h>
   44 #include <sys/kmem.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/protosw.h>
   47 #include <sys/signalvar.h>
   48 #include <sys/socket.h>
   49 #include <sys/socketvar.h>
   50 #include <sys/sysctl.h>
   51 #include <sys/systm.h>
   52 #include <sys/cpu.h>
   53 #include <sys/syslog.h>
   54 
   55 #include <net/raw_cb.h>
   56 #include <net/route.h>
   57 
   58 #include <net/pfkeyv2.h>
   59 #include <netipsec/key.h>
   60 #include <netipsec/keysock.h>
   61 #include <netipsec/key_debug.h>
   62 
   63 #include <netipsec/ipsec_private.h>
   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 = {
   72     .sa_len = 2,
   73     .sa_family = PF_KEY,
   74 };
   75 static struct sockaddr key_src = {
   76     .sa_len = 2,
   77     .sa_family = PF_KEY,
   78 };
   79 
   80 static const struct protosw keysw[];
   81 
   82 static int key_sendup0(struct rawcb *, struct mbuf *, int, int);
   83 
   84 int key_registered_sb_max = (2048 * MHLEN); /* XXX arbitrary */
   85 
   86 static kmutex_t *key_so_mtx;
   87 static struct rawcbhead key_rawcb;
   88 
   89 void
   90 key_init_so(void)
   91 {
   92 
   93         key_so_mtx = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
   94 }
   95 
   96 static void
   97 key_pr_init(void)
   98 {
   99 
  100         LIST_INIT(&key_rawcb);
  101 }
  102 
  103 /*
  104  * key_output()
  105  */
  106 static int
  107 key_output(struct mbuf *m, struct socket *so)
  108 {
  109         struct sadb_msg *msg;
  110         int len, error = 0;
  111         int s;
  112 
  113         KASSERT(m != NULL);
  114 
  115         {
  116                 uint64_t *ps = PFKEY_STAT_GETREF();
  117                 ps[PFKEY_STAT_OUT_TOTAL]++;
  118                 ps[PFKEY_STAT_OUT_BYTES] += m->m_pkthdr.len;
  119                 PFKEY_STAT_PUTREF();
  120         }
  121 
  122         len = m->m_pkthdr.len;
  123         if (len < sizeof(struct sadb_msg)) {
  124                 PFKEY_STATINC(PFKEY_STAT_OUT_TOOSHORT);
  125                 error = EINVAL;
  126                 goto end;
  127         }
  128 
  129         if (m->m_len < sizeof(struct sadb_msg)) {
  130                 if ((m = m_pullup(m, sizeof(struct sadb_msg))) == 0) {
  131                         PFKEY_STATINC(PFKEY_STAT_OUT_NOMEM);
  132                         error = ENOBUFS;
  133                         goto end;
  134                 }
  135         }
  136 
  137         KASSERT((m->m_flags & M_PKTHDR) != 0);
  138 
  139         if (KEYDEBUG_ON(KEYDEBUG_KEY_DUMP))
  140                 kdebug_mbuf(__func__, m);
  141 
  142         msg = mtod(m, struct sadb_msg *);
  143         PFKEY_STATINC(PFKEY_STAT_OUT_MSGTYPE + msg->sadb_msg_type);
  144         if (len != PFKEY_UNUNIT64(msg->sadb_msg_len)) {
  145                 PFKEY_STATINC(PFKEY_STAT_OUT_INVLEN);
  146                 error = EINVAL;
  147                 goto end;
  148         }
  149 
  150         /*XXX giant lock*/
  151         s = splsoftnet();
  152         error = key_parse(m, so);
  153         m = NULL;
  154         splx(s);
  155 end:
  156         if (m)
  157                 m_freem(m);
  158         return error;
  159 }
  160 
  161 /*
  162  * send message to the socket.
  163  */
  164 static int
  165 key_sendup0(
  166     struct rawcb *rp,
  167     struct mbuf *m,
  168     int promisc,
  169     int sbprio
  170 )
  171 {
  172         int error;
  173         int ok;
  174 
  175         if (promisc) {
  176                 struct sadb_msg *pmsg;
  177 
  178                 M_PREPEND(m, sizeof(struct sadb_msg), M_DONTWAIT);
  179                 if (m && m->m_len < sizeof(struct sadb_msg))
  180                         m = m_pullup(m, sizeof(struct sadb_msg));
  181                 if (!m) {
  182                         PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
  183                         return ENOBUFS;
  184                 }
  185                 m->m_pkthdr.len += sizeof(*pmsg);
  186 
  187                 pmsg = mtod(m, struct sadb_msg *);
  188                 memset(pmsg, 0, sizeof(*pmsg));
  189                 pmsg->sadb_msg_version = PF_KEY_V2;
  190                 pmsg->sadb_msg_type = SADB_X_PROMISC;
  191                 pmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
  192                 /* pid and seq? */
  193 
  194                 PFKEY_STATINC(PFKEY_STAT_IN_MSGTYPE + pmsg->sadb_msg_type);
  195         }
  196 
  197         if (sbprio == 0)
  198                 ok = sbappendaddr(&rp->rcb_socket->so_rcv,
  199                                (struct sockaddr *)&key_src, m, NULL);
  200         else
  201                 ok = sbappendaddrchain(&rp->rcb_socket->so_rcv,
  202                                (struct sockaddr *)&key_src, m, sbprio);
  203 
  204         if (!ok) {
  205                 log(LOG_WARNING,
  206                     "%s: couldn't send PF_KEY message to the socket\n",
  207                     __func__);
  208                 PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
  209                 m_freem(m);
  210                 /* Don't call soroverflow because we're returning this
  211                  * error directly to the sender. */
  212                 rp->rcb_socket->so_rcv.sb_overflowed++;
  213                 error = ENOBUFS;
  214         } else {
  215                 sorwakeup(rp->rcb_socket);
  216                 error = 0;
  217         }
  218         return error;
  219 }
  220 
  221 /* so can be NULL if target != KEY_SENDUP_ONE */
  222 static int
  223 _key_sendup_mbuf(struct socket *so, struct mbuf *m,
  224                 int target/*, sbprio */)
  225 {
  226         struct mbuf *n;
  227         struct keycb *kp;
  228         int sendup;
  229         struct rawcb *rp;
  230         int error = 0;
  231         int sbprio = 0; /* XXX should be a parameter */
  232 
  233         KASSERT(m != NULL);
  234         KASSERT(so != NULL || target != KEY_SENDUP_ONE);
  235 
  236         /*
  237          * RFC 2367 says ACQUIRE and other kernel-generated messages
  238          * are special. We treat all KEY_SENDUP_REGISTERED messages
  239          * as special, delivering them to all registered sockets
  240          * even if the socket is at or above its so->so_rcv.sb_max limits.
  241          * The only constraint is that the  so_rcv data fall below
  242          * key_registered_sb_max.
  243          * Doing that check here avoids reworking every key_sendup_mbuf()
  244          * in the short term. . The rework will be done after a technical
  245          * conensus that this approach is appropriate.
  246          */
  247         if (target == KEY_SENDUP_REGISTERED) {
  248                 sbprio = SB_PRIO_BESTEFFORT;
  249         }
  250 
  251         {
  252                 uint64_t *ps = PFKEY_STAT_GETREF();
  253                 ps[PFKEY_STAT_IN_TOTAL]++;
  254                 ps[PFKEY_STAT_IN_BYTES] += m->m_pkthdr.len;
  255                 PFKEY_STAT_PUTREF();
  256         }
  257         if (m->m_len < sizeof(struct sadb_msg)) {
  258 #if 1
  259                 m = m_pullup(m, sizeof(struct sadb_msg));
  260                 if (m == NULL) {
  261                         PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
  262                         return ENOBUFS;
  263                 }
  264 #else
  265                 /* don't bother pulling it up just for stats */
  266 #endif
  267         }
  268         if (m->m_len >= sizeof(struct sadb_msg)) {
  269                 struct sadb_msg *msg;
  270                 msg = mtod(m, struct sadb_msg *);
  271                 PFKEY_STATINC(PFKEY_STAT_IN_MSGTYPE + msg->sadb_msg_type);
  272         }
  273 
  274         LIST_FOREACH(rp, &key_rawcb, rcb_list)
  275         {
  276                 struct socket * kso = rp->rcb_socket;
  277                 if (rp->rcb_proto.sp_family != PF_KEY)
  278                         continue;
  279                 if (rp->rcb_proto.sp_protocol
  280                  && rp->rcb_proto.sp_protocol != PF_KEY_V2) {
  281                         continue;
  282                 }
  283 
  284                 kp = (struct keycb *)rp;
  285 
  286                 /*
  287                  * If you are in promiscuous mode, and when you get broadcasted
  288                  * reply, you'll get two PF_KEY messages.
  289                  * (based on pf_key@inner.net message on 14 Oct 1998)
  290                  */
  291                 if (((struct keycb *)rp)->kp_promisc) {
  292                         if ((n = m_copym(m, 0, (int)M_COPYALL, M_DONTWAIT)) != NULL) {
  293                                 (void)key_sendup0(rp, n, 1, 0);
  294                                 n = NULL;
  295                         }
  296                 }
  297 
  298                 /* the exact target will be processed later */
  299                 if (so && sotorawcb(so) == rp)
  300                         continue;
  301 
  302                 sendup = 0;
  303                 switch (target) {
  304                 case KEY_SENDUP_ONE:
  305                         /* the statement has no effect */
  306                         if (so && sotorawcb(so) == rp)
  307                                 sendup++;
  308                         break;
  309                 case KEY_SENDUP_ALL:
  310                         sendup++;
  311                         break;
  312                 case KEY_SENDUP_REGISTERED:
  313                         if (kp->kp_registered) {
  314                                 if (kso->so_rcv.sb_cc <= key_registered_sb_max)
  315                                         sendup++;
  316                                 else
  317                                         printf("keysock: "
  318                                                "registered sendup dropped, "
  319                                                "sb_cc %ld max %d\n",
  320                                                kso->so_rcv.sb_cc,
  321                                                key_registered_sb_max);
  322                         }
  323                         break;
  324                 }
  325                 PFKEY_STATINC(PFKEY_STAT_IN_MSGTARGET + target);
  326 
  327                 if (!sendup)
  328                         continue;
  329 
  330                 if ((n = m_copym(m, 0, (int)M_COPYALL, M_DONTWAIT)) == NULL) {
  331                         m_freem(m);
  332                         PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
  333                         return ENOBUFS;
  334                 }
  335 
  336                 if ((error = key_sendup0(rp, n, 0, 0)) != 0) {
  337                         m_freem(m);
  338                         return error;
  339                 }
  340 
  341                 n = NULL;
  342         }
  343 
  344         /* The 'later' time for processing the exact target has arrived */
  345         if (so) {
  346                 error = key_sendup0(sotorawcb(so), m, 0, sbprio);
  347                 m = NULL;
  348         } else {
  349                 error = 0;
  350                 m_freem(m);
  351         }
  352         return error;
  353 }
  354 
  355 int
  356 key_sendup_mbuf(struct socket *so, struct mbuf *m,
  357                 int target/*, sbprio */)
  358 {
  359         int error;
  360 
  361         if (so == NULL)
  362                 mutex_enter(key_so_mtx);
  363         else
  364                 KASSERT(solocked(so));
  365 
  366         error = _key_sendup_mbuf(so, m, target);
  367 
  368         if (so == NULL)
  369                 mutex_exit(key_so_mtx);
  370         return error;
  371 }
  372 
  373 static int
  374 key_attach(struct socket *so, int proto)
  375 {
  376         struct keycb *kp;
  377         int s, error;
  378 
  379         KASSERT(sotorawcb(so) == NULL);
  380         kp = kmem_zalloc(sizeof(*kp), KM_SLEEP);
  381         kp->kp_raw.rcb_len = sizeof(*kp);
  382         so->so_pcb = kp;
  383 
  384         s = splsoftnet();
  385 
  386         if (so->so_lock != key_so_mtx) {
  387                 KASSERT(so->so_lock == NULL);
  388                 mutex_obj_hold(key_so_mtx);
  389                 so->so_lock = key_so_mtx;
  390                 solock(so);
  391         }
  392 
  393         error = raw_attach(so, proto, &key_rawcb);
  394         if (error) {
  395                 PFKEY_STATINC(PFKEY_STAT_SOCKERR);
  396                 kmem_free(kp, sizeof(*kp));
  397                 so->so_pcb = NULL;
  398                 goto out;
  399         }
  400 
  401         kp->kp_promisc = kp->kp_registered = 0;
  402 
  403         if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
  404                 key_cb.key_count++;
  405         key_cb.any_count++;
  406         kp->kp_raw.rcb_laddr = &key_src;
  407         kp->kp_raw.rcb_faddr = &key_dst;
  408         soisconnected(so);
  409         so->so_options |= SO_USELOOPBACK;
  410 out:
  411         KASSERT(solocked(so));
  412         splx(s);
  413         return error;
  414 }
  415 
  416 static void
  417 key_detach(struct socket *so)
  418 {
  419         struct keycb *kp = (struct keycb *)sotorawcb(so);
  420         int s;
  421 
  422         KASSERT(!cpu_softintr_p());
  423         KASSERT(solocked(so));
  424         KASSERT(kp != NULL);
  425 
  426         s = splsoftnet();
  427         if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
  428                 key_cb.key_count--;
  429         key_cb.any_count--;
  430         key_freereg(so);
  431         raw_detach(so);
  432         splx(s);
  433 }
  434 
  435 static int
  436 key_accept(struct socket *so, struct sockaddr *nam)
  437 {
  438         KASSERT(solocked(so));
  439 
  440         panic("%s: unsupported", __func__);
  441 
  442         return EOPNOTSUPP;
  443 }
  444 
  445 static int
  446 key_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
  447 {
  448         KASSERT(solocked(so));
  449 
  450         return EOPNOTSUPP;
  451 }
  452 
  453 static int
  454 key_listen(struct socket *so, struct lwp *l)
  455 {
  456         KASSERT(solocked(so));
  457 
  458         return EOPNOTSUPP;
  459 }
  460 
  461 static int
  462 key_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
  463 {
  464         KASSERT(solocked(so));
  465 
  466         return EOPNOTSUPP;
  467 }
  468 
  469 static int
  470 key_connect2(struct socket *so, struct socket *so2)
  471 {
  472         KASSERT(solocked(so));
  473 
  474         return EOPNOTSUPP;
  475 }
  476 
  477 static int
  478 key_disconnect(struct socket *so)
  479 {
  480         struct rawcb *rp = sotorawcb(so);
  481         int s;
  482         
  483         KASSERT(solocked(so));
  484         KASSERT(rp != NULL);
  485 
  486         s = splsoftnet();
  487         soisdisconnected(so);
  488         raw_disconnect(rp);
  489         splx(s);
  490  
  491         return 0;                               
  492 }
  493 
  494 static int
  495 key_shutdown(struct socket *so)
  496 {
  497         int s;
  498 
  499         KASSERT(solocked(so));
  500 
  501         /*
  502          * Mark the connection as being incapable of further input.
  503          */
  504         s = splsoftnet();
  505         socantsendmore(so);
  506         splx(s);
  507 
  508         return 0;
  509 }
  510 
  511 static int
  512 key_abort(struct socket *so)
  513 {
  514         KASSERT(solocked(so));
  515 
  516         panic("%s: unsupported", __func__);
  517 
  518         return EOPNOTSUPP;
  519 }
  520 
  521 static int
  522 key_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
  523 {
  524         return EOPNOTSUPP;
  525 }
  526 
  527 static int
  528 key_stat(struct socket *so, struct stat *ub)
  529 {
  530         KASSERT(solocked(so));
  531 
  532         return 0;
  533 }
  534 
  535 static int
  536 key_peeraddr(struct socket *so, struct sockaddr *nam)
  537 {
  538         struct rawcb *rp = sotorawcb(so);
  539 
  540         KASSERT(solocked(so));
  541         KASSERT(rp != NULL);
  542         KASSERT(nam != NULL);
  543 
  544         if (rp->rcb_faddr == NULL)
  545                 return ENOTCONN;
  546 
  547         raw_setpeeraddr(rp, nam);
  548         return 0;
  549 }
  550 
  551 static int
  552 key_sockaddr(struct socket *so, struct sockaddr *nam)
  553 {
  554         struct rawcb *rp = sotorawcb(so);
  555 
  556         KASSERT(solocked(so));
  557         KASSERT(rp != NULL);
  558         KASSERT(nam != NULL);
  559 
  560         if (rp->rcb_faddr == NULL)
  561                 return ENOTCONN;
  562 
  563         raw_setsockaddr(rp, nam);
  564         return 0;
  565 }
  566 
  567 static int
  568 key_rcvd(struct socket *so, int flags, struct lwp *l)
  569 {
  570         KASSERT(solocked(so));
  571 
  572         return EOPNOTSUPP;
  573 }
  574 
  575 static int
  576 key_recvoob(struct socket *so, struct mbuf *m, int flags)
  577 {
  578         KASSERT(solocked(so));
  579 
  580         return EOPNOTSUPP;
  581 }
  582 
  583 static int
  584 key_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
  585     struct mbuf *control, struct lwp *l)
  586 {
  587         int error = 0;
  588         int s;
  589 
  590         KASSERT(solocked(so));
  591         KASSERT(so->so_proto == &keysw[0]);
  592 
  593         s = splsoftnet();
  594         error = raw_send(so, m, nam, control, l, &key_output);
  595         splx(s);
  596 
  597         return error;
  598 }
  599 
  600 static int
  601 key_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
  602 {
  603         KASSERT(solocked(so));
  604 
  605         m_freem(m);
  606         m_freem(control);
  607 
  608         return EOPNOTSUPP;
  609 }
  610 
  611 static int
  612 key_purgeif(struct socket *so, struct ifnet *ifa)
  613 {
  614 
  615         panic("%s: unsupported", __func__);
  616 
  617         return EOPNOTSUPP;
  618 }
  619 
  620 /*
  621  * Definitions of protocols supported in the KEY domain.
  622  */
  623 
  624 DOMAIN_DEFINE(keydomain);
  625 
  626 PR_WRAP_USRREQS(key)
  627 #define key_attach      key_attach_wrapper
  628 #define key_detach      key_detach_wrapper
  629 #define key_accept      key_accept_wrapper
  630 #define key_bind        key_bind_wrapper
  631 #define key_listen      key_listen_wrapper
  632 #define key_connect     key_connect_wrapper
  633 #define key_connect2    key_connect2_wrapper
  634 #define key_disconnect  key_disconnect_wrapper
  635 #define key_shutdown    key_shutdown_wrapper
  636 #define key_abort       key_abort_wrapper
  637 #define key_ioctl       key_ioctl_wrapper
  638 #define key_stat        key_stat_wrapper
  639 #define key_peeraddr    key_peeraddr_wrapper
  640 #define key_sockaddr    key_sockaddr_wrapper
  641 #define key_rcvd        key_rcvd_wrapper
  642 #define key_recvoob     key_recvoob_wrapper
  643 #define key_send        key_send_wrapper
  644 #define key_sendoob     key_sendoob_wrapper
  645 #define key_purgeif     key_purgeif_wrapper
  646 
  647 static const struct pr_usrreqs key_usrreqs = {
  648         .pr_attach      = key_attach,
  649         .pr_detach      = key_detach,
  650         .pr_accept      = key_accept,
  651         .pr_bind        = key_bind,
  652         .pr_listen      = key_listen,
  653         .pr_connect     = key_connect,
  654         .pr_connect2    = key_connect2,
  655         .pr_disconnect  = key_disconnect,
  656         .pr_shutdown    = key_shutdown,
  657         .pr_abort       = key_abort,
  658         .pr_ioctl       = key_ioctl,
  659         .pr_stat        = key_stat,
  660         .pr_peeraddr    = key_peeraddr,
  661         .pr_sockaddr    = key_sockaddr,
  662         .pr_rcvd        = key_rcvd,
  663         .pr_recvoob     = key_recvoob,
  664         .pr_send        = key_send,
  665         .pr_sendoob     = key_sendoob,
  666         .pr_purgeif     = key_purgeif,
  667 };
  668 
  669 static const struct protosw keysw[] = {
  670     {
  671         .pr_type = SOCK_RAW,
  672         .pr_domain = &keydomain,
  673         .pr_protocol = PF_KEY_V2,
  674         .pr_flags = PR_ATOMIC|PR_ADDR,
  675         .pr_ctlinput = raw_ctlinput,
  676         .pr_usrreqs = &key_usrreqs,
  677         .pr_init = key_pr_init,
  678     }
  679 };
  680 
  681 struct domain keydomain = {
  682     .dom_family = PF_KEY,
  683     .dom_name = "key",
  684     .dom_init = key_init,
  685     .dom_protosw = keysw,
  686     .dom_protoswNPROTOSW = &keysw[__arraycount(keysw)],
  687 };
Cache object: 2ab793334b2c737e1ee28d0c6203987f
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netipsec/keysock.c

FreeBSD/Linux Kernel Cross Reference
sys/netipsec/keysock.c
