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

Cache object: b1945080d92fff094aa42b79f1bb02e2


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