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/netinet/in.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) 1982, 1986, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * Copyright (C) 2001 WIDE Project.  All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 4. Neither the name of the University nor the names of its contributors
   15  *    may be used to endorse or promote products derived from this software
   16  *    without specific prior written permission.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  *
   30  *      @(#)in.c        8.4 (Berkeley) 1/9/95
   31  * $FreeBSD: releng/6.1/sys/netinet/in.c 155109 2006-01-31 16:11:37Z andre $
   32  */
   33 
   34 #include "opt_carp.h"
   35 
   36 #include <sys/param.h>
   37 #include <sys/systm.h>
   38 #include <sys/sockio.h>
   39 #include <sys/malloc.h>
   40 #include <sys/socket.h>
   41 #include <sys/kernel.h>
   42 #include <sys/sysctl.h>
   43 
   44 #include <net/if.h>
   45 #include <net/if_types.h>
   46 #include <net/route.h>
   47 
   48 #include <netinet/in.h>
   49 #include <netinet/in_var.h>
   50 #include <netinet/in_pcb.h>
   51 
   52 #include <netinet/igmp_var.h>
   53 
   54 static MALLOC_DEFINE(M_IPMADDR, "in_multi", "internet multicast address");
   55 
   56 static int in_mask2len(struct in_addr *);
   57 static void in_len2mask(struct in_addr *, int);
   58 static int in_lifaddr_ioctl(struct socket *, u_long, caddr_t,
   59         struct ifnet *, struct thread *);
   60 
   61 static int      in_addprefix(struct in_ifaddr *, int);
   62 static int      in_scrubprefix(struct in_ifaddr *);
   63 static void     in_socktrim(struct sockaddr_in *);
   64 static int      in_ifinit(struct ifnet *,
   65             struct in_ifaddr *, struct sockaddr_in *, int);
   66 
   67 static int subnetsarelocal = 0;
   68 SYSCTL_INT(_net_inet_ip, OID_AUTO, subnets_are_local, CTLFLAG_RW,
   69         &subnetsarelocal, 0, "Treat all subnets as directly connected");
   70 static int sameprefixcarponly = 0;
   71 SYSCTL_INT(_net_inet_ip, OID_AUTO, same_prefix_carp_only, CTLFLAG_RW,
   72         &sameprefixcarponly, 0,
   73         "Refuse to create same prefixes on different interfaces");
   74 
   75 /*
   76  * The IPv4 multicast list (in_multihead and associated structures) are
   77  * protected by the global in_multi_mtx.  See in_var.h for more details.  For
   78  * now, in_multi_mtx is marked as recursible due to IGMP's calling back into
   79  * ip_output() to send IGMP packets while holding the lock; this probably is
   80  * not quite desirable.
   81  */
   82 struct in_multihead in_multihead; /* XXX BSS initialization */
   83 struct mtx in_multi_mtx;
   84 MTX_SYSINIT(in_multi_mtx, &in_multi_mtx, "in_multi_mtx", MTX_DEF | MTX_RECURSE);
   85 
   86 extern struct inpcbinfo ripcbinfo;
   87 extern struct inpcbinfo udbinfo;
   88 
   89 /*
   90  * Return 1 if an internet address is for a ``local'' host
   91  * (one to which we have a connection).  If subnetsarelocal
   92  * is true, this includes other subnets of the local net.
   93  * Otherwise, it includes only the directly-connected (sub)nets.
   94  */
   95 int
   96 in_localaddr(in)
   97         struct in_addr in;
   98 {
   99         register u_long i = ntohl(in.s_addr);
  100         register struct in_ifaddr *ia;
  101 
  102         if (subnetsarelocal) {
  103                 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link)
  104                         if ((i & ia->ia_netmask) == ia->ia_net)
  105                                 return (1);
  106         } else {
  107                 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link)
  108                         if ((i & ia->ia_subnetmask) == ia->ia_subnet)
  109                                 return (1);
  110         }
  111         return (0);
  112 }
  113 
  114 /*
  115  * Return 1 if an internet address is for the local host and configured
  116  * on one of its interfaces.
  117  */
  118 int
  119 in_localip(in)
  120         struct in_addr in;
  121 {
  122         struct in_ifaddr *ia;
  123 
  124         LIST_FOREACH(ia, INADDR_HASH(in.s_addr), ia_hash) {
  125                 if (IA_SIN(ia)->sin_addr.s_addr == in.s_addr)
  126                         return 1;
  127         }
  128         return 0;
  129 }
  130 
  131 /*
  132  * Determine whether an IP address is in a reserved set of addresses
  133  * that may not be forwarded, or whether datagrams to that destination
  134  * may be forwarded.
  135  */
  136 int
  137 in_canforward(in)
  138         struct in_addr in;
  139 {
  140         register u_long i = ntohl(in.s_addr);
  141         register u_long net;
  142 
  143         if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i))
  144                 return (0);
  145         if (IN_CLASSA(i)) {
  146                 net = i & IN_CLASSA_NET;
  147                 if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
  148                         return (0);
  149         }
  150         return (1);
  151 }
  152 
  153 /*
  154  * Trim a mask in a sockaddr
  155  */
  156 static void
  157 in_socktrim(ap)
  158 struct sockaddr_in *ap;
  159 {
  160     register char *cplim = (char *) &ap->sin_addr;
  161     register char *cp = (char *) (&ap->sin_addr + 1);
  162 
  163     ap->sin_len = 0;
  164     while (--cp >= cplim)
  165         if (*cp) {
  166             (ap)->sin_len = cp - (char *) (ap) + 1;
  167             break;
  168         }
  169 }
  170 
  171 static int
  172 in_mask2len(mask)
  173         struct in_addr *mask;
  174 {
  175         int x, y;
  176         u_char *p;
  177 
  178         p = (u_char *)mask;
  179         for (x = 0; x < sizeof(*mask); x++) {
  180                 if (p[x] != 0xff)
  181                         break;
  182         }
  183         y = 0;
  184         if (x < sizeof(*mask)) {
  185                 for (y = 0; y < 8; y++) {
  186                         if ((p[x] & (0x80 >> y)) == 0)
  187                                 break;
  188                 }
  189         }
  190         return x * 8 + y;
  191 }
  192 
  193 static void
  194 in_len2mask(mask, len)
  195         struct in_addr *mask;
  196         int len;
  197 {
  198         int i;
  199         u_char *p;
  200 
  201         p = (u_char *)mask;
  202         bzero(mask, sizeof(*mask));
  203         for (i = 0; i < len / 8; i++)
  204                 p[i] = 0xff;
  205         if (len % 8)
  206                 p[i] = (0xff00 >> (len % 8)) & 0xff;
  207 }
  208 
  209 /*
  210  * Generic internet control operations (ioctl's).
  211  * Ifp is 0 if not an interface-specific ioctl.
  212  */
  213 /* ARGSUSED */
  214 int
  215 in_control(so, cmd, data, ifp, td)
  216         struct socket *so;
  217         u_long cmd;
  218         caddr_t data;
  219         register struct ifnet *ifp;
  220         struct thread *td;
  221 {
  222         register struct ifreq *ifr = (struct ifreq *)data;
  223         register struct in_ifaddr *ia = 0, *iap;
  224         register struct ifaddr *ifa;
  225         struct in_addr dst;
  226         struct in_ifaddr *oia;
  227         struct in_aliasreq *ifra = (struct in_aliasreq *)data;
  228         struct sockaddr_in oldaddr;
  229         int error, hostIsNew, iaIsNew, maskIsNew, s;
  230 
  231         iaIsNew = 0;
  232 
  233         switch (cmd) {
  234         case SIOCALIFADDR:
  235         case SIOCDLIFADDR:
  236                 if (td && (error = suser(td)) != 0)
  237                         return error;
  238                 /*fall through*/
  239         case SIOCGLIFADDR:
  240                 if (!ifp)
  241                         return EINVAL;
  242                 return in_lifaddr_ioctl(so, cmd, data, ifp, td);
  243         }
  244 
  245         /*
  246          * Find address for this interface, if it exists.
  247          *
  248          * If an alias address was specified, find that one instead of
  249          * the first one on the interface, if possible.
  250          */
  251         if (ifp) {
  252                 dst = ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
  253                 LIST_FOREACH(iap, INADDR_HASH(dst.s_addr), ia_hash)
  254                         if (iap->ia_ifp == ifp &&
  255                             iap->ia_addr.sin_addr.s_addr == dst.s_addr) {
  256                                 ia = iap;
  257                                 break;
  258                         }
  259                 if (ia == NULL)
  260                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
  261                                 iap = ifatoia(ifa);
  262                                 if (iap->ia_addr.sin_family == AF_INET) {
  263                                         ia = iap;
  264                                         break;
  265                                 }
  266                         }
  267         }
  268 
  269         switch (cmd) {
  270 
  271         case SIOCAIFADDR:
  272         case SIOCDIFADDR:
  273                 if (ifp == 0)
  274                         return (EADDRNOTAVAIL);
  275                 if (ifra->ifra_addr.sin_family == AF_INET) {
  276                         for (oia = ia; ia; ia = TAILQ_NEXT(ia, ia_link)) {
  277                                 if (ia->ia_ifp == ifp  &&
  278                                     ia->ia_addr.sin_addr.s_addr ==
  279                                     ifra->ifra_addr.sin_addr.s_addr)
  280                                         break;
  281                         }
  282                         if ((ifp->if_flags & IFF_POINTOPOINT)
  283                             && (cmd == SIOCAIFADDR)
  284                             && (ifra->ifra_dstaddr.sin_addr.s_addr
  285                                 == INADDR_ANY)) {
  286                                 return EDESTADDRREQ;
  287                         }
  288                 }
  289                 if (cmd == SIOCDIFADDR && ia == 0)
  290                         return (EADDRNOTAVAIL);
  291                 /* FALLTHROUGH */
  292         case SIOCSIFADDR:
  293         case SIOCSIFNETMASK:
  294         case SIOCSIFDSTADDR:
  295                 if (td && (error = suser(td)) != 0)
  296                         return error;
  297 
  298                 if (ifp == 0)
  299                         return (EADDRNOTAVAIL);
  300                 if (ia == (struct in_ifaddr *)0) {
  301                         ia = (struct in_ifaddr *)
  302                                 malloc(sizeof *ia, M_IFADDR, M_WAITOK | M_ZERO);
  303                         if (ia == (struct in_ifaddr *)NULL)
  304                                 return (ENOBUFS);
  305                         /*
  306                          * Protect from ipintr() traversing address list
  307                          * while we're modifying it.
  308                          */
  309                         s = splnet();
  310                         ifa = &ia->ia_ifa;
  311                         IFA_LOCK_INIT(ifa);
  312                         ifa->ifa_addr = (struct sockaddr *)&ia->ia_addr;
  313                         ifa->ifa_dstaddr = (struct sockaddr *)&ia->ia_dstaddr;
  314                         ifa->ifa_netmask = (struct sockaddr *)&ia->ia_sockmask;
  315                         ifa->ifa_refcnt = 1;
  316                         TAILQ_INSERT_TAIL(&ifp->if_addrhead, ifa, ifa_link);
  317 
  318                         ia->ia_sockmask.sin_len = 8;
  319                         ia->ia_sockmask.sin_family = AF_INET;
  320                         if (ifp->if_flags & IFF_BROADCAST) {
  321                                 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
  322                                 ia->ia_broadaddr.sin_family = AF_INET;
  323                         }
  324                         ia->ia_ifp = ifp;
  325 
  326                         TAILQ_INSERT_TAIL(&in_ifaddrhead, ia, ia_link);
  327                         splx(s);
  328                         iaIsNew = 1;
  329                 }
  330                 break;
  331 
  332         case SIOCSIFBRDADDR:
  333                 if (td && (error = suser(td)) != 0)
  334                         return error;
  335                 /* FALLTHROUGH */
  336 
  337         case SIOCGIFADDR:
  338         case SIOCGIFNETMASK:
  339         case SIOCGIFDSTADDR:
  340         case SIOCGIFBRDADDR:
  341                 if (ia == (struct in_ifaddr *)0)
  342                         return (EADDRNOTAVAIL);
  343                 break;
  344         }
  345         switch (cmd) {
  346 
  347         case SIOCGIFADDR:
  348                 *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;
  349                 return (0);
  350 
  351         case SIOCGIFBRDADDR:
  352                 if ((ifp->if_flags & IFF_BROADCAST) == 0)
  353                         return (EINVAL);
  354                 *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;
  355                 return (0);
  356 
  357         case SIOCGIFDSTADDR:
  358                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  359                         return (EINVAL);
  360                 *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;
  361                 return (0);
  362 
  363         case SIOCGIFNETMASK:
  364                 *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;
  365                 return (0);
  366 
  367         case SIOCSIFDSTADDR:
  368                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  369                         return (EINVAL);
  370                 oldaddr = ia->ia_dstaddr;
  371                 ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;
  372                 if (ifp->if_ioctl) {
  373                         IFF_LOCKGIANT(ifp);
  374                         error = (*ifp->if_ioctl)(ifp, SIOCSIFDSTADDR,
  375                             (caddr_t)ia);
  376                         IFF_UNLOCKGIANT(ifp);
  377                         if (error) {
  378                                 ia->ia_dstaddr = oldaddr;
  379                                 return (error);
  380                         }
  381                 }
  382                 if (ia->ia_flags & IFA_ROUTE) {
  383                         ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;
  384                         rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  385                         ia->ia_ifa.ifa_dstaddr =
  386                                         (struct sockaddr *)&ia->ia_dstaddr;
  387                         rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
  388                 }
  389                 return (0);
  390 
  391         case SIOCSIFBRDADDR:
  392                 if ((ifp->if_flags & IFF_BROADCAST) == 0)
  393                         return (EINVAL);
  394                 ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;
  395                 return (0);
  396 
  397         case SIOCSIFADDR:
  398                 error = in_ifinit(ifp, ia,
  399                     (struct sockaddr_in *) &ifr->ifr_addr, 1);
  400                 if (error != 0 && iaIsNew)
  401                         break;
  402                 if (error == 0)
  403                         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  404                 return (0);
  405 
  406         case SIOCSIFNETMASK:
  407                 ia->ia_sockmask.sin_addr = ifra->ifra_addr.sin_addr;
  408                 ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr);
  409                 return (0);
  410 
  411         case SIOCAIFADDR:
  412                 maskIsNew = 0;
  413                 hostIsNew = 1;
  414                 error = 0;
  415                 if (ia->ia_addr.sin_family == AF_INET) {
  416                         if (ifra->ifra_addr.sin_len == 0) {
  417                                 ifra->ifra_addr = ia->ia_addr;
  418                                 hostIsNew = 0;
  419                         } else if (ifra->ifra_addr.sin_addr.s_addr ==
  420                                                ia->ia_addr.sin_addr.s_addr)
  421                                 hostIsNew = 0;
  422                 }
  423                 if (ifra->ifra_mask.sin_len) {
  424                         in_ifscrub(ifp, ia);
  425                         ia->ia_sockmask = ifra->ifra_mask;
  426                         ia->ia_sockmask.sin_family = AF_INET;
  427                         ia->ia_subnetmask =
  428                              ntohl(ia->ia_sockmask.sin_addr.s_addr);
  429                         maskIsNew = 1;
  430                 }
  431                 if ((ifp->if_flags & IFF_POINTOPOINT) &&
  432                     (ifra->ifra_dstaddr.sin_family == AF_INET)) {
  433                         in_ifscrub(ifp, ia);
  434                         ia->ia_dstaddr = ifra->ifra_dstaddr;
  435                         maskIsNew  = 1; /* We lie; but the effect's the same */
  436                 }
  437                 if (ifra->ifra_addr.sin_family == AF_INET &&
  438                     (hostIsNew || maskIsNew))
  439                         error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
  440                 if (error != 0 && iaIsNew)
  441                         break;
  442 
  443                 if ((ifp->if_flags & IFF_BROADCAST) &&
  444                     (ifra->ifra_broadaddr.sin_family == AF_INET))
  445                         ia->ia_broadaddr = ifra->ifra_broadaddr;
  446                 if (error == 0)
  447                         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  448                 return (error);
  449 
  450         case SIOCDIFADDR:
  451                 /*
  452                  * in_ifscrub kills the interface route.
  453                  */
  454                 in_ifscrub(ifp, ia);
  455                 /*
  456                  * in_ifadown gets rid of all the rest of
  457                  * the routes.  This is not quite the right
  458                  * thing to do, but at least if we are running
  459                  * a routing process they will come back.
  460                  */
  461                 in_ifadown(&ia->ia_ifa, 1);
  462                 EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  463                 error = 0;
  464                 break;
  465 
  466         default:
  467                 if (ifp == 0 || ifp->if_ioctl == 0)
  468                         return (EOPNOTSUPP);
  469                 IFF_LOCKGIANT(ifp);
  470                 error = (*ifp->if_ioctl)(ifp, cmd, data);
  471                 IFF_UNLOCKGIANT(ifp);
  472                 return (error);
  473         }
  474 
  475         /*
  476          * Protect from ipintr() traversing address list while we're modifying
  477          * it.
  478          */
  479         s = splnet();
  480         TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
  481         TAILQ_REMOVE(&in_ifaddrhead, ia, ia_link);
  482         if (ia->ia_addr.sin_family == AF_INET)
  483                 LIST_REMOVE(ia, ia_hash);
  484         IFAFREE(&ia->ia_ifa);
  485         splx(s);
  486 
  487         return (error);
  488 }
  489 
  490 /*
  491  * SIOC[GAD]LIFADDR.
  492  *      SIOCGLIFADDR: get first address. (?!?)
  493  *      SIOCGLIFADDR with IFLR_PREFIX:
  494  *              get first address that matches the specified prefix.
  495  *      SIOCALIFADDR: add the specified address.
  496  *      SIOCALIFADDR with IFLR_PREFIX:
  497  *              EINVAL since we can't deduce hostid part of the address.
  498  *      SIOCDLIFADDR: delete the specified address.
  499  *      SIOCDLIFADDR with IFLR_PREFIX:
  500  *              delete the first address that matches the specified prefix.
  501  * return values:
  502  *      EINVAL on invalid parameters
  503  *      EADDRNOTAVAIL on prefix match failed/specified address not found
  504  *      other values may be returned from in_ioctl()
  505  */
  506 static int
  507 in_lifaddr_ioctl(so, cmd, data, ifp, td)
  508         struct socket *so;
  509         u_long cmd;
  510         caddr_t data;
  511         struct ifnet *ifp;
  512         struct thread *td;
  513 {
  514         struct if_laddrreq *iflr = (struct if_laddrreq *)data;
  515         struct ifaddr *ifa;
  516 
  517         /* sanity checks */
  518         if (!data || !ifp) {
  519                 panic("invalid argument to in_lifaddr_ioctl");
  520                 /*NOTRECHED*/
  521         }
  522 
  523         switch (cmd) {
  524         case SIOCGLIFADDR:
  525                 /* address must be specified on GET with IFLR_PREFIX */
  526                 if ((iflr->flags & IFLR_PREFIX) == 0)
  527                         break;
  528                 /*FALLTHROUGH*/
  529         case SIOCALIFADDR:
  530         case SIOCDLIFADDR:
  531                 /* address must be specified on ADD and DELETE */
  532                 if (iflr->addr.ss_family != AF_INET)
  533                         return EINVAL;
  534                 if (iflr->addr.ss_len != sizeof(struct sockaddr_in))
  535                         return EINVAL;
  536                 /* XXX need improvement */
  537                 if (iflr->dstaddr.ss_family
  538                  && iflr->dstaddr.ss_family != AF_INET)
  539                         return EINVAL;
  540                 if (iflr->dstaddr.ss_family
  541                  && iflr->dstaddr.ss_len != sizeof(struct sockaddr_in))
  542                         return EINVAL;
  543                 break;
  544         default: /*shouldn't happen*/
  545                 return EOPNOTSUPP;
  546         }
  547         if (sizeof(struct in_addr) * 8 < iflr->prefixlen)
  548                 return EINVAL;
  549 
  550         switch (cmd) {
  551         case SIOCALIFADDR:
  552             {
  553                 struct in_aliasreq ifra;
  554 
  555                 if (iflr->flags & IFLR_PREFIX)
  556                         return EINVAL;
  557 
  558                 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */
  559                 bzero(&ifra, sizeof(ifra));
  560                 bcopy(iflr->iflr_name, ifra.ifra_name,
  561                         sizeof(ifra.ifra_name));
  562 
  563                 bcopy(&iflr->addr, &ifra.ifra_addr, iflr->addr.ss_len);
  564 
  565                 if (iflr->dstaddr.ss_family) {  /*XXX*/
  566                         bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr,
  567                                 iflr->dstaddr.ss_len);
  568                 }
  569 
  570                 ifra.ifra_mask.sin_family = AF_INET;
  571                 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in);
  572                 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen);
  573 
  574                 return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, td);
  575             }
  576         case SIOCGLIFADDR:
  577         case SIOCDLIFADDR:
  578             {
  579                 struct in_ifaddr *ia;
  580                 struct in_addr mask, candidate, match;
  581                 struct sockaddr_in *sin;
  582                 int cmp;
  583 
  584                 bzero(&mask, sizeof(mask));
  585                 if (iflr->flags & IFLR_PREFIX) {
  586                         /* lookup a prefix rather than address. */
  587                         in_len2mask(&mask, iflr->prefixlen);
  588 
  589                         sin = (struct sockaddr_in *)&iflr->addr;
  590                         match.s_addr = sin->sin_addr.s_addr;
  591                         match.s_addr &= mask.s_addr;
  592 
  593                         /* if you set extra bits, that's wrong */
  594                         if (match.s_addr != sin->sin_addr.s_addr)
  595                                 return EINVAL;
  596 
  597                         cmp = 1;
  598                 } else {
  599                         if (cmd == SIOCGLIFADDR) {
  600                                 /* on getting an address, take the 1st match */
  601                                 cmp = 0;        /*XXX*/
  602                         } else {
  603                                 /* on deleting an address, do exact match */
  604                                 in_len2mask(&mask, 32);
  605                                 sin = (struct sockaddr_in *)&iflr->addr;
  606                                 match.s_addr = sin->sin_addr.s_addr;
  607 
  608                                 cmp = 1;
  609                         }
  610                 }
  611 
  612                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
  613                         if (ifa->ifa_addr->sa_family != AF_INET6)
  614                                 continue;
  615                         if (!cmp)
  616                                 break;
  617                         candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr;
  618                         candidate.s_addr &= mask.s_addr;
  619                         if (candidate.s_addr == match.s_addr)
  620                                 break;
  621                 }
  622                 if (!ifa)
  623                         return EADDRNOTAVAIL;
  624                 ia = (struct in_ifaddr *)ifa;
  625 
  626                 if (cmd == SIOCGLIFADDR) {
  627                         /* fill in the if_laddrreq structure */
  628                         bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len);
  629 
  630                         if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
  631                                 bcopy(&ia->ia_dstaddr, &iflr->dstaddr,
  632                                         ia->ia_dstaddr.sin_len);
  633                         } else
  634                                 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr));
  635 
  636                         iflr->prefixlen =
  637                                 in_mask2len(&ia->ia_sockmask.sin_addr);
  638 
  639                         iflr->flags = 0;        /*XXX*/
  640 
  641                         return 0;
  642                 } else {
  643                         struct in_aliasreq ifra;
  644 
  645                         /* fill in_aliasreq and do ioctl(SIOCDIFADDR_IN6) */
  646                         bzero(&ifra, sizeof(ifra));
  647                         bcopy(iflr->iflr_name, ifra.ifra_name,
  648                                 sizeof(ifra.ifra_name));
  649 
  650                         bcopy(&ia->ia_addr, &ifra.ifra_addr,
  651                                 ia->ia_addr.sin_len);
  652                         if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
  653                                 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr,
  654                                         ia->ia_dstaddr.sin_len);
  655                         }
  656                         bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr,
  657                                 ia->ia_sockmask.sin_len);
  658 
  659                         return in_control(so, SIOCDIFADDR, (caddr_t)&ifra,
  660                                           ifp, td);
  661                 }
  662             }
  663         }
  664 
  665         return EOPNOTSUPP;      /*just for safety*/
  666 }
  667 
  668 /*
  669  * Delete any existing route for an interface.
  670  */
  671 void
  672 in_ifscrub(ifp, ia)
  673         register struct ifnet *ifp;
  674         register struct in_ifaddr *ia;
  675 {
  676         in_scrubprefix(ia);
  677 }
  678 
  679 /*
  680  * Initialize an interface's internet address
  681  * and routing table entry.
  682  */
  683 static int
  684 in_ifinit(ifp, ia, sin, scrub)
  685         register struct ifnet *ifp;
  686         register struct in_ifaddr *ia;
  687         struct sockaddr_in *sin;
  688         int scrub;
  689 {
  690         register u_long i = ntohl(sin->sin_addr.s_addr);
  691         struct sockaddr_in oldaddr;
  692         int s = splimp(), flags = RTF_UP, error = 0;
  693 
  694         oldaddr = ia->ia_addr;
  695         if (oldaddr.sin_family == AF_INET)
  696                 LIST_REMOVE(ia, ia_hash);
  697         ia->ia_addr = *sin;
  698         if (ia->ia_addr.sin_family == AF_INET)
  699                 LIST_INSERT_HEAD(INADDR_HASH(ia->ia_addr.sin_addr.s_addr),
  700                     ia, ia_hash);
  701         /*
  702          * Give the interface a chance to initialize
  703          * if this is its first address,
  704          * and to validate the address if necessary.
  705          */
  706         if (ifp->if_ioctl) {
  707                 IFF_LOCKGIANT(ifp);
  708                 error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia);
  709                 IFF_UNLOCKGIANT(ifp);
  710                 if (error) {
  711                         splx(s);
  712                         /* LIST_REMOVE(ia, ia_hash) is done in in_control */
  713                         ia->ia_addr = oldaddr;
  714                         if (ia->ia_addr.sin_family == AF_INET)
  715                                 LIST_INSERT_HEAD(INADDR_HASH(
  716                                     ia->ia_addr.sin_addr.s_addr), ia, ia_hash);
  717                         return (error);
  718                 }
  719         }
  720         splx(s);
  721         if (scrub) {
  722                 ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
  723                 in_ifscrub(ifp, ia);
  724                 ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  725         }
  726         if (IN_CLASSA(i))
  727                 ia->ia_netmask = IN_CLASSA_NET;
  728         else if (IN_CLASSB(i))
  729                 ia->ia_netmask = IN_CLASSB_NET;
  730         else
  731                 ia->ia_netmask = IN_CLASSC_NET;
  732         /*
  733          * The subnet mask usually includes at least the standard network part,
  734          * but may may be smaller in the case of supernetting.
  735          * If it is set, we believe it.
  736          */
  737         if (ia->ia_subnetmask == 0) {
  738                 ia->ia_subnetmask = ia->ia_netmask;
  739                 ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
  740         } else
  741                 ia->ia_netmask &= ia->ia_subnetmask;
  742         ia->ia_net = i & ia->ia_netmask;
  743         ia->ia_subnet = i & ia->ia_subnetmask;
  744         in_socktrim(&ia->ia_sockmask);
  745 #ifdef DEV_CARP
  746         /*
  747          * XXX: carp(4) does not have interface route
  748          */
  749         if (ifp->if_type == IFT_CARP)
  750                 return (0);
  751 #endif
  752         /*
  753          * Add route for the network.
  754          */
  755         ia->ia_ifa.ifa_metric = ifp->if_metric;
  756         if (ifp->if_flags & IFF_BROADCAST) {
  757                 ia->ia_broadaddr.sin_addr.s_addr =
  758                         htonl(ia->ia_subnet | ~ia->ia_subnetmask);
  759                 ia->ia_netbroadcast.s_addr =
  760                         htonl(ia->ia_net | ~ ia->ia_netmask);
  761         } else if (ifp->if_flags & IFF_LOOPBACK) {
  762                 ia->ia_dstaddr = ia->ia_addr;
  763                 flags |= RTF_HOST;
  764         } else if (ifp->if_flags & IFF_POINTOPOINT) {
  765                 if (ia->ia_dstaddr.sin_family != AF_INET)
  766                         return (0);
  767                 flags |= RTF_HOST;
  768         }
  769         if ((error = in_addprefix(ia, flags)) != 0)
  770                 return (error);
  771 
  772         /*
  773          * If the interface supports multicast, join the "all hosts"
  774          * multicast group on that interface.
  775          */
  776         if (ifp->if_flags & IFF_MULTICAST) {
  777                 struct in_addr addr;
  778 
  779                 addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
  780                 in_addmulti(&addr, ifp);
  781         }
  782         return (error);
  783 }
  784 
  785 #define rtinitflags(x) \
  786         ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \
  787             ? RTF_HOST : 0)
  788 /*
  789  * Check if we have a route for the given prefix already or add a one
  790  * accordingly.
  791  */
  792 static int
  793 in_addprefix(target, flags)
  794         struct in_ifaddr *target;
  795         int flags;
  796 {
  797         struct in_ifaddr *ia;
  798         struct in_addr prefix, mask, p, m;
  799         int error;
  800 
  801         if ((flags & RTF_HOST) != 0)
  802                 prefix = target->ia_dstaddr.sin_addr;
  803         else {
  804                 prefix = target->ia_addr.sin_addr;
  805                 mask = target->ia_sockmask.sin_addr;
  806                 prefix.s_addr &= mask.s_addr;
  807         }
  808 
  809         TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) {
  810                 if (rtinitflags(ia)) {
  811                         p = ia->ia_addr.sin_addr;
  812 
  813                         if (prefix.s_addr != p.s_addr)
  814                                 continue;
  815                 } else {
  816                         p = ia->ia_addr.sin_addr;
  817                         m = ia->ia_sockmask.sin_addr;
  818                         p.s_addr &= m.s_addr;
  819 
  820                         if (prefix.s_addr != p.s_addr ||
  821                             mask.s_addr != m.s_addr)
  822                                 continue;
  823                 }
  824 
  825                 /*
  826                  * If we got a matching prefix route inserted by other
  827                  * interface address, we are done here.
  828                  */
  829                 if (ia->ia_flags & IFA_ROUTE) {
  830                         if (sameprefixcarponly &&
  831                             target->ia_ifp->if_type != IFT_CARP &&
  832                             ia->ia_ifp->if_type != IFT_CARP)
  833                                 return (EEXIST);
  834                         else
  835                                 return (0);
  836                 }
  837         }
  838 
  839         /*
  840          * No-one seem to have this prefix route, so we try to insert it.
  841          */
  842         error = rtinit(&target->ia_ifa, (int)RTM_ADD, flags);
  843         if (!error)
  844                 target->ia_flags |= IFA_ROUTE;
  845         return error;
  846 }
  847 
  848 /*
  849  * If there is no other address in the system that can serve a route to the
  850  * same prefix, remove the route.  Hand over the route to the new address
  851  * otherwise.
  852  */
  853 static int
  854 in_scrubprefix(target)
  855         struct in_ifaddr *target;
  856 {
  857         struct in_ifaddr *ia;
  858         struct in_addr prefix, mask, p;
  859         int error;
  860 
  861         if ((target->ia_flags & IFA_ROUTE) == 0)
  862                 return 0;
  863 
  864         if (rtinitflags(target))
  865                 prefix = target->ia_dstaddr.sin_addr;
  866         else {
  867                 prefix = target->ia_addr.sin_addr;
  868                 mask = target->ia_sockmask.sin_addr;
  869                 prefix.s_addr &= mask.s_addr;
  870         }
  871 
  872         TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) {
  873                 if (rtinitflags(ia))
  874                         p = ia->ia_dstaddr.sin_addr;
  875                 else {
  876                         p = ia->ia_addr.sin_addr;
  877                         p.s_addr &= ia->ia_sockmask.sin_addr.s_addr;
  878                 }
  879 
  880                 if (prefix.s_addr != p.s_addr)
  881                         continue;
  882 
  883                 /*
  884                  * If we got a matching prefix address, move IFA_ROUTE and
  885                  * the route itself to it.  Make sure that routing daemons
  886                  * get a heads-up.
  887                  *
  888                  * XXX: a special case for carp(4) interface
  889                  */
  890                 if ((ia->ia_flags & IFA_ROUTE) == 0
  891 #ifdef DEV_CARP
  892                     && (ia->ia_ifp->if_type != IFT_CARP)
  893 #endif
  894                                                         ) {
  895                         rtinit(&(target->ia_ifa), (int)RTM_DELETE,
  896                             rtinitflags(target));
  897                         target->ia_flags &= ~IFA_ROUTE;
  898 
  899                         error = rtinit(&ia->ia_ifa, (int)RTM_ADD,
  900                             rtinitflags(ia) | RTF_UP);
  901                         if (error == 0)
  902                                 ia->ia_flags |= IFA_ROUTE;
  903                         return error;
  904                 }
  905         }
  906 
  907         /*
  908          * As no-one seem to have this prefix, we can remove the route.
  909          */
  910         rtinit(&(target->ia_ifa), (int)RTM_DELETE, rtinitflags(target));
  911         target->ia_flags &= ~IFA_ROUTE;
  912         return 0;
  913 }
  914 
  915 #undef rtinitflags
  916 
  917 /*
  918  * Return 1 if the address might be a local broadcast address.
  919  */
  920 int
  921 in_broadcast(in, ifp)
  922         struct in_addr in;
  923         struct ifnet *ifp;
  924 {
  925         register struct ifaddr *ifa;
  926         u_long t;
  927 
  928         if (in.s_addr == INADDR_BROADCAST ||
  929             in.s_addr == INADDR_ANY)
  930                 return 1;
  931         if ((ifp->if_flags & IFF_BROADCAST) == 0)
  932                 return 0;
  933         t = ntohl(in.s_addr);
  934         /*
  935          * Look through the list of addresses for a match
  936          * with a broadcast address.
  937          */
  938 #define ia ((struct in_ifaddr *)ifa)
  939         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
  940                 if (ifa->ifa_addr->sa_family == AF_INET &&
  941                     (in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
  942                      in.s_addr == ia->ia_netbroadcast.s_addr ||
  943                      /*
  944                       * Check for old-style (host 0) broadcast.
  945                       */
  946                      t == ia->ia_subnet || t == ia->ia_net) &&
  947                      /*
  948                       * Check for an all one subnetmask. These
  949                       * only exist when an interface gets a secondary
  950                       * address.
  951                       */
  952                      ia->ia_subnetmask != (u_long)0xffffffff)
  953                             return 1;
  954         return (0);
  955 #undef ia
  956 }
  957 /*
  958  * Add an address to the list of IP multicast addresses for a given interface.
  959  */
  960 struct in_multi *
  961 in_addmulti(ap, ifp)
  962         register struct in_addr *ap;
  963         register struct ifnet *ifp;
  964 {
  965         register struct in_multi *inm;
  966         int error;
  967         struct sockaddr_in sin;
  968         struct ifmultiaddr *ifma;
  969 
  970         IFF_LOCKGIANT(ifp);
  971         IN_MULTI_LOCK();
  972         /*
  973          * Call generic routine to add membership or increment
  974          * refcount.  It wants addresses in the form of a sockaddr,
  975          * so we build one here (being careful to zero the unused bytes).
  976          */
  977         bzero(&sin, sizeof sin);
  978         sin.sin_family = AF_INET;
  979         sin.sin_len = sizeof sin;
  980         sin.sin_addr = *ap;
  981         error = if_addmulti(ifp, (struct sockaddr *)&sin, &ifma);
  982         if (error) {
  983                 IN_MULTI_UNLOCK();
  984                 IFF_UNLOCKGIANT(ifp);
  985                 return 0;
  986         }
  987 
  988         /*
  989          * If ifma->ifma_protospec is null, then if_addmulti() created
  990          * a new record.  Otherwise, we are done.
  991          */
  992         if (ifma->ifma_protospec != NULL) {
  993                 IN_MULTI_UNLOCK();
  994                 IFF_UNLOCKGIANT(ifp);
  995                 return ifma->ifma_protospec;
  996         }
  997 
  998         inm = (struct in_multi *)malloc(sizeof(*inm), M_IPMADDR,
  999             M_NOWAIT | M_ZERO);
 1000         if (inm == NULL) {
 1001                 IN_MULTI_UNLOCK();
 1002                 IFF_UNLOCKGIANT(ifp);
 1003                 return (NULL);
 1004         }
 1005 
 1006         inm->inm_addr = *ap;
 1007         inm->inm_ifp = ifp;
 1008         inm->inm_ifma = ifma;
 1009         ifma->ifma_protospec = inm;
 1010         LIST_INSERT_HEAD(&in_multihead, inm, inm_link);
 1011 
 1012         /*
 1013          * Let IGMP know that we have joined a new IP multicast group.
 1014          */
 1015         igmp_joingroup(inm);
 1016         IN_MULTI_UNLOCK();
 1017         IFF_UNLOCKGIANT(ifp);
 1018         return (inm);
 1019 }
 1020 
 1021 /*
 1022  * Delete a multicast address record.
 1023  */
 1024 void
 1025 in_delmulti(inm)
 1026         register struct in_multi *inm;
 1027 {
 1028         struct ifmultiaddr *ifma;
 1029         struct in_multi my_inm;
 1030         struct ifnet *ifp;
 1031 
 1032         ifp = inm->inm_ifp;
 1033         IFF_LOCKGIANT(ifp);
 1034         IN_MULTI_LOCK();
 1035         ifma = inm->inm_ifma;
 1036         my_inm.inm_ifp = NULL ; /* don't send the leave msg */
 1037         if (ifma->ifma_refcount == 1) {
 1038                 /*
 1039                  * No remaining claims to this record; let IGMP know that
 1040                  * we are leaving the multicast group.
 1041                  * But do it after the if_delmulti() which might reset
 1042                  * the interface and nuke the packet.
 1043                  */
 1044                 my_inm = *inm ;
 1045                 ifma->ifma_protospec = NULL;
 1046                 LIST_REMOVE(inm, inm_link);
 1047                 free(inm, M_IPMADDR);
 1048         }
 1049         /* XXX - should be separate API for when we have an ifma? */
 1050         if_delmulti(ifma->ifma_ifp, ifma->ifma_addr);
 1051         if (my_inm.inm_ifp != NULL)
 1052                 igmp_leavegroup(&my_inm);
 1053         IN_MULTI_UNLOCK();
 1054         IFF_UNLOCKGIANT(ifp);
 1055 }
 1056 
 1057 /*
 1058  * On interface removal, clean up IPv4 data structures hung off of the ifnet.
 1059  */
 1060 void
 1061 in_ifdetach(ifp)
 1062         struct ifnet *ifp;
 1063 {
 1064 
 1065         in_pcbpurgeif0(&ripcbinfo, ifp);
 1066         in_pcbpurgeif0(&udbinfo, ifp);
 1067 }

Cache object: b89ece006dee65e83380cffd191fe3fa


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