The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet6/raw_ip6.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of the project nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 /*-
   31  * Copyright (c) 1982, 1986, 1988, 1993
   32  *      The Regents of the University of California.
   33  * All rights reserved.
   34  *
   35  * Redistribution and use in source and binary forms, with or without
   36  * modification, are permitted provided that the following conditions
   37  * are met:
   38  * 1. Redistributions of source code must retain the above copyright
   39  *    notice, this list of conditions and the following disclaimer.
   40  * 2. Redistributions in binary form must reproduce the above copyright
   41  *    notice, this list of conditions and the following disclaimer in the
   42  *    documentation and/or other materials provided with the distribution.
   43  * 4. Neither the name of the University nor the names of its contributors
   44  *    may be used to endorse or promote products derived from this software
   45  *    without specific prior written permission.
   46  *
   47  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   57  * SUCH DAMAGE.
   58  *
   59  *      @(#)raw_ip.c    8.2 (Berkeley) 1/4/94
   60  */
   61 
   62 #include <sys/cdefs.h>
   63 __FBSDID("$FreeBSD: releng/10.0/sys/netinet6/raw_ip6.c 253571 2013-07-23 14:14:24Z ae $");
   64 
   65 #include "opt_ipsec.h"
   66 #include "opt_inet6.h"
   67 
   68 #include <sys/param.h>
   69 #include <sys/errno.h>
   70 #include <sys/jail.h>
   71 #include <sys/kernel.h>
   72 #include <sys/lock.h>
   73 #include <sys/malloc.h>
   74 #include <sys/mbuf.h>
   75 #include <sys/priv.h>
   76 #include <sys/proc.h>
   77 #include <sys/protosw.h>
   78 #include <sys/signalvar.h>
   79 #include <sys/socket.h>
   80 #include <sys/socketvar.h>
   81 #include <sys/sx.h>
   82 #include <sys/syslog.h>
   83 
   84 #include <net/if.h>
   85 #include <net/if_types.h>
   86 #include <net/route.h>
   87 #include <net/vnet.h>
   88 
   89 #include <netinet/in.h>
   90 #include <netinet/in_var.h>
   91 #include <netinet/in_systm.h>
   92 #include <netinet/in_pcb.h>
   93 
   94 #include <netinet/icmp6.h>
   95 #include <netinet/ip6.h>
   96 #include <netinet/ip_var.h>
   97 #include <netinet6/ip6protosw.h>
   98 #include <netinet6/ip6_mroute.h>
   99 #include <netinet6/in6_pcb.h>
  100 #include <netinet6/ip6_var.h>
  101 #include <netinet6/nd6.h>
  102 #include <netinet6/raw_ip6.h>
  103 #include <netinet6/scope6_var.h>
  104 #include <netinet6/send.h>
  105 
  106 #ifdef IPSEC
  107 #include <netipsec/ipsec.h>
  108 #include <netipsec/ipsec6.h>
  109 #endif /* IPSEC */
  110 
  111 #include <machine/stdarg.h>
  112 
  113 #define satosin6(sa)    ((struct sockaddr_in6 *)(sa))
  114 #define ifatoia6(ifa)   ((struct in6_ifaddr *)(ifa))
  115 
  116 /*
  117  * Raw interface to IP6 protocol.
  118  */
  119 
  120 VNET_DECLARE(struct inpcbhead, ripcb);
  121 VNET_DECLARE(struct inpcbinfo, ripcbinfo);
  122 #define V_ripcb                         VNET(ripcb)
  123 #define V_ripcbinfo                     VNET(ripcbinfo)
  124 
  125 extern u_long   rip_sendspace;
  126 extern u_long   rip_recvspace;
  127 
  128 VNET_PCPUSTAT_DEFINE(struct rip6stat, rip6stat);
  129 VNET_PCPUSTAT_SYSINIT(rip6stat);
  130 
  131 #ifdef VIMAGE
  132 VNET_PCPUSTAT_SYSUNINIT(rip6stat);
  133 #endif /* VIMAGE */
  134 
  135 /*
  136  * Hooks for multicast routing. They all default to NULL, so leave them not
  137  * initialized and rely on BSS being set to 0.
  138  */
  139 
  140 /*
  141  * The socket used to communicate with the multicast routing daemon.
  142  */
  143 VNET_DEFINE(struct socket *, ip6_mrouter);
  144 
  145 /*
  146  * The various mrouter functions.
  147  */
  148 int (*ip6_mrouter_set)(struct socket *, struct sockopt *);
  149 int (*ip6_mrouter_get)(struct socket *, struct sockopt *);
  150 int (*ip6_mrouter_done)(void);
  151 int (*ip6_mforward)(struct ip6_hdr *, struct ifnet *, struct mbuf *);
  152 int (*mrt6_ioctl)(u_long, caddr_t);
  153 
  154 /*
  155  * Setup generic address and protocol structures for raw_input routine, then
  156  * pass them along with mbuf chain.
  157  */
  158 int
  159 rip6_input(struct mbuf **mp, int *offp, int proto)
  160 {
  161         struct ifnet *ifp;
  162         struct mbuf *m = *mp;
  163         register struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
  164         register struct inpcb *in6p;
  165         struct inpcb *last = 0;
  166         struct mbuf *opts = NULL;
  167         struct sockaddr_in6 fromsa;
  168 
  169         RIP6STAT_INC(rip6s_ipackets);
  170 
  171         if (faithprefix_p != NULL && (*faithprefix_p)(&ip6->ip6_dst)) {
  172                 /* XXX Send icmp6 host/port unreach? */
  173                 m_freem(m);
  174                 return (IPPROTO_DONE);
  175         }
  176 
  177         init_sin6(&fromsa, m); /* general init */
  178 
  179         ifp = m->m_pkthdr.rcvif;
  180 
  181         INP_INFO_RLOCK(&V_ripcbinfo);
  182         LIST_FOREACH(in6p, &V_ripcb, inp_list) {
  183                 /* XXX inp locking */
  184                 if ((in6p->inp_vflag & INP_IPV6) == 0)
  185                         continue;
  186                 if (in6p->inp_ip_p &&
  187                     in6p->inp_ip_p != proto)
  188                         continue;
  189                 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) &&
  190                     !IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &ip6->ip6_dst))
  191                         continue;
  192                 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr) &&
  193                     !IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, &ip6->ip6_src))
  194                         continue;
  195                 if (jailed_without_vnet(in6p->inp_cred)) {
  196                         /*
  197                          * Allow raw socket in jail to receive multicast;
  198                          * assume process had PRIV_NETINET_RAW at attach,
  199                          * and fall through into normal filter path if so.
  200                          */
  201                         if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
  202                             prison_check_ip6(in6p->inp_cred,
  203                             &ip6->ip6_dst) != 0)
  204                                 continue;
  205                 }
  206                 INP_RLOCK(in6p);
  207                 if (in6p->in6p_cksum != -1) {
  208                         RIP6STAT_INC(rip6s_isum);
  209                         if (in6_cksum(m, proto, *offp,
  210                             m->m_pkthdr.len - *offp)) {
  211                                 INP_RUNLOCK(in6p);
  212                                 RIP6STAT_INC(rip6s_badsum);
  213                                 continue;
  214                         }
  215                 }
  216                 /*
  217                  * If this raw socket has multicast state, and we
  218                  * have received a multicast, check if this socket
  219                  * should receive it, as multicast filtering is now
  220                  * the responsibility of the transport layer.
  221                  */
  222                 if (in6p->in6p_moptions &&
  223                     IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
  224                         /*
  225                          * If the incoming datagram is for MLD, allow it
  226                          * through unconditionally to the raw socket.
  227                          *
  228                          * Use the M_RTALERT_MLD flag to check for MLD
  229                          * traffic without having to inspect the mbuf chain
  230                          * more deeply, as all MLDv1/v2 host messages MUST
  231                          * contain the Router Alert option.
  232                          *
  233                          * In the case of MLDv1, we may not have explicitly
  234                          * joined the group, and may have set IFF_ALLMULTI
  235                          * on the interface. im6o_mc_filter() may discard
  236                          * control traffic we actually need to see.
  237                          *
  238                          * Userland multicast routing daemons should continue
  239                          * filter the control traffic appropriately.
  240                          */
  241                         int blocked;
  242 
  243                         blocked = MCAST_PASS;
  244                         if ((m->m_flags & M_RTALERT_MLD) == 0) {
  245                                 struct sockaddr_in6 mcaddr;
  246 
  247                                 bzero(&mcaddr, sizeof(struct sockaddr_in6));
  248                                 mcaddr.sin6_len = sizeof(struct sockaddr_in6);
  249                                 mcaddr.sin6_family = AF_INET6;
  250                                 mcaddr.sin6_addr = ip6->ip6_dst;
  251 
  252                                 blocked = im6o_mc_filter(in6p->in6p_moptions,
  253                                     ifp,
  254                                     (struct sockaddr *)&mcaddr,
  255                                     (struct sockaddr *)&fromsa);
  256                         }
  257                         if (blocked != MCAST_PASS) {
  258                                 IP6STAT_INC(ip6s_notmember);
  259                                 INP_RUNLOCK(in6p);
  260                                 continue;
  261                         }
  262                 }
  263                 if (last != NULL) {
  264                         struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
  265 
  266 #ifdef IPSEC
  267                         /*
  268                          * Check AH/ESP integrity.
  269                          */
  270                         if (n && ipsec6_in_reject(n, last)) {
  271                                 m_freem(n);
  272                                 IPSEC6STAT_INC(ips_in_polvio);
  273                                 /* Do not inject data into pcb. */
  274                         } else
  275 #endif /* IPSEC */
  276                         if (n) {
  277                                 if (last->inp_flags & INP_CONTROLOPTS ||
  278                                     last->inp_socket->so_options & SO_TIMESTAMP)
  279                                         ip6_savecontrol(last, n, &opts);
  280                                 /* strip intermediate headers */
  281                                 m_adj(n, *offp);
  282                                 if (sbappendaddr(&last->inp_socket->so_rcv,
  283                                                 (struct sockaddr *)&fromsa,
  284                                                  n, opts) == 0) {
  285                                         m_freem(n);
  286                                         if (opts)
  287                                                 m_freem(opts);
  288                                         RIP6STAT_INC(rip6s_fullsock);
  289                                 } else
  290                                         sorwakeup(last->inp_socket);
  291                                 opts = NULL;
  292                         }
  293                         INP_RUNLOCK(last);
  294                 }
  295                 last = in6p;
  296         }
  297         INP_INFO_RUNLOCK(&V_ripcbinfo);
  298 #ifdef IPSEC
  299         /*
  300          * Check AH/ESP integrity.
  301          */
  302         if ((last != NULL) && ipsec6_in_reject(m, last)) {
  303                 m_freem(m);
  304                 IPSEC6STAT_INC(ips_in_polvio);
  305                 IP6STAT_DEC(ip6s_delivered);
  306                 /* Do not inject data into pcb. */
  307                 INP_RUNLOCK(last);
  308         } else
  309 #endif /* IPSEC */
  310         if (last != NULL) {
  311                 if (last->inp_flags & INP_CONTROLOPTS ||
  312                     last->inp_socket->so_options & SO_TIMESTAMP)
  313                         ip6_savecontrol(last, m, &opts);
  314                 /* Strip intermediate headers. */
  315                 m_adj(m, *offp);
  316                 if (sbappendaddr(&last->inp_socket->so_rcv,
  317                     (struct sockaddr *)&fromsa, m, opts) == 0) {
  318                         m_freem(m);
  319                         if (opts)
  320                                 m_freem(opts);
  321                         RIP6STAT_INC(rip6s_fullsock);
  322                 } else
  323                         sorwakeup(last->inp_socket);
  324                 INP_RUNLOCK(last);
  325         } else {
  326                 RIP6STAT_INC(rip6s_nosock);
  327                 if (m->m_flags & M_MCAST)
  328                         RIP6STAT_INC(rip6s_nosockmcast);
  329                 if (proto == IPPROTO_NONE)
  330                         m_freem(m);
  331                 else {
  332                         char *prvnxtp = ip6_get_prevhdr(m, *offp); /* XXX */
  333                         icmp6_error(m, ICMP6_PARAM_PROB,
  334                             ICMP6_PARAMPROB_NEXTHEADER,
  335                             prvnxtp - mtod(m, char *));
  336                 }
  337                 IP6STAT_DEC(ip6s_delivered);
  338         }
  339         return (IPPROTO_DONE);
  340 }
  341 
  342 void
  343 rip6_ctlinput(int cmd, struct sockaddr *sa, void *d)
  344 {
  345         struct ip6_hdr *ip6;
  346         struct mbuf *m;
  347         int off = 0;
  348         struct ip6ctlparam *ip6cp = NULL;
  349         const struct sockaddr_in6 *sa6_src = NULL;
  350         void *cmdarg;
  351         struct inpcb *(*notify)(struct inpcb *, int) = in6_rtchange;
  352 
  353         if (sa->sa_family != AF_INET6 ||
  354             sa->sa_len != sizeof(struct sockaddr_in6))
  355                 return;
  356 
  357         if ((unsigned)cmd >= PRC_NCMDS)
  358                 return;
  359         if (PRC_IS_REDIRECT(cmd))
  360                 notify = in6_rtchange, d = NULL;
  361         else if (cmd == PRC_HOSTDEAD)
  362                 d = NULL;
  363         else if (inet6ctlerrmap[cmd] == 0)
  364                 return;
  365 
  366         /*
  367          * If the parameter is from icmp6, decode it.
  368          */
  369         if (d != NULL) {
  370                 ip6cp = (struct ip6ctlparam *)d;
  371                 m = ip6cp->ip6c_m;
  372                 ip6 = ip6cp->ip6c_ip6;
  373                 off = ip6cp->ip6c_off;
  374                 cmdarg = ip6cp->ip6c_cmdarg;
  375                 sa6_src = ip6cp->ip6c_src;
  376         } else {
  377                 m = NULL;
  378                 ip6 = NULL;
  379                 cmdarg = NULL;
  380                 sa6_src = &sa6_any;
  381         }
  382 
  383         (void) in6_pcbnotify(&V_ripcbinfo, sa, 0,
  384             (const struct sockaddr *)sa6_src, 0, cmd, cmdarg, notify);
  385 }
  386 
  387 /*
  388  * Generate IPv6 header and pass packet to ip6_output.  Tack on options user
  389  * may have setup with control call.
  390  */
  391 int
  392 #if __STDC__
  393 rip6_output(struct mbuf *m, ...)
  394 #else
  395 rip6_output(m, va_alist)
  396         struct mbuf *m;
  397         va_dcl
  398 #endif
  399 {
  400         struct mbuf *control;
  401         struct m_tag *mtag;
  402         struct socket *so;
  403         struct sockaddr_in6 *dstsock;
  404         struct in6_addr *dst;
  405         struct ip6_hdr *ip6;
  406         struct inpcb *in6p;
  407         u_int   plen = m->m_pkthdr.len;
  408         int error = 0;
  409         struct ip6_pktopts opt, *optp;
  410         struct ifnet *oifp = NULL;
  411         int type = 0, code = 0;         /* for ICMPv6 output statistics only */
  412         int scope_ambiguous = 0;
  413         int use_defzone = 0;
  414         struct in6_addr in6a;
  415         va_list ap;
  416 
  417         va_start(ap, m);
  418         so = va_arg(ap, struct socket *);
  419         dstsock = va_arg(ap, struct sockaddr_in6 *);
  420         control = va_arg(ap, struct mbuf *);
  421         va_end(ap);
  422 
  423         in6p = sotoinpcb(so);
  424         INP_WLOCK(in6p);
  425 
  426         dst = &dstsock->sin6_addr;
  427         if (control != NULL) {
  428                 if ((error = ip6_setpktopts(control, &opt,
  429                     in6p->in6p_outputopts, so->so_cred,
  430                     so->so_proto->pr_protocol)) != 0) {
  431                         goto bad;
  432                 }
  433                 optp = &opt;
  434         } else
  435                 optp = in6p->in6p_outputopts;
  436 
  437         /*
  438          * Check and convert scope zone ID into internal form.
  439          *
  440          * XXX: we may still need to determine the zone later.
  441          */
  442         if (!(so->so_state & SS_ISCONNECTED)) {
  443                 if (!optp || !optp->ip6po_pktinfo ||
  444                     !optp->ip6po_pktinfo->ipi6_ifindex)
  445                         use_defzone = V_ip6_use_defzone;
  446                 if (dstsock->sin6_scope_id == 0 && !use_defzone)
  447                         scope_ambiguous = 1;
  448                 if ((error = sa6_embedscope(dstsock, use_defzone)) != 0)
  449                         goto bad;
  450         }
  451 
  452         /*
  453          * For an ICMPv6 packet, we should know its type and code to update
  454          * statistics.
  455          */
  456         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) {
  457                 struct icmp6_hdr *icmp6;
  458                 if (m->m_len < sizeof(struct icmp6_hdr) &&
  459                     (m = m_pullup(m, sizeof(struct icmp6_hdr))) == NULL) {
  460                         error = ENOBUFS;
  461                         goto bad;
  462                 }
  463                 icmp6 = mtod(m, struct icmp6_hdr *);
  464                 type = icmp6->icmp6_type;
  465                 code = icmp6->icmp6_code;
  466         }
  467 
  468         M_PREPEND(m, sizeof(*ip6), M_NOWAIT);
  469         if (m == NULL) {
  470                 error = ENOBUFS;
  471                 goto bad;
  472         }
  473         ip6 = mtod(m, struct ip6_hdr *);
  474 
  475         /*
  476          * Source address selection.
  477          */
  478         error = in6_selectsrc(dstsock, optp, in6p, NULL, so->so_cred,
  479             &oifp, &in6a);
  480         if (error)
  481                 goto bad;
  482         error = prison_check_ip6(in6p->inp_cred, &in6a);
  483         if (error != 0)
  484                 goto bad;
  485         ip6->ip6_src = in6a;
  486 
  487         if (oifp && scope_ambiguous) {
  488                 /*
  489                  * Application should provide a proper zone ID or the use of
  490                  * default zone IDs should be enabled.  Unfortunately, some
  491                  * applications do not behave as it should, so we need a
  492                  * workaround.  Even if an appropriate ID is not determined
  493                  * (when it's required), if we can determine the outgoing
  494                  * interface. determine the zone ID based on the interface.
  495                  */
  496                 error = in6_setscope(&dstsock->sin6_addr, oifp, NULL);
  497                 if (error != 0)
  498                         goto bad;
  499         }
  500         ip6->ip6_dst = dstsock->sin6_addr;
  501 
  502         /*
  503          * Fill in the rest of the IPv6 header fields.
  504          */
  505         ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
  506             (in6p->inp_flow & IPV6_FLOWINFO_MASK);
  507         ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
  508             (IPV6_VERSION & IPV6_VERSION_MASK);
  509 
  510         /*
  511          * ip6_plen will be filled in ip6_output, so not fill it here.
  512          */
  513         ip6->ip6_nxt = in6p->inp_ip_p;
  514         ip6->ip6_hlim = in6_selecthlim(in6p, oifp);
  515 
  516         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6 ||
  517             in6p->in6p_cksum != -1) {
  518                 struct mbuf *n;
  519                 int off;
  520                 u_int16_t *p;
  521 
  522                 /* Compute checksum. */
  523                 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6)
  524                         off = offsetof(struct icmp6_hdr, icmp6_cksum);
  525                 else
  526                         off = in6p->in6p_cksum;
  527                 if (plen < off + 1) {
  528                         error = EINVAL;
  529                         goto bad;
  530                 }
  531                 off += sizeof(struct ip6_hdr);
  532 
  533                 n = m;
  534                 while (n && n->m_len <= off) {
  535                         off -= n->m_len;
  536                         n = n->m_next;
  537                 }
  538                 if (!n)
  539                         goto bad;
  540                 p = (u_int16_t *)(mtod(n, caddr_t) + off);
  541                 *p = 0;
  542                 *p = in6_cksum(m, ip6->ip6_nxt, sizeof(*ip6), plen);
  543         }
  544 
  545         /*
  546          * Send RA/RS messages to user land for protection, before sending
  547          * them to rtadvd/rtsol.
  548          */
  549         if ((send_sendso_input_hook != NULL) &&
  550             so->so_proto->pr_protocol == IPPROTO_ICMPV6) {
  551                 switch (type) {
  552                 case ND_ROUTER_ADVERT:
  553                 case ND_ROUTER_SOLICIT:
  554                         mtag = m_tag_get(PACKET_TAG_ND_OUTGOING,
  555                                 sizeof(unsigned short), M_NOWAIT);
  556                         if (mtag == NULL)
  557                                 goto bad;
  558                         m_tag_prepend(m, mtag);
  559                 }
  560         }
  561 
  562         error = ip6_output(m, optp, NULL, 0, in6p->in6p_moptions, &oifp, in6p);
  563         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) {
  564                 if (oifp)
  565                         icmp6_ifoutstat_inc(oifp, type, code);
  566                 ICMP6STAT_INC(icp6s_outhist[type]);
  567         } else
  568                 RIP6STAT_INC(rip6s_opackets);
  569 
  570         goto freectl;
  571 
  572  bad:
  573         if (m)
  574                 m_freem(m);
  575 
  576  freectl:
  577         if (control != NULL) {
  578                 ip6_clearpktopts(&opt, -1);
  579                 m_freem(control);
  580         }
  581         INP_WUNLOCK(in6p);
  582         return (error);
  583 }
  584 
  585 /*
  586  * Raw IPv6 socket option processing.
  587  */
  588 int
  589 rip6_ctloutput(struct socket *so, struct sockopt *sopt)
  590 {
  591         struct inpcb *inp;
  592         int error;
  593 
  594         if (sopt->sopt_level == IPPROTO_ICMPV6)
  595                 /*
  596                  * XXX: is it better to call icmp6_ctloutput() directly
  597                  * from protosw?
  598                  */
  599                 return (icmp6_ctloutput(so, sopt));
  600         else if (sopt->sopt_level != IPPROTO_IPV6) {
  601                 if (sopt->sopt_level == SOL_SOCKET &&
  602                     sopt->sopt_name == SO_SETFIB) {
  603                         inp = sotoinpcb(so);
  604                         INP_WLOCK(inp);
  605                         inp->inp_inc.inc_fibnum = so->so_fibnum;
  606                         INP_WUNLOCK(inp);
  607                         return (0);
  608                 }
  609                 return (EINVAL);
  610         }
  611 
  612         error = 0;
  613 
  614         switch (sopt->sopt_dir) {
  615         case SOPT_GET:
  616                 switch (sopt->sopt_name) {
  617                 case MRT6_INIT:
  618                 case MRT6_DONE:
  619                 case MRT6_ADD_MIF:
  620                 case MRT6_DEL_MIF:
  621                 case MRT6_ADD_MFC:
  622                 case MRT6_DEL_MFC:
  623                 case MRT6_PIM:
  624                         error = ip6_mrouter_get ?  ip6_mrouter_get(so, sopt) :
  625                             EOPNOTSUPP;
  626                         break;
  627                 case IPV6_CHECKSUM:
  628                         error = ip6_raw_ctloutput(so, sopt);
  629                         break;
  630                 default:
  631                         error = ip6_ctloutput(so, sopt);
  632                         break;
  633                 }
  634                 break;
  635 
  636         case SOPT_SET:
  637                 switch (sopt->sopt_name) {
  638                 case MRT6_INIT:
  639                 case MRT6_DONE:
  640                 case MRT6_ADD_MIF:
  641                 case MRT6_DEL_MIF:
  642                 case MRT6_ADD_MFC:
  643                 case MRT6_DEL_MFC:
  644                 case MRT6_PIM:
  645                         error = ip6_mrouter_set ?  ip6_mrouter_set(so, sopt) :
  646                             EOPNOTSUPP;
  647                         break;
  648                 case IPV6_CHECKSUM:
  649                         error = ip6_raw_ctloutput(so, sopt);
  650                         break;
  651                 default:
  652                         error = ip6_ctloutput(so, sopt);
  653                         break;
  654                 }
  655                 break;
  656         }
  657 
  658         return (error);
  659 }
  660 
  661 static int
  662 rip6_attach(struct socket *so, int proto, struct thread *td)
  663 {
  664         struct inpcb *inp;
  665         struct icmp6_filter *filter;
  666         int error;
  667 
  668         inp = sotoinpcb(so);
  669         KASSERT(inp == NULL, ("rip6_attach: inp != NULL"));
  670 
  671         error = priv_check(td, PRIV_NETINET_RAW);
  672         if (error)
  673                 return (error);
  674         error = soreserve(so, rip_sendspace, rip_recvspace);
  675         if (error)
  676                 return (error);
  677         filter = malloc(sizeof(struct icmp6_filter), M_PCB, M_NOWAIT);
  678         if (filter == NULL)
  679                 return (ENOMEM);
  680         INP_INFO_WLOCK(&V_ripcbinfo);
  681         error = in_pcballoc(so, &V_ripcbinfo);
  682         if (error) {
  683                 INP_INFO_WUNLOCK(&V_ripcbinfo);
  684                 free(filter, M_PCB);
  685                 return (error);
  686         }
  687         inp = (struct inpcb *)so->so_pcb;
  688         INP_INFO_WUNLOCK(&V_ripcbinfo);
  689         inp->inp_vflag |= INP_IPV6;
  690         inp->inp_ip_p = (long)proto;
  691         inp->in6p_hops = -1;    /* use kernel default */
  692         inp->in6p_cksum = -1;
  693         inp->in6p_icmp6filt = filter;
  694         ICMP6_FILTER_SETPASSALL(inp->in6p_icmp6filt);
  695         INP_WUNLOCK(inp);
  696         return (0);
  697 }
  698 
  699 static void
  700 rip6_detach(struct socket *so)
  701 {
  702         struct inpcb *inp;
  703 
  704         inp = sotoinpcb(so);
  705         KASSERT(inp != NULL, ("rip6_detach: inp == NULL"));
  706 
  707         if (so == V_ip6_mrouter && ip6_mrouter_done)
  708                 ip6_mrouter_done();
  709         /* xxx: RSVP */
  710         INP_INFO_WLOCK(&V_ripcbinfo);
  711         INP_WLOCK(inp);
  712         free(inp->in6p_icmp6filt, M_PCB);
  713         in_pcbdetach(inp);
  714         in_pcbfree(inp);
  715         INP_INFO_WUNLOCK(&V_ripcbinfo);
  716 }
  717 
  718 /* XXXRW: This can't ever be called. */
  719 static void
  720 rip6_abort(struct socket *so)
  721 {
  722         struct inpcb *inp;
  723 
  724         inp = sotoinpcb(so);
  725         KASSERT(inp != NULL, ("rip6_abort: inp == NULL"));
  726 
  727         soisdisconnected(so);
  728 }
  729 
  730 static void
  731 rip6_close(struct socket *so)
  732 {
  733         struct inpcb *inp;
  734 
  735         inp = sotoinpcb(so);
  736         KASSERT(inp != NULL, ("rip6_close: inp == NULL"));
  737 
  738         soisdisconnected(so);
  739 }
  740 
  741 static int
  742 rip6_disconnect(struct socket *so)
  743 {
  744         struct inpcb *inp;
  745 
  746         inp = sotoinpcb(so);
  747         KASSERT(inp != NULL, ("rip6_disconnect: inp == NULL"));
  748 
  749         if ((so->so_state & SS_ISCONNECTED) == 0)
  750                 return (ENOTCONN);
  751         inp->in6p_faddr = in6addr_any;
  752         rip6_abort(so);
  753         return (0);
  754 }
  755 
  756 static int
  757 rip6_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
  758 {
  759         struct inpcb *inp;
  760         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam;
  761         struct ifaddr *ifa = NULL;
  762         int error = 0;
  763 
  764         inp = sotoinpcb(so);
  765         KASSERT(inp != NULL, ("rip6_bind: inp == NULL"));
  766 
  767         if (nam->sa_len != sizeof(*addr))
  768                 return (EINVAL);
  769         if ((error = prison_check_ip6(td->td_ucred, &addr->sin6_addr)) != 0)
  770                 return (error);
  771         if (TAILQ_EMPTY(&V_ifnet) || addr->sin6_family != AF_INET6)
  772                 return (EADDRNOTAVAIL);
  773         if ((error = sa6_embedscope(addr, V_ip6_use_defzone)) != 0)
  774                 return (error);
  775 
  776         if (!IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr) &&
  777             (ifa = ifa_ifwithaddr((struct sockaddr *)addr)) == NULL)
  778                 return (EADDRNOTAVAIL);
  779         if (ifa != NULL &&
  780             ((struct in6_ifaddr *)ifa)->ia6_flags &
  781             (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|
  782              IN6_IFF_DETACHED|IN6_IFF_DEPRECATED)) {
  783                 ifa_free(ifa);
  784                 return (EADDRNOTAVAIL);
  785         }
  786         if (ifa != NULL)
  787                 ifa_free(ifa);
  788         INP_INFO_WLOCK(&V_ripcbinfo);
  789         INP_WLOCK(inp);
  790         inp->in6p_laddr = addr->sin6_addr;
  791         INP_WUNLOCK(inp);
  792         INP_INFO_WUNLOCK(&V_ripcbinfo);
  793         return (0);
  794 }
  795 
  796 static int
  797 rip6_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  798 {
  799         struct inpcb *inp;
  800         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam;
  801         struct in6_addr in6a;
  802         struct ifnet *ifp = NULL;
  803         int error = 0, scope_ambiguous = 0;
  804 
  805         inp = sotoinpcb(so);
  806         KASSERT(inp != NULL, ("rip6_connect: inp == NULL"));
  807 
  808         if (nam->sa_len != sizeof(*addr))
  809                 return (EINVAL);
  810         if (TAILQ_EMPTY(&V_ifnet))
  811                 return (EADDRNOTAVAIL);
  812         if (addr->sin6_family != AF_INET6)
  813                 return (EAFNOSUPPORT);
  814 
  815         /*
  816          * Application should provide a proper zone ID or the use of default
  817          * zone IDs should be enabled.  Unfortunately, some applications do
  818          * not behave as it should, so we need a workaround.  Even if an
  819          * appropriate ID is not determined, we'll see if we can determine
  820          * the outgoing interface.  If we can, determine the zone ID based on
  821          * the interface below.
  822          */
  823         if (addr->sin6_scope_id == 0 && !V_ip6_use_defzone)
  824                 scope_ambiguous = 1;
  825         if ((error = sa6_embedscope(addr, V_ip6_use_defzone)) != 0)
  826                 return (error);
  827 
  828         INP_INFO_WLOCK(&V_ripcbinfo);
  829         INP_WLOCK(inp);
  830         /* Source address selection. XXX: need pcblookup? */
  831         error = in6_selectsrc(addr, inp->in6p_outputopts,
  832             inp, NULL, so->so_cred, &ifp, &in6a);
  833         if (error) {
  834                 INP_WUNLOCK(inp);
  835                 INP_INFO_WUNLOCK(&V_ripcbinfo);
  836                 return (error);
  837         }
  838 
  839         /* XXX: see above */
  840         if (ifp && scope_ambiguous &&
  841             (error = in6_setscope(&addr->sin6_addr, ifp, NULL)) != 0) {
  842                 INP_WUNLOCK(inp);
  843                 INP_INFO_WUNLOCK(&V_ripcbinfo);
  844                 return (error);
  845         }
  846         inp->in6p_faddr = addr->sin6_addr;
  847         inp->in6p_laddr = in6a;
  848         soisconnected(so);
  849         INP_WUNLOCK(inp);
  850         INP_INFO_WUNLOCK(&V_ripcbinfo);
  851         return (0);
  852 }
  853 
  854 static int
  855 rip6_shutdown(struct socket *so)
  856 {
  857         struct inpcb *inp;
  858 
  859         inp = sotoinpcb(so);
  860         KASSERT(inp != NULL, ("rip6_shutdown: inp == NULL"));
  861 
  862         INP_WLOCK(inp);
  863         socantsendmore(so);
  864         INP_WUNLOCK(inp);
  865         return (0);
  866 }
  867 
  868 static int
  869 rip6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
  870     struct mbuf *control, struct thread *td)
  871 {
  872         struct inpcb *inp;
  873         struct sockaddr_in6 tmp;
  874         struct sockaddr_in6 *dst;
  875         int ret;
  876 
  877         inp = sotoinpcb(so);
  878         KASSERT(inp != NULL, ("rip6_send: inp == NULL"));
  879 
  880         /* Always copy sockaddr to avoid overwrites. */
  881         /* Unlocked read. */
  882         if (so->so_state & SS_ISCONNECTED) {
  883                 if (nam) {
  884                         m_freem(m);
  885                         return (EISCONN);
  886                 }
  887                 /* XXX */
  888                 bzero(&tmp, sizeof(tmp));
  889                 tmp.sin6_family = AF_INET6;
  890                 tmp.sin6_len = sizeof(struct sockaddr_in6);
  891                 INP_RLOCK(inp);
  892                 bcopy(&inp->in6p_faddr, &tmp.sin6_addr,
  893                     sizeof(struct in6_addr));
  894                 INP_RUNLOCK(inp);
  895                 dst = &tmp;
  896         } else {
  897                 if (nam == NULL) {
  898                         m_freem(m);
  899                         return (ENOTCONN);
  900                 }
  901                 if (nam->sa_len != sizeof(struct sockaddr_in6)) {
  902                         m_freem(m);
  903                         return (EINVAL);
  904                 }
  905                 tmp = *(struct sockaddr_in6 *)nam;
  906                 dst = &tmp;
  907 
  908                 if (dst->sin6_family == AF_UNSPEC) {
  909                         /*
  910                          * XXX: we allow this case for backward
  911                          * compatibility to buggy applications that
  912                          * rely on old (and wrong) kernel behavior.
  913                          */
  914                         log(LOG_INFO, "rip6 SEND: address family is "
  915                             "unspec. Assume AF_INET6\n");
  916                         dst->sin6_family = AF_INET6;
  917                 } else if (dst->sin6_family != AF_INET6) {
  918                         m_freem(m);
  919                         return(EAFNOSUPPORT);
  920                 }
  921         }
  922         ret = rip6_output(m, so, dst, control);
  923         return (ret);
  924 }
  925 
  926 struct pr_usrreqs rip6_usrreqs = {
  927         .pru_abort =            rip6_abort,
  928         .pru_attach =           rip6_attach,
  929         .pru_bind =             rip6_bind,
  930         .pru_connect =          rip6_connect,
  931         .pru_control =          in6_control,
  932         .pru_detach =           rip6_detach,
  933         .pru_disconnect =       rip6_disconnect,
  934         .pru_peeraddr =         in6_getpeeraddr,
  935         .pru_send =             rip6_send,
  936         .pru_shutdown =         rip6_shutdown,
  937         .pru_sockaddr =         in6_getsockaddr,
  938         .pru_close =            rip6_close,
  939 };

Cache object: 7b543e0ba2158d075476164f25fccc4b


[ 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.