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/in6_pcb.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 /*      $FreeBSD: src/sys/netinet6/in6_pcb.c,v 1.59.2.3 2005/01/31 23:26:39 imp Exp $   */
    2 /*      $KAME: in6_pcb.c,v 1.31 2001/05/21 05:45:10 jinmei Exp $        */
    3   
    4 /*-
    5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the project nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  */
   33 
   34 /*-
   35  * Copyright (c) 1982, 1986, 1991, 1993
   36  *      The Regents of the University of California.  All rights reserved.
   37  *
   38  * Redistribution and use in source and binary forms, with or without
   39  * modification, are permitted provided that the following conditions
   40  * are met:
   41  * 1. Redistributions of source code must retain the above copyright
   42  *    notice, this list of conditions and the following disclaimer.
   43  * 2. Redistributions in binary form must reproduce the above copyright
   44  *    notice, this list of conditions and the following disclaimer in the
   45  *    documentation and/or other materials provided with the distribution.
   46  * 4. Neither the name of the University nor the names of its contributors
   47  *    may be used to endorse or promote products derived from this software
   48  *    without specific prior written permission.
   49  *
   50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   53  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   60  * SUCH DAMAGE.
   61  *
   62  *      @(#)in_pcb.c    8.2 (Berkeley) 1/4/94
   63  */
   64 
   65 #include "opt_inet.h"
   66 #include "opt_inet6.h"
   67 #include "opt_ipsec.h"
   68 
   69 #include <sys/param.h>
   70 #include <sys/systm.h>
   71 #include <sys/malloc.h>
   72 #include <sys/mbuf.h>
   73 #include <sys/domain.h>
   74 #include <sys/protosw.h>
   75 #include <sys/socket.h>
   76 #include <sys/socketvar.h>
   77 #include <sys/sockio.h>
   78 #include <sys/errno.h>
   79 #include <sys/time.h>
   80 #include <sys/proc.h>
   81 #include <sys/jail.h>
   82 
   83 #include <vm/uma.h>
   84 
   85 #include <net/if.h>
   86 #include <net/if_types.h>
   87 #include <net/route.h>
   88 
   89 #include <netinet/in.h>
   90 #include <netinet/in_var.h>
   91 #include <netinet/in_systm.h>
   92 #include <netinet/tcp_var.h>
   93 #include <netinet/ip6.h>
   94 #include <netinet/ip_var.h>
   95 #include <netinet6/ip6_var.h>
   96 #include <netinet6/nd6.h>
   97 #include <netinet/in_pcb.h>
   98 #include <netinet6/in6_pcb.h>
   99 
  100 #ifdef IPSEC
  101 #include <netinet6/ipsec.h>
  102 #ifdef INET6
  103 #include <netinet6/ipsec6.h>
  104 #endif
  105 #include <netinet6/ah.h>
  106 #ifdef INET6
  107 #include <netinet6/ah6.h>
  108 #endif
  109 #include <netkey/key.h>
  110 #endif /* IPSEC */
  111 
  112 #ifdef FAST_IPSEC
  113 #include <netipsec/ipsec.h>
  114 #include <netipsec/ipsec6.h>
  115 #include <netipsec/key.h>
  116 #endif /* FAST_IPSEC */
  117 
  118 struct  in6_addr zeroin6_addr;
  119 
  120 int
  121 in6_pcbbind(inp, nam, cred)
  122         register struct inpcb *inp;
  123         struct sockaddr *nam;
  124         struct ucred *cred;
  125 {
  126         struct socket *so = inp->inp_socket;
  127         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)NULL;
  128         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
  129         u_short lport = 0;
  130         int wild = 0, reuseport = (so->so_options & SO_REUSEPORT);
  131 
  132         INP_INFO_WLOCK_ASSERT(pcbinfo);
  133         INP_LOCK_ASSERT(inp);
  134 
  135         if (!in6_ifaddr) /* XXX broken! */
  136                 return (EADDRNOTAVAIL);
  137         if (inp->inp_lport || !IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
  138                 return (EINVAL);
  139         if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
  140                 wild = 1;
  141         if (nam) {
  142                 sin6 = (struct sockaddr_in6 *)nam;
  143                 if (nam->sa_len != sizeof(*sin6))
  144                         return (EINVAL);
  145                 /*
  146                  * family check.
  147                  */
  148                 if (nam->sa_family != AF_INET6)
  149                         return (EAFNOSUPPORT);
  150 
  151                 /* KAME hack: embed scopeid */
  152                 if (in6_embedscope(&sin6->sin6_addr, sin6, inp, NULL) != 0)
  153                         return EINVAL;
  154                 /* this must be cleared for ifa_ifwithaddr() */
  155                 sin6->sin6_scope_id = 0;
  156 
  157                 lport = sin6->sin6_port;
  158                 if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
  159                         /*
  160                          * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
  161                          * allow compepte duplication of binding if
  162                          * SO_REUSEPORT is set, or if SO_REUSEADDR is set
  163                          * and a multicast address is bound on both
  164                          * new and duplicated sockets.
  165                          */
  166                         if (so->so_options & SO_REUSEADDR)
  167                                 reuseport = SO_REUSEADDR|SO_REUSEPORT;
  168                 } else if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  169                         struct ifaddr *ia = NULL;
  170 
  171                         sin6->sin6_port = 0;            /* yech... */
  172                         if ((ia = ifa_ifwithaddr((struct sockaddr *)sin6)) == 0)
  173                                 return (EADDRNOTAVAIL);
  174 
  175                         /*
  176                          * XXX: bind to an anycast address might accidentally
  177                          * cause sending a packet with anycast source address.
  178                          * We should allow to bind to a deprecated address, since
  179                          * the application dares to use it.
  180                          */
  181                         if (ia &&
  182                             ((struct in6_ifaddr *)ia)->ia6_flags &
  183                             (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|IN6_IFF_DETACHED)) {
  184                                 return (EADDRNOTAVAIL);
  185                         }
  186                 }
  187                 if (lport) {
  188                         struct inpcb *t;
  189 
  190                         /* GROSS */
  191                         if (ntohs(lport) < IPV6PORT_RESERVED &&
  192                             suser_cred(cred, SUSER_ALLOWJAIL))
  193                                 return (EACCES);
  194                         if (so->so_cred->cr_uid != 0 &&
  195                             !IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
  196                                 t = in6_pcblookup_local(pcbinfo,
  197                                     &sin6->sin6_addr, lport,
  198                                     INPLOOKUP_WILDCARD);
  199                                 if (t &&
  200                                     ((t->inp_vflag & INP_TIMEWAIT) == 0) &&
  201                                     (so->so_type != SOCK_STREAM ||
  202                                      IN6_IS_ADDR_UNSPECIFIED(&t->in6p_faddr)) &&
  203                                     (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) ||
  204                                      !IN6_IS_ADDR_UNSPECIFIED(&t->in6p_laddr) ||
  205                                      (t->inp_socket->so_options & SO_REUSEPORT) 
  206                                       == 0) && (so->so_cred->cr_uid !=
  207                                      t->inp_socket->so_cred->cr_uid))
  208                                         return (EADDRINUSE);
  209                                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0 &&
  210                                     IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  211                                         struct sockaddr_in sin;
  212 
  213                                         in6_sin6_2_sin(&sin, sin6);
  214                                         t = in_pcblookup_local(pcbinfo,
  215                                                 sin.sin_addr, lport,
  216                                                 INPLOOKUP_WILDCARD);
  217                                         if (t &&
  218                                             ((t->inp_vflag &
  219                                               INP_TIMEWAIT) == 0) &&
  220                                             (so->so_type != SOCK_STREAM ||
  221                                              ntohl(t->inp_faddr.s_addr) ==
  222                                               INADDR_ANY) &&
  223                                             (so->so_cred->cr_uid !=
  224                                              t->inp_socket->so_cred->cr_uid))
  225                                                 return (EADDRINUSE);
  226                                 }
  227                         }
  228                         t = in6_pcblookup_local(pcbinfo, &sin6->sin6_addr,
  229                                                 lport, wild);
  230                         if (t && (reuseport & ((t->inp_vflag & INP_TIMEWAIT) ?
  231                             intotw(t)->tw_so_options : 
  232                             t->inp_socket->so_options)) == 0)
  233                                 return (EADDRINUSE);
  234                         if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0 &&
  235                             IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  236                                 struct sockaddr_in sin;
  237 
  238                                 in6_sin6_2_sin(&sin, sin6);
  239                                 t = in_pcblookup_local(pcbinfo, sin.sin_addr,
  240                                                        lport, wild);
  241                                 if (t && t->inp_vflag & INP_TIMEWAIT) {
  242                                         if ((reuseport & 
  243                                             intotw(t)->tw_so_options) == 0 &&
  244                                             (ntohl(t->inp_laddr.s_addr) !=
  245                                              INADDR_ANY || ((inp->inp_vflag & 
  246                                              INP_IPV6PROTO) == 
  247                                              (t->inp_vflag & INP_IPV6PROTO))))
  248                                                 return (EADDRINUSE);
  249                                 }
  250                                 else if (t && 
  251                                     (reuseport & t->inp_socket->so_options) 
  252                                     == 0 && (ntohl(t->inp_laddr.s_addr) != 
  253                                     INADDR_ANY || INP_SOCKAF(so) ==
  254                                      INP_SOCKAF(t->inp_socket)))
  255                                         return (EADDRINUSE);
  256                         }
  257                 }
  258                 inp->in6p_laddr = sin6->sin6_addr;
  259         }
  260         if (lport == 0) {
  261                 int e;
  262                 if ((e = in6_pcbsetport(&inp->in6p_laddr, inp, cred)) != 0)
  263                         return (e);
  264         }
  265         else {
  266                 inp->inp_lport = lport;
  267                 if (in_pcbinshash(inp) != 0) {
  268                         inp->in6p_laddr = in6addr_any;
  269                         inp->inp_lport = 0;
  270                         return (EAGAIN);
  271                 }
  272         }
  273         return (0);
  274 }
  275 
  276 /*
  277  *   Transform old in6_pcbconnect() into an inner subroutine for new
  278  *   in6_pcbconnect(): Do some validity-checking on the remote
  279  *   address (in mbuf 'nam') and then determine local host address
  280  *   (i.e., which interface) to use to access that remote host.
  281  *
  282  *   This preserves definition of in6_pcbconnect(), while supporting a
  283  *   slightly different version for T/TCP.  (This is more than
  284  *   a bit of a kludge, but cleaning up the internal interfaces would
  285  *   have forced minor changes in every protocol).
  286  */
  287 
  288 int
  289 in6_pcbladdr(inp, nam, plocal_addr6)
  290         register struct inpcb *inp;
  291         struct sockaddr *nam;
  292         struct in6_addr **plocal_addr6;
  293 {
  294         register struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
  295         struct ifnet *ifp = NULL;
  296         int error = 0;
  297 
  298         if (nam->sa_len != sizeof (*sin6))
  299                 return (EINVAL);
  300         if (sin6->sin6_family != AF_INET6)
  301                 return (EAFNOSUPPORT);
  302         if (sin6->sin6_port == 0)
  303                 return (EADDRNOTAVAIL);
  304 
  305         INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
  306         INP_LOCK_ASSERT(inp);
  307 
  308         /* KAME hack: embed scopeid */
  309         if (in6_embedscope(&sin6->sin6_addr, sin6, inp, &ifp) != 0)
  310                 return EINVAL;
  311 
  312         if (in6_ifaddr) {
  313                 /*
  314                  * If the destination address is UNSPECIFIED addr,
  315                  * use the loopback addr, e.g ::1.
  316                  */
  317                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
  318                         sin6->sin6_addr = in6addr_loopback;
  319         }
  320         {
  321                 /*
  322                  * XXX: in6_selectsrc might replace the bound local address
  323                  * with the address specified by setsockopt(IPV6_PKTINFO).
  324                  * Is it the intended behavior?
  325                  */
  326                 *plocal_addr6 = in6_selectsrc(sin6, inp->in6p_outputopts,
  327                                               inp->in6p_moptions, NULL,
  328                                               &inp->in6p_laddr, &error);
  329                 if (*plocal_addr6 == 0) {
  330                         if (error == 0)
  331                                 error = EADDRNOTAVAIL;
  332                         return (error);
  333                 }
  334                 /*
  335                  * Don't do pcblookup call here; return interface in
  336                  * plocal_addr6
  337                  * and exit to caller, that will do the lookup.
  338                  */
  339         }
  340         return (0);
  341 }
  342 
  343 /*
  344  * Outer subroutine:
  345  * Connect from a socket to a specified address.
  346  * Both address and port must be specified in argument sin.
  347  * If don't have a local address for this socket yet,
  348  * then pick one.
  349  */
  350 int
  351 in6_pcbconnect(inp, nam, cred)
  352         register struct inpcb *inp;
  353         struct sockaddr *nam;
  354         struct ucred *cred;
  355 {
  356         struct in6_addr *addr6;
  357         register struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
  358         int error;
  359 
  360         INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
  361         INP_LOCK_ASSERT(inp);
  362 
  363         /*
  364          * Call inner routine, to assign local interface address.
  365          * in6_pcbladdr() may automatically fill in sin6_scope_id.
  366          */
  367         if ((error = in6_pcbladdr(inp, nam, &addr6)) != 0)
  368                 return (error);
  369 
  370         if (in6_pcblookup_hash(inp->inp_pcbinfo, &sin6->sin6_addr,
  371                                sin6->sin6_port,
  372                               IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)
  373                               ? addr6 : &inp->in6p_laddr,
  374                               inp->inp_lport, 0, NULL) != NULL) {
  375                 return (EADDRINUSE);
  376         }
  377         if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
  378                 if (inp->inp_lport == 0) {
  379                         error = in6_pcbbind(inp, (struct sockaddr *)0, cred);
  380                         if (error)
  381                                 return (error);
  382                 }
  383                 inp->in6p_laddr = *addr6;
  384         }
  385         inp->in6p_faddr = sin6->sin6_addr;
  386         inp->inp_fport = sin6->sin6_port;
  387         /* update flowinfo - draft-itojun-ipv6-flowlabel-api-00 */
  388         inp->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK;
  389         if (inp->in6p_flags & IN6P_AUTOFLOWLABEL)
  390                 inp->in6p_flowinfo |=
  391                     (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK);
  392 
  393         in_pcbrehash(inp);
  394 #ifdef IPSEC
  395         if (inp->inp_socket->so_type == SOCK_STREAM)
  396                 ipsec_pcbconn(inp->inp_sp);
  397 #endif
  398         return (0);
  399 }
  400 
  401 void
  402 in6_pcbdisconnect(inp)
  403         struct inpcb *inp;
  404 {
  405 
  406         INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
  407         INP_LOCK_ASSERT(inp);
  408 
  409         bzero((caddr_t)&inp->in6p_faddr, sizeof(inp->in6p_faddr));
  410         inp->inp_fport = 0;
  411         /* clear flowinfo - draft-itojun-ipv6-flowlabel-api-00 */
  412         inp->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK;
  413         in_pcbrehash(inp);
  414 #ifdef IPSEC
  415         ipsec_pcbdisconn(inp->inp_sp);
  416 #endif
  417         if (inp->inp_socket->so_state & SS_NOFDREF)
  418                 in6_pcbdetach(inp);
  419 }
  420 
  421 void
  422 in6_pcbdetach(inp)
  423         struct inpcb *inp;
  424 {
  425         struct socket *so = inp->inp_socket;
  426         struct inpcbinfo *ipi = inp->inp_pcbinfo;
  427 
  428         INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
  429         INP_LOCK_ASSERT(inp);
  430 
  431 #if defined(IPSEC) || defined(FAST_IPSEC)
  432         if (inp->in6p_sp != NULL)
  433                 ipsec6_delete_pcbpolicy(inp);
  434 #endif /* IPSEC */
  435         inp->inp_gencnt = ++ipi->ipi_gencnt;
  436         in_pcbremlists(inp);
  437 
  438         if (so) {
  439                 ACCEPT_LOCK();
  440                 SOCK_LOCK(so);
  441                 so->so_pcb = NULL;
  442                 sotryfree(so);
  443         }
  444 
  445         ip6_freepcbopts(inp->in6p_outputopts);
  446         ip6_freemoptions(inp->in6p_moptions);
  447         /* Check and free IPv4 related resources in case of mapped addr */
  448         if (inp->inp_options)
  449                 (void)m_free(inp->inp_options);
  450         ip_freemoptions(inp->inp_moptions);
  451         inp->inp_vflag = 0;
  452         INP_LOCK_DESTROY(inp);
  453         uma_zfree(ipi->ipi_zone, inp);
  454 }
  455 
  456 struct sockaddr *
  457 in6_sockaddr(port, addr_p)
  458         in_port_t port;
  459         struct in6_addr *addr_p;
  460 {
  461         struct sockaddr_in6 *sin6;
  462 
  463         MALLOC(sin6, struct sockaddr_in6 *, sizeof *sin6, M_SONAME, M_WAITOK);
  464         bzero(sin6, sizeof *sin6);
  465         sin6->sin6_family = AF_INET6;
  466         sin6->sin6_len = sizeof(*sin6);
  467         sin6->sin6_port = port;
  468         sin6->sin6_addr = *addr_p;
  469         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
  470                 sin6->sin6_scope_id = ntohs(sin6->sin6_addr.s6_addr16[1]);
  471         else
  472                 sin6->sin6_scope_id = 0;        /*XXX*/
  473         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
  474                 sin6->sin6_addr.s6_addr16[1] = 0;
  475 
  476         return (struct sockaddr *)sin6;
  477 }
  478 
  479 struct sockaddr *
  480 in6_v4mapsin6_sockaddr(port, addr_p)
  481         in_port_t port;
  482         struct in_addr *addr_p;
  483 {
  484         struct sockaddr_in sin;
  485         struct sockaddr_in6 *sin6_p;
  486 
  487         bzero(&sin, sizeof sin);
  488         sin.sin_family = AF_INET;
  489         sin.sin_len = sizeof(sin);
  490         sin.sin_port = port;
  491         sin.sin_addr = *addr_p;
  492 
  493         MALLOC(sin6_p, struct sockaddr_in6 *, sizeof *sin6_p, M_SONAME,
  494                 M_WAITOK);
  495         in6_sin_2_v4mapsin6(&sin, sin6_p);
  496 
  497         return (struct sockaddr *)sin6_p;
  498 }
  499 
  500 /*
  501  * The calling convention of in6_setsockaddr() and in6_setpeeraddr() was
  502  * modified to match the pru_sockaddr() and pru_peeraddr() entry points
  503  * in struct pr_usrreqs, so that protocols can just reference then directly
  504  * without the need for a wrapper function.  The socket must have a valid
  505  * (i.e., non-nil) PCB, but it should be impossible to get an invalid one
  506  * except through a kernel programming error, so it is acceptable to panic
  507  * (or in this case trap) if the PCB is invalid.  (Actually, we don't trap
  508  * because there actually /is/ a programming error somewhere... XXX)
  509  */
  510 int
  511 in6_setsockaddr(so, nam)
  512         struct socket *so;
  513         struct sockaddr **nam;
  514 {
  515         int s;
  516         register struct inpcb *inp;
  517         struct in6_addr addr;
  518         in_port_t port;
  519 
  520         s = splnet();
  521         inp = sotoinpcb(so);
  522         if (!inp) {
  523                 splx(s);
  524                 return EINVAL;
  525         }
  526         port = inp->inp_lport;
  527         addr = inp->in6p_laddr;
  528         splx(s);
  529 
  530         *nam = in6_sockaddr(port, &addr);
  531         return 0;
  532 }
  533 
  534 int
  535 in6_setpeeraddr(so, nam)
  536         struct socket *so;
  537         struct sockaddr **nam;
  538 {
  539         int s;
  540         struct inpcb *inp;
  541         struct in6_addr addr;
  542         in_port_t port;
  543 
  544         s = splnet();
  545         inp = sotoinpcb(so);
  546         if (!inp) {
  547                 splx(s);
  548                 return EINVAL;
  549         }
  550         port = inp->inp_fport;
  551         addr = inp->in6p_faddr;
  552         splx(s);
  553 
  554         *nam = in6_sockaddr(port, &addr);
  555         return 0;
  556 }
  557 
  558 int
  559 in6_mapped_sockaddr(struct socket *so, struct sockaddr **nam)
  560 {
  561         struct  inpcb *inp = sotoinpcb(so);
  562         int     error;
  563 
  564         if (inp == NULL)
  565                 return EINVAL;
  566         if ((inp->inp_vflag & (INP_IPV4 | INP_IPV6)) == INP_IPV4) {
  567                 error = in_setsockaddr(so, nam, &tcbinfo);
  568                 if (error == 0)
  569                         in6_sin_2_v4mapsin6_in_sock(nam);
  570         } else {
  571                 /* scope issues will be handled in in6_setsockaddr(). */
  572                 error = in6_setsockaddr(so, nam);
  573         }
  574 
  575         return error;
  576 }
  577 
  578 int
  579 in6_mapped_peeraddr(struct socket *so, struct sockaddr **nam)
  580 {
  581         struct  inpcb *inp = sotoinpcb(so);
  582         int     error;
  583 
  584         if (inp == NULL)
  585                 return EINVAL;
  586         if ((inp->inp_vflag & (INP_IPV4 | INP_IPV6)) == INP_IPV4) {
  587                 error = in_setpeeraddr(so, nam, &tcbinfo);
  588                 if (error == 0)
  589                         in6_sin_2_v4mapsin6_in_sock(nam);
  590         } else
  591         /* scope issues will be handled in in6_setpeeraddr(). */
  592         error = in6_setpeeraddr(so, nam);
  593 
  594         return error;
  595 }
  596 
  597 /*
  598  * Pass some notification to all connections of a protocol
  599  * associated with address dst.  The local address and/or port numbers
  600  * may be specified to limit the search.  The "usual action" will be
  601  * taken, depending on the ctlinput cmd.  The caller must filter any
  602  * cmds that are uninteresting (e.g., no error in the map).
  603  * Call the protocol specific routine (if any) to report
  604  * any errors for each matching socket.
  605  *
  606  * Must be called at splnet.
  607  */
  608 void
  609 in6_pcbnotify(pcbinfo, dst, fport_arg, src, lport_arg, cmd, cmdarg, notify)
  610         struct inpcbinfo *pcbinfo;
  611         struct sockaddr *dst;
  612         const struct sockaddr *src;
  613         u_int fport_arg, lport_arg;
  614         int cmd;
  615         void *cmdarg;
  616         struct inpcb *(*notify) __P((struct inpcb *, int));
  617 {
  618         struct inpcbhead *head;
  619         struct inpcb *inp, *ninp;
  620         struct sockaddr_in6 sa6_src, *sa6_dst;
  621         u_short fport = fport_arg, lport = lport_arg;
  622         u_int32_t flowinfo;
  623         int errno, s;
  624 
  625         if ((unsigned)cmd >= PRC_NCMDS || dst->sa_family != AF_INET6)
  626                 return;
  627 
  628         sa6_dst = (struct sockaddr_in6 *)dst;
  629         if (IN6_IS_ADDR_UNSPECIFIED(&sa6_dst->sin6_addr))
  630                 return;
  631 
  632         /*
  633          * note that src can be NULL when we get notify by local fragmentation.
  634          */
  635         sa6_src = (src == NULL) ? sa6_any : *(const struct sockaddr_in6 *)src;
  636         flowinfo = sa6_src.sin6_flowinfo;
  637 
  638         /*
  639          * Redirects go to all references to the destination,
  640          * and use in6_rtchange to invalidate the route cache.
  641          * Dead host indications: also use in6_rtchange to invalidate
  642          * the cache, and deliver the error to all the sockets.
  643          * Otherwise, if we have knowledge of the local port and address,
  644          * deliver only to that socket.
  645          */
  646         if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) {
  647                 fport = 0;
  648                 lport = 0;
  649                 bzero((caddr_t)&sa6_src.sin6_addr, sizeof(sa6_src.sin6_addr));
  650 
  651                 if (cmd != PRC_HOSTDEAD)
  652                         notify = in6_rtchange;
  653         }
  654         errno = inet6ctlerrmap[cmd];
  655         s = splnet();
  656         head = pcbinfo->listhead;
  657         INP_INFO_WLOCK(pcbinfo);
  658         for (inp = LIST_FIRST(head); inp != NULL; inp = ninp) {
  659                 INP_LOCK(inp);
  660                 ninp = LIST_NEXT(inp, inp_list);
  661 
  662                 if ((inp->inp_vflag & INP_IPV6) == 0) {
  663                         INP_UNLOCK(inp);
  664                         continue;
  665                 }
  666 
  667                 /*
  668                  * If the error designates a new path MTU for a destination
  669                  * and the application (associated with this socket) wanted to
  670                  * know the value, notify. Note that we notify for all
  671                  * disconnected sockets if the corresponding application
  672                  * wanted. This is because some UDP applications keep sending
  673                  * sockets disconnected.
  674                  * XXX: should we avoid to notify the value to TCP sockets?
  675                  */
  676                 if (cmd == PRC_MSGSIZE && (inp->inp_flags & IN6P_MTU) != 0 &&
  677                     (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) ||
  678                      IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr, &sa6_dst->sin6_addr))) {
  679                         ip6_notify_pmtu(inp, (struct sockaddr_in6 *)dst,
  680                                         (u_int32_t *)cmdarg);
  681                 }
  682 
  683                 /*
  684                  * Detect if we should notify the error. If no source and
  685                  * destination ports are specifed, but non-zero flowinfo and
  686                  * local address match, notify the error. This is the case
  687                  * when the error is delivered with an encrypted buffer
  688                  * by ESP. Otherwise, just compare addresses and ports
  689                  * as usual.
  690                  */
  691                 if (lport == 0 && fport == 0 && flowinfo &&
  692                     inp->inp_socket != NULL &&
  693                     flowinfo == (inp->in6p_flowinfo & IPV6_FLOWLABEL_MASK) &&
  694                     IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, &sa6_src.sin6_addr))
  695                         goto do_notify;
  696                 else if (!IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr,
  697                                              &sa6_dst->sin6_addr) ||
  698                          inp->inp_socket == 0 ||
  699                          (lport && inp->inp_lport != lport) ||
  700                          (!IN6_IS_ADDR_UNSPECIFIED(&sa6_src.sin6_addr) &&
  701                           !IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr,
  702                                               &sa6_src.sin6_addr)) ||
  703                          (fport && inp->inp_fport != fport)) {
  704                         INP_UNLOCK(inp);
  705                         continue;
  706                 }
  707 
  708           do_notify:
  709                 if (notify) {
  710                         if ((*notify)(inp, errno))
  711                                 INP_UNLOCK(inp);
  712                 } else
  713                         INP_UNLOCK(inp);
  714         }
  715         INP_INFO_WUNLOCK(pcbinfo);
  716         splx(s);
  717 }
  718 
  719 /*
  720  * Lookup a PCB based on the local address and port.
  721  */
  722 struct inpcb *
  723 in6_pcblookup_local(pcbinfo, laddr, lport_arg, wild_okay)
  724         struct inpcbinfo *pcbinfo;
  725         struct in6_addr *laddr;
  726         u_int lport_arg;
  727         int wild_okay;
  728 {
  729         register struct inpcb *inp;
  730         int matchwild = 3, wildcard;
  731         u_short lport = lport_arg;
  732 
  733         if (!wild_okay) {
  734                 struct inpcbhead *head;
  735                 /*
  736                  * Look for an unconnected (wildcard foreign addr) PCB that
  737                  * matches the local address and port we're looking for.
  738                  */
  739                 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0,
  740                                                       pcbinfo->hashmask)];
  741                 LIST_FOREACH(inp, head, inp_hash) {
  742                         if ((inp->inp_vflag & INP_IPV6) == 0)
  743                                 continue;
  744                         if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) &&
  745                             IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr) &&
  746                             inp->inp_lport == lport) {
  747                                 /*
  748                                  * Found.
  749                                  */
  750                                 return (inp);
  751                         }
  752                 }
  753                 /*
  754                  * Not found.
  755                  */
  756                 return (NULL);
  757         } else {
  758                 struct inpcbporthead *porthash;
  759                 struct inpcbport *phd;
  760                 struct inpcb *match = NULL;
  761                 /*
  762                  * Best fit PCB lookup.
  763                  *
  764                  * First see if this local port is in use by looking on the
  765                  * port hash list.
  766                  */
  767                 porthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(lport,
  768                     pcbinfo->porthashmask)];
  769                 LIST_FOREACH(phd, porthash, phd_hash) {
  770                         if (phd->phd_port == lport)
  771                                 break;
  772                 }
  773                 if (phd != NULL) {
  774                         /*
  775                          * Port is in use by one or more PCBs. Look for best
  776                          * fit.
  777                          */
  778                         LIST_FOREACH(inp, &phd->phd_pcblist, inp_portlist) {
  779                                 wildcard = 0;
  780                                 if ((inp->inp_vflag & INP_IPV6) == 0)
  781                                         continue;
  782                                 if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
  783                                         wildcard++;
  784                                 if (!IN6_IS_ADDR_UNSPECIFIED(
  785                                         &inp->in6p_laddr)) {
  786                                         if (IN6_IS_ADDR_UNSPECIFIED(laddr))
  787                                                 wildcard++;
  788                                         else if (!IN6_ARE_ADDR_EQUAL(
  789                                                 &inp->in6p_laddr, laddr))
  790                                                 continue;
  791                                 } else {
  792                                         if (!IN6_IS_ADDR_UNSPECIFIED(laddr))
  793                                                 wildcard++;
  794                                 }
  795                                 if (wildcard < matchwild) {
  796                                         match = inp;
  797                                         matchwild = wildcard;
  798                                         if (matchwild == 0) {
  799                                                 break;
  800                                         }
  801                                 }
  802                         }
  803                 }
  804                 return (match);
  805         }
  806 }
  807 
  808 void
  809 in6_pcbpurgeif0(head, ifp)
  810         struct in6pcb *head;
  811         struct ifnet *ifp;
  812 {
  813         struct in6pcb *in6p;
  814         struct ip6_moptions *im6o;
  815         struct in6_multi_mship *imm, *nimm;
  816 
  817         for (in6p = head; in6p != NULL; in6p = LIST_NEXT(in6p, inp_list)) {
  818                 im6o = in6p->in6p_moptions;
  819                 if ((in6p->inp_vflag & INP_IPV6) &&
  820                     im6o) {
  821                         /*
  822                          * Unselect the outgoing interface if it is being
  823                          * detached.
  824                          */
  825                         if (im6o->im6o_multicast_ifp == ifp)
  826                                 im6o->im6o_multicast_ifp = NULL;
  827 
  828                         /*
  829                          * Drop multicast group membership if we joined
  830                          * through the interface being detached.
  831                          * XXX controversial - is it really legal for kernel
  832                          * to force this?
  833                          */
  834                         for (imm = im6o->im6o_memberships.lh_first;
  835                              imm != NULL; imm = nimm) {
  836                                 nimm = imm->i6mm_chain.le_next;
  837                                 if (imm->i6mm_maddr->in6m_ifp == ifp) {
  838                                         LIST_REMOVE(imm, i6mm_chain);
  839                                         in6_delmulti(imm->i6mm_maddr);
  840                                         free(imm, M_IPMADDR);
  841                                 }
  842                         }
  843                 }
  844         }
  845 }
  846 
  847 /*
  848  * Check for alternatives when higher level complains
  849  * about service problems.  For now, invalidate cached
  850  * routing information.  If the route was created dynamically
  851  * (by a redirect), time to try a default gateway again.
  852  */
  853 void
  854 in6_losing(in6p)
  855         struct inpcb *in6p;
  856 {
  857         /*
  858          * We don't store route pointers in the routing table anymore
  859          */
  860         return;
  861 }
  862 
  863 /*
  864  * After a routing change, flush old routing
  865  * and allocate a (hopefully) better one.
  866  */
  867 struct inpcb *
  868 in6_rtchange(inp, errno)
  869         struct inpcb *inp;
  870         int errno;
  871 {
  872         /*
  873          * We don't store route pointers in the routing table anymore
  874          */
  875         return inp;
  876 }
  877 
  878 /*
  879  * Lookup PCB in hash list.
  880  */
  881 struct inpcb *
  882 in6_pcblookup_hash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard, ifp)
  883         struct inpcbinfo *pcbinfo;
  884         struct in6_addr *faddr, *laddr;
  885         u_int fport_arg, lport_arg;
  886         int wildcard;
  887         struct ifnet *ifp;
  888 {
  889         struct inpcbhead *head;
  890         register struct inpcb *inp;
  891         u_short fport = fport_arg, lport = lport_arg;
  892         int faith;
  893 
  894         if (faithprefix_p != NULL)
  895                 faith = (*faithprefix_p)(laddr);
  896         else
  897                 faith = 0;
  898 
  899         /*
  900          * First look for an exact match.
  901          */
  902         head = &pcbinfo->hashbase[INP_PCBHASH(faddr->s6_addr32[3] /* XXX */,
  903                                               lport, fport,
  904                                               pcbinfo->hashmask)];
  905         LIST_FOREACH(inp, head, inp_hash) {
  906                 if ((inp->inp_vflag & INP_IPV6) == 0)
  907                         continue;
  908                 if (IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr, faddr) &&
  909                     IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr) &&
  910                     inp->inp_fport == fport &&
  911                     inp->inp_lport == lport) {
  912                         /*
  913                          * Found.
  914                          */
  915                         return (inp);
  916                 }
  917         }
  918         if (wildcard) {
  919                 struct inpcb *local_wild = NULL;
  920 
  921                 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0,
  922                                                       pcbinfo->hashmask)];
  923                 LIST_FOREACH(inp, head, inp_hash) {
  924                         if ((inp->inp_vflag & INP_IPV6) == 0)
  925                                 continue;
  926                         if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) &&
  927                             inp->inp_lport == lport) {
  928                                 if (faith && (inp->inp_flags & INP_FAITH) == 0)
  929                                         continue;
  930                                 if (IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr,
  931                                                        laddr))
  932                                         return (inp);
  933                                 else if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
  934                                         local_wild = inp;
  935                         }
  936                 }
  937                 return (local_wild);
  938         }
  939 
  940         /*
  941          * Not found.
  942          */
  943         return (NULL);
  944 }
  945 
  946 void
  947 init_sin6(struct sockaddr_in6 *sin6, struct mbuf *m)
  948 {
  949         struct ip6_hdr *ip;
  950 
  951         ip = mtod(m, struct ip6_hdr *);
  952         bzero(sin6, sizeof(*sin6));
  953         sin6->sin6_len = sizeof(*sin6);
  954         sin6->sin6_family = AF_INET6;
  955         sin6->sin6_addr = ip->ip6_src;
  956         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
  957                 sin6->sin6_addr.s6_addr16[1] = 0;
  958         sin6->sin6_scope_id =
  959                 (m->m_pkthdr.rcvif && IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
  960                 ? m->m_pkthdr.rcvif->if_index : 0;
  961 
  962         return;
  963 }

Cache object: b310ebcb02e601c914a341d4a5a25e98


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