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  */
   32 
   33 #include <sys/cdefs.h>
   34 __FBSDID("$FreeBSD: releng/8.0/sys/netinet/in.c 198298 2009-10-20 17:44:50Z qingli $");
   35 
   36 #include "opt_carp.h"
   37 
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/sockio.h>
   41 #include <sys/malloc.h>
   42 #include <sys/priv.h>
   43 #include <sys/socket.h>
   44 #include <sys/jail.h>
   45 #include <sys/kernel.h>
   46 #include <sys/proc.h>
   47 #include <sys/sysctl.h>
   48 #include <sys/syslog.h>
   49 
   50 #include <net/if.h>
   51 #include <net/if_var.h>
   52 #include <net/if_dl.h>
   53 #include <net/if_llatbl.h>
   54 #include <net/if_types.h>
   55 #include <net/route.h>
   56 #include <net/vnet.h>
   57 
   58 #include <netinet/in.h>
   59 #include <netinet/in_var.h>
   60 #include <netinet/in_pcb.h>
   61 #include <netinet/ip_var.h>
   62 #include <netinet/igmp_var.h>
   63 #include <netinet/udp.h>
   64 #include <netinet/udp_var.h>
   65 
   66 static int in_mask2len(struct in_addr *);
   67 static void in_len2mask(struct in_addr *, int);
   68 static int in_lifaddr_ioctl(struct socket *, u_long, caddr_t,
   69         struct ifnet *, struct thread *);
   70 
   71 static int      in_addprefix(struct in_ifaddr *, int);
   72 static int      in_scrubprefix(struct in_ifaddr *);
   73 static void     in_socktrim(struct sockaddr_in *);
   74 static int      in_ifinit(struct ifnet *,
   75             struct in_ifaddr *, struct sockaddr_in *, int);
   76 static void     in_purgemaddrs(struct ifnet *);
   77 
   78 static VNET_DEFINE(int, subnetsarelocal);
   79 static VNET_DEFINE(int, sameprefixcarponly);
   80 VNET_DECLARE(struct inpcbinfo, ripcbinfo);
   81 
   82 #define V_subnetsarelocal               VNET(subnetsarelocal)
   83 #define V_sameprefixcarponly            VNET(sameprefixcarponly)
   84 #define V_ripcbinfo                     VNET(ripcbinfo)
   85 
   86 SYSCTL_VNET_INT(_net_inet_ip, OID_AUTO, subnets_are_local, CTLFLAG_RW,
   87         &VNET_NAME(subnetsarelocal), 0,
   88         "Treat all subnets as directly connected");
   89 SYSCTL_VNET_INT(_net_inet_ip, OID_AUTO, same_prefix_carp_only, CTLFLAG_RW,
   90         &VNET_NAME(sameprefixcarponly), 0,
   91         "Refuse to create same prefixes on different interfaces");
   92 
   93 /*
   94  * Return 1 if an internet address is for a ``local'' host
   95  * (one to which we have a connection).  If subnetsarelocal
   96  * is true, this includes other subnets of the local net.
   97  * Otherwise, it includes only the directly-connected (sub)nets.
   98  */
   99 int
  100 in_localaddr(struct in_addr in)
  101 {
  102         register u_long i = ntohl(in.s_addr);
  103         register struct in_ifaddr *ia;
  104 
  105         IN_IFADDR_RLOCK();
  106         if (V_subnetsarelocal) {
  107                 TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
  108                         if ((i & ia->ia_netmask) == ia->ia_net) {
  109                                 IN_IFADDR_RUNLOCK();
  110                                 return (1);
  111                         }
  112                 }
  113         } else {
  114                 TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
  115                         if ((i & ia->ia_subnetmask) == ia->ia_subnet) {
  116                                 IN_IFADDR_RUNLOCK();
  117                                 return (1);
  118                         }
  119                 }
  120         }
  121         IN_IFADDR_RUNLOCK();
  122         return (0);
  123 }
  124 
  125 /*
  126  * Return 1 if an internet address is for the local host and configured
  127  * on one of its interfaces.
  128  */
  129 int
  130 in_localip(struct in_addr in)
  131 {
  132         struct in_ifaddr *ia;
  133 
  134         IN_IFADDR_RLOCK();
  135         LIST_FOREACH(ia, INADDR_HASH(in.s_addr), ia_hash) {
  136                 if (IA_SIN(ia)->sin_addr.s_addr == in.s_addr) {
  137                         IN_IFADDR_RUNLOCK();
  138                         return (1);
  139                 }
  140         }
  141         IN_IFADDR_RUNLOCK();
  142         return (0);
  143 }
  144 
  145 /*
  146  * Determine whether an IP address is in a reserved set of addresses
  147  * that may not be forwarded, or whether datagrams to that destination
  148  * may be forwarded.
  149  */
  150 int
  151 in_canforward(struct in_addr in)
  152 {
  153         register u_long i = ntohl(in.s_addr);
  154         register u_long net;
  155 
  156         if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i) || IN_LINKLOCAL(i))
  157                 return (0);
  158         if (IN_CLASSA(i)) {
  159                 net = i & IN_CLASSA_NET;
  160                 if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
  161                         return (0);
  162         }
  163         return (1);
  164 }
  165 
  166 /*
  167  * Trim a mask in a sockaddr
  168  */
  169 static void
  170 in_socktrim(struct sockaddr_in *ap)
  171 {
  172     register char *cplim = (char *) &ap->sin_addr;
  173     register char *cp = (char *) (&ap->sin_addr + 1);
  174 
  175     ap->sin_len = 0;
  176     while (--cp >= cplim)
  177         if (*cp) {
  178             (ap)->sin_len = cp - (char *) (ap) + 1;
  179             break;
  180         }
  181 }
  182 
  183 static int
  184 in_mask2len(mask)
  185         struct in_addr *mask;
  186 {
  187         int x, y;
  188         u_char *p;
  189 
  190         p = (u_char *)mask;
  191         for (x = 0; x < sizeof(*mask); x++) {
  192                 if (p[x] != 0xff)
  193                         break;
  194         }
  195         y = 0;
  196         if (x < sizeof(*mask)) {
  197                 for (y = 0; y < 8; y++) {
  198                         if ((p[x] & (0x80 >> y)) == 0)
  199                                 break;
  200                 }
  201         }
  202         return (x * 8 + y);
  203 }
  204 
  205 static void
  206 in_len2mask(struct in_addr *mask, int len)
  207 {
  208         int i;
  209         u_char *p;
  210 
  211         p = (u_char *)mask;
  212         bzero(mask, sizeof(*mask));
  213         for (i = 0; i < len / 8; i++)
  214                 p[i] = 0xff;
  215         if (len % 8)
  216                 p[i] = (0xff00 >> (len % 8)) & 0xff;
  217 }
  218 
  219 /*
  220  * Generic internet control operations (ioctl's).
  221  *
  222  * ifp is NULL if not an interface-specific ioctl.
  223  */
  224 /* ARGSUSED */
  225 int
  226 in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp,
  227     struct thread *td)
  228 {
  229         register struct ifreq *ifr = (struct ifreq *)data;
  230         register struct in_ifaddr *ia, *iap;
  231         register struct ifaddr *ifa;
  232         struct in_addr allhosts_addr;
  233         struct in_addr dst;
  234         struct in_ifinfo *ii;
  235         struct in_aliasreq *ifra = (struct in_aliasreq *)data;
  236         struct sockaddr_in oldaddr;
  237         int error, hostIsNew, iaIsNew, maskIsNew;
  238         int iaIsFirst;
  239 
  240         ia = NULL;
  241         iaIsFirst = 0;
  242         iaIsNew = 0;
  243         allhosts_addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
  244 
  245         /*
  246          * Filter out ioctls we implement directly; forward the rest on to
  247          * in_lifaddr_ioctl() and ifp->if_ioctl().
  248          */
  249         switch (cmd) {
  250         case SIOCAIFADDR:
  251         case SIOCDIFADDR:
  252         case SIOCGIFADDR:
  253         case SIOCGIFBRDADDR:
  254         case SIOCGIFDSTADDR:
  255         case SIOCGIFNETMASK:
  256         case SIOCSIFADDR:
  257         case SIOCSIFBRDADDR:
  258         case SIOCSIFDSTADDR:
  259         case SIOCSIFNETMASK:
  260                 break;
  261 
  262         case SIOCALIFADDR:
  263                 if (td != NULL) {
  264                         error = priv_check(td, PRIV_NET_ADDIFADDR);
  265                         if (error)
  266                                 return (error);
  267                 }
  268                 if (ifp == NULL)
  269                         return (EINVAL);
  270                 return in_lifaddr_ioctl(so, cmd, data, ifp, td);
  271 
  272         case SIOCDLIFADDR:
  273                 if (td != NULL) {
  274                         error = priv_check(td, PRIV_NET_DELIFADDR);
  275                         if (error)
  276                                 return (error);
  277                 }
  278                 if (ifp == NULL)
  279                         return (EINVAL);
  280                 return in_lifaddr_ioctl(so, cmd, data, ifp, td);
  281 
  282         case SIOCGLIFADDR:
  283                 if (ifp == NULL)
  284                         return (EINVAL);
  285                 return in_lifaddr_ioctl(so, cmd, data, ifp, td);
  286 
  287         default:
  288                 if (ifp == NULL || ifp->if_ioctl == NULL)
  289                         return (EOPNOTSUPP);
  290                 return ((*ifp->if_ioctl)(ifp, cmd, data));
  291         }
  292 
  293         if (ifp == NULL)
  294                 return (EADDRNOTAVAIL);
  295 
  296         /*
  297          * Security checks before we get involved in any work.
  298          */
  299         switch (cmd) {
  300         case SIOCAIFADDR:
  301         case SIOCSIFADDR:
  302         case SIOCSIFBRDADDR:
  303         case SIOCSIFNETMASK:
  304         case SIOCSIFDSTADDR:
  305                 if (td != NULL) {
  306                         error = priv_check(td, PRIV_NET_ADDIFADDR);
  307                         if (error)
  308                                 return (error);
  309                 }
  310                 break;
  311 
  312         case SIOCDIFADDR:
  313                 if (td != NULL) {
  314                         error = priv_check(td, PRIV_NET_DELIFADDR);
  315                         if (error)
  316                                 return (error);
  317                 }
  318                 break;
  319         }
  320 
  321         /*
  322          * Find address for this interface, if it exists.
  323          *
  324          * If an alias address was specified, find that one instead of the
  325          * first one on the interface, if possible.
  326          */
  327         dst = ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
  328         IN_IFADDR_RLOCK();
  329         LIST_FOREACH(iap, INADDR_HASH(dst.s_addr), ia_hash) {
  330                 if (iap->ia_ifp == ifp &&
  331                     iap->ia_addr.sin_addr.s_addr == dst.s_addr) {
  332                         if (td == NULL || prison_check_ip4(td->td_ucred,
  333                             &dst) == 0)
  334                                 ia = iap;
  335                         break;
  336                 }
  337         }
  338         if (ia != NULL)
  339                 ifa_ref(&ia->ia_ifa);
  340         IN_IFADDR_RUNLOCK();
  341         if (ia == NULL) {
  342                 IF_ADDR_LOCK(ifp);
  343                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
  344                         iap = ifatoia(ifa);
  345                         if (iap->ia_addr.sin_family == AF_INET) {
  346                                 if (td != NULL &&
  347                                     prison_check_ip4(td->td_ucred,
  348                                     &iap->ia_addr.sin_addr) != 0)
  349                                         continue;
  350                                 ia = iap;
  351                                 break;
  352                         }
  353                 }
  354                 if (ia != NULL)
  355                         ifa_ref(&ia->ia_ifa);
  356                 IF_ADDR_UNLOCK(ifp);
  357         }
  358         if (ia == NULL)
  359                 iaIsFirst = 1;
  360 
  361         error = 0;
  362         switch (cmd) {
  363         case SIOCAIFADDR:
  364         case SIOCDIFADDR:
  365                 if (ifra->ifra_addr.sin_family == AF_INET) {
  366                         struct in_ifaddr *oia;
  367 
  368                         IN_IFADDR_RLOCK();
  369                         for (oia = ia; ia; ia = TAILQ_NEXT(ia, ia_link)) {
  370                                 if (ia->ia_ifp == ifp  &&
  371                                     ia->ia_addr.sin_addr.s_addr ==
  372                                     ifra->ifra_addr.sin_addr.s_addr)
  373                                         break;
  374                         }
  375                         if (ia != NULL && ia != oia)
  376                                 ifa_ref(&ia->ia_ifa);
  377                         if (oia != NULL && ia != oia)
  378                                 ifa_free(&oia->ia_ifa);
  379                         IN_IFADDR_RUNLOCK();
  380                         if ((ifp->if_flags & IFF_POINTOPOINT)
  381                             && (cmd == SIOCAIFADDR)
  382                             && (ifra->ifra_dstaddr.sin_addr.s_addr
  383                                 == INADDR_ANY)) {
  384                                 error = EDESTADDRREQ;
  385                                 goto out;
  386                         }
  387                 }
  388                 if (cmd == SIOCDIFADDR && ia == NULL) {
  389                         error = EADDRNOTAVAIL;
  390                         goto out;
  391                 }
  392                 /* FALLTHROUGH */
  393         case SIOCSIFADDR:
  394         case SIOCSIFNETMASK:
  395         case SIOCSIFDSTADDR:
  396                 if (ia == NULL) {
  397                         ia = (struct in_ifaddr *)
  398                                 malloc(sizeof *ia, M_IFADDR, M_NOWAIT |
  399                                     M_ZERO);
  400                         if (ia == NULL) {
  401                                 error = ENOBUFS;
  402                                 goto out;
  403                         }
  404 
  405                         ifa = &ia->ia_ifa;
  406                         ifa_init(ifa);
  407                         ifa->ifa_addr = (struct sockaddr *)&ia->ia_addr;
  408                         ifa->ifa_dstaddr = (struct sockaddr *)&ia->ia_dstaddr;
  409                         ifa->ifa_netmask = (struct sockaddr *)&ia->ia_sockmask;
  410 
  411                         ia->ia_sockmask.sin_len = 8;
  412                         ia->ia_sockmask.sin_family = AF_INET;
  413                         if (ifp->if_flags & IFF_BROADCAST) {
  414                                 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
  415                                 ia->ia_broadaddr.sin_family = AF_INET;
  416                         }
  417                         ia->ia_ifp = ifp;
  418 
  419                         ifa_ref(ifa);                   /* if_addrhead */
  420                         IF_ADDR_LOCK(ifp);
  421                         TAILQ_INSERT_TAIL(&ifp->if_addrhead, ifa, ifa_link);
  422                         IF_ADDR_UNLOCK(ifp);
  423                         ifa_ref(ifa);                   /* in_ifaddrhead */
  424                         IN_IFADDR_WLOCK();
  425                         TAILQ_INSERT_TAIL(&V_in_ifaddrhead, ia, ia_link);
  426                         IN_IFADDR_WUNLOCK();
  427                         iaIsNew = 1;
  428                 }
  429                 break;
  430 
  431         case SIOCSIFBRDADDR:
  432         case SIOCGIFADDR:
  433         case SIOCGIFNETMASK:
  434         case SIOCGIFDSTADDR:
  435         case SIOCGIFBRDADDR:
  436                 if (ia == NULL) {
  437                         error = EADDRNOTAVAIL;
  438                         goto out;
  439                 }
  440                 break;
  441         }
  442 
  443         /*
  444          * Most paths in this switch return directly or via out.  Only paths
  445          * that remove the address break in order to hit common removal code.
  446          */
  447         switch (cmd) {
  448         case SIOCGIFADDR:
  449                 *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;
  450                 goto out;
  451 
  452         case SIOCGIFBRDADDR:
  453                 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
  454                         error = EINVAL;
  455                         goto out;
  456                 }
  457                 *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;
  458                 goto out;
  459 
  460         case SIOCGIFDSTADDR:
  461                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) {
  462                         error = EINVAL;
  463                         goto out;
  464                 }
  465                 *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;
  466                 goto out;
  467 
  468         case SIOCGIFNETMASK:
  469                 *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;
  470                 goto out;
  471 
  472         case SIOCSIFDSTADDR:
  473                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) {
  474                         error = EINVAL;
  475                         goto out;
  476                 }
  477                 oldaddr = ia->ia_dstaddr;
  478                 ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;
  479                 if (ifp->if_ioctl != NULL) {
  480                         error = (*ifp->if_ioctl)(ifp, SIOCSIFDSTADDR,
  481                             (caddr_t)ia);
  482                         if (error) {
  483                                 ia->ia_dstaddr = oldaddr;
  484                                 goto out;
  485                         }
  486                 }
  487                 if (ia->ia_flags & IFA_ROUTE) {
  488                         ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;
  489                         rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  490                         ia->ia_ifa.ifa_dstaddr =
  491                                         (struct sockaddr *)&ia->ia_dstaddr;
  492                         rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
  493                 }
  494                 goto out;
  495 
  496         case SIOCSIFBRDADDR:
  497                 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
  498                         error = EINVAL;
  499                         goto out;
  500                 }
  501                 ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;
  502                 goto out;
  503 
  504         case SIOCSIFADDR:
  505                 error = in_ifinit(ifp, ia,
  506                     (struct sockaddr_in *) &ifr->ifr_addr, 1);
  507                 if (error != 0 && iaIsNew)
  508                         break;
  509                 if (error == 0) {
  510                         ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]);
  511                         if (iaIsFirst &&
  512                             (ifp->if_flags & IFF_MULTICAST) != 0) {
  513                                 error = in_joingroup(ifp, &allhosts_addr,
  514                                     NULL, &ii->ii_allhosts);
  515                         }
  516                         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  517                 }
  518                 error = 0;
  519                 goto out;
  520 
  521         case SIOCSIFNETMASK:
  522                 ia->ia_sockmask.sin_addr = ifra->ifra_addr.sin_addr;
  523                 ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr);
  524                 goto out;
  525 
  526         case SIOCAIFADDR:
  527                 maskIsNew = 0;
  528                 hostIsNew = 1;
  529                 error = 0;
  530                 if (ia->ia_addr.sin_family == AF_INET) {
  531                         if (ifra->ifra_addr.sin_len == 0) {
  532                                 ifra->ifra_addr = ia->ia_addr;
  533                                 hostIsNew = 0;
  534                         } else if (ifra->ifra_addr.sin_addr.s_addr ==
  535                                                ia->ia_addr.sin_addr.s_addr)
  536                                 hostIsNew = 0;
  537                 }
  538                 if (ifra->ifra_mask.sin_len) {
  539                         /* 
  540                          * QL: XXX
  541                          * Need to scrub the prefix here in case
  542                          * the issued command is SIOCAIFADDR with
  543                          * the same address, but with a different
  544                          * prefix length. And if the prefix length
  545                          * is the same as before, then the call is 
  546                          * un-necessarily executed here.
  547                          */
  548                         in_ifscrub(ifp, ia);
  549                         ia->ia_sockmask = ifra->ifra_mask;
  550                         ia->ia_sockmask.sin_family = AF_INET;
  551                         ia->ia_subnetmask =
  552                              ntohl(ia->ia_sockmask.sin_addr.s_addr);
  553                         maskIsNew = 1;
  554                 }
  555                 if ((ifp->if_flags & IFF_POINTOPOINT) &&
  556                     (ifra->ifra_dstaddr.sin_family == AF_INET)) {
  557                         in_ifscrub(ifp, ia);
  558                         ia->ia_dstaddr = ifra->ifra_dstaddr;
  559                         maskIsNew  = 1; /* We lie; but the effect's the same */
  560                 }
  561                 if (ifra->ifra_addr.sin_family == AF_INET &&
  562                     (hostIsNew || maskIsNew))
  563                         error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
  564                 if (error != 0 && iaIsNew)
  565                         goto out;
  566 
  567                 if ((ifp->if_flags & IFF_BROADCAST) &&
  568                     (ifra->ifra_broadaddr.sin_family == AF_INET))
  569                         ia->ia_broadaddr = ifra->ifra_broadaddr;
  570                 if (error == 0) {
  571                         ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]);
  572                         if (iaIsFirst &&
  573                             (ifp->if_flags & IFF_MULTICAST) != 0) {
  574                                 error = in_joingroup(ifp, &allhosts_addr,
  575                                     NULL, &ii->ii_allhosts);
  576                         }
  577                         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  578                 }
  579                 goto out;
  580 
  581         case SIOCDIFADDR:
  582                 /*
  583                  * in_ifscrub kills the interface route.
  584                  */
  585                 in_ifscrub(ifp, ia);
  586 
  587                 /*
  588                  * in_ifadown gets rid of all the rest of
  589                  * the routes.  This is not quite the right
  590                  * thing to do, but at least if we are running
  591                  * a routing process they will come back.
  592                  */
  593                 in_ifadown(&ia->ia_ifa, 1);
  594                 EVENTHANDLER_INVOKE(ifaddr_event, ifp);
  595                 error = 0;
  596                 break;
  597 
  598         default:
  599                 panic("in_control: unsupported ioctl");
  600         }
  601 
  602         IF_ADDR_LOCK(ifp);
  603         TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
  604         IF_ADDR_UNLOCK(ifp);
  605         ifa_free(&ia->ia_ifa);                          /* if_addrhead */
  606 
  607         IN_IFADDR_WLOCK();
  608         TAILQ_REMOVE(&V_in_ifaddrhead, ia, ia_link);
  609         if (ia->ia_addr.sin_family == AF_INET) {
  610                 struct in_ifaddr *if_ia;
  611 
  612                 LIST_REMOVE(ia, ia_hash);
  613                 IN_IFADDR_WUNLOCK();
  614                 /*
  615                  * If this is the last IPv4 address configured on this
  616                  * interface, leave the all-hosts group.
  617                  * No state-change report need be transmitted.
  618                  */
  619                 if_ia = NULL;
  620                 IFP_TO_IA(ifp, if_ia);
  621                 if (if_ia == NULL) {
  622                         ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]);
  623                         IN_MULTI_LOCK();
  624                         if (ii->ii_allhosts) {
  625                                 (void)in_leavegroup_locked(ii->ii_allhosts,
  626                                     NULL);
  627                                 ii->ii_allhosts = NULL;
  628                         }
  629                         IN_MULTI_UNLOCK();
  630                 } else
  631                         ifa_free(&if_ia->ia_ifa);
  632         } else
  633                 IN_IFADDR_WUNLOCK();
  634         ifa_free(&ia->ia_ifa);                          /* in_ifaddrhead */
  635 out:
  636         if (ia != NULL)
  637                 ifa_free(&ia->ia_ifa);
  638         return (error);
  639 }
  640 
  641 /*
  642  * SIOC[GAD]LIFADDR.
  643  *      SIOCGLIFADDR: get first address. (?!?)
  644  *      SIOCGLIFADDR with IFLR_PREFIX:
  645  *              get first address that matches the specified prefix.
  646  *      SIOCALIFADDR: add the specified address.
  647  *      SIOCALIFADDR with IFLR_PREFIX:
  648  *              EINVAL since we can't deduce hostid part of the address.
  649  *      SIOCDLIFADDR: delete the specified address.
  650  *      SIOCDLIFADDR with IFLR_PREFIX:
  651  *              delete the first address that matches the specified prefix.
  652  * return values:
  653  *      EINVAL on invalid parameters
  654  *      EADDRNOTAVAIL on prefix match failed/specified address not found
  655  *      other values may be returned from in_ioctl()
  656  */
  657 static int
  658 in_lifaddr_ioctl(struct socket *so, u_long cmd, caddr_t data,
  659     struct ifnet *ifp, struct thread *td)
  660 {
  661         struct if_laddrreq *iflr = (struct if_laddrreq *)data;
  662         struct ifaddr *ifa;
  663 
  664         /* sanity checks */
  665         if (data == NULL || ifp == NULL) {
  666                 panic("invalid argument to in_lifaddr_ioctl");
  667                 /*NOTRECHED*/
  668         }
  669 
  670         switch (cmd) {
  671         case SIOCGLIFADDR:
  672                 /* address must be specified on GET with IFLR_PREFIX */
  673                 if ((iflr->flags & IFLR_PREFIX) == 0)
  674                         break;
  675                 /*FALLTHROUGH*/
  676         case SIOCALIFADDR:
  677         case SIOCDLIFADDR:
  678                 /* address must be specified on ADD and DELETE */
  679                 if (iflr->addr.ss_family != AF_INET)
  680                         return (EINVAL);
  681                 if (iflr->addr.ss_len != sizeof(struct sockaddr_in))
  682                         return (EINVAL);
  683                 /* XXX need improvement */
  684                 if (iflr->dstaddr.ss_family
  685                  && iflr->dstaddr.ss_family != AF_INET)
  686                         return (EINVAL);
  687                 if (iflr->dstaddr.ss_family
  688                  && iflr->dstaddr.ss_len != sizeof(struct sockaddr_in))
  689                         return (EINVAL);
  690                 break;
  691         default: /*shouldn't happen*/
  692                 return (EOPNOTSUPP);
  693         }
  694         if (sizeof(struct in_addr) * 8 < iflr->prefixlen)
  695                 return (EINVAL);
  696 
  697         switch (cmd) {
  698         case SIOCALIFADDR:
  699             {
  700                 struct in_aliasreq ifra;
  701 
  702                 if (iflr->flags & IFLR_PREFIX)
  703                         return (EINVAL);
  704 
  705                 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */
  706                 bzero(&ifra, sizeof(ifra));
  707                 bcopy(iflr->iflr_name, ifra.ifra_name,
  708                         sizeof(ifra.ifra_name));
  709 
  710                 bcopy(&iflr->addr, &ifra.ifra_addr, iflr->addr.ss_len);
  711 
  712                 if (iflr->dstaddr.ss_family) {  /*XXX*/
  713                         bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr,
  714                                 iflr->dstaddr.ss_len);
  715                 }
  716 
  717                 ifra.ifra_mask.sin_family = AF_INET;
  718                 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in);
  719                 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen);
  720 
  721                 return (in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, td));
  722             }
  723         case SIOCGLIFADDR:
  724         case SIOCDLIFADDR:
  725             {
  726                 struct in_ifaddr *ia;
  727                 struct in_addr mask, candidate, match;
  728                 struct sockaddr_in *sin;
  729 
  730                 bzero(&mask, sizeof(mask));
  731                 bzero(&match, sizeof(match));
  732                 if (iflr->flags & IFLR_PREFIX) {
  733                         /* lookup a prefix rather than address. */
  734                         in_len2mask(&mask, iflr->prefixlen);
  735 
  736                         sin = (struct sockaddr_in *)&iflr->addr;
  737                         match.s_addr = sin->sin_addr.s_addr;
  738                         match.s_addr &= mask.s_addr;
  739 
  740                         /* if you set extra bits, that's wrong */
  741                         if (match.s_addr != sin->sin_addr.s_addr)
  742                                 return (EINVAL);
  743 
  744                 } else {
  745                         /* on getting an address, take the 1st match */
  746                         /* on deleting an address, do exact match */
  747                         if (cmd != SIOCGLIFADDR) {
  748                                 in_len2mask(&mask, 32);
  749                                 sin = (struct sockaddr_in *)&iflr->addr;
  750                                 match.s_addr = sin->sin_addr.s_addr;
  751                         }
  752                 }
  753 
  754                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
  755                         if (ifa->ifa_addr->sa_family != AF_INET6)
  756                                 continue;
  757                         if (match.s_addr == 0)
  758                                 break;
  759                         candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr;
  760                         candidate.s_addr &= mask.s_addr;
  761                         if (candidate.s_addr == match.s_addr)
  762                                 break;
  763                 }
  764                 if (ifa == NULL)
  765                         return (EADDRNOTAVAIL);
  766                 ia = (struct in_ifaddr *)ifa;
  767 
  768                 if (cmd == SIOCGLIFADDR) {
  769                         /* fill in the if_laddrreq structure */
  770                         bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len);
  771 
  772                         if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
  773                                 bcopy(&ia->ia_dstaddr, &iflr->dstaddr,
  774                                         ia->ia_dstaddr.sin_len);
  775                         } else
  776                                 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr));
  777 
  778                         iflr->prefixlen =
  779                                 in_mask2len(&ia->ia_sockmask.sin_addr);
  780 
  781                         iflr->flags = 0;        /*XXX*/
  782 
  783                         return (0);
  784                 } else {
  785                         struct in_aliasreq ifra;
  786 
  787                         /* fill in_aliasreq and do ioctl(SIOCDIFADDR_IN6) */
  788                         bzero(&ifra, sizeof(ifra));
  789                         bcopy(iflr->iflr_name, ifra.ifra_name,
  790                                 sizeof(ifra.ifra_name));
  791 
  792                         bcopy(&ia->ia_addr, &ifra.ifra_addr,
  793                                 ia->ia_addr.sin_len);
  794                         if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
  795                                 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr,
  796                                         ia->ia_dstaddr.sin_len);
  797                         }
  798                         bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr,
  799                                 ia->ia_sockmask.sin_len);
  800 
  801                         return (in_control(so, SIOCDIFADDR, (caddr_t)&ifra,
  802                             ifp, td));
  803                 }
  804             }
  805         }
  806 
  807         return (EOPNOTSUPP);    /*just for safety*/
  808 }
  809 
  810 /*
  811  * Delete any existing route for an interface.
  812  */
  813 void
  814 in_ifscrub(struct ifnet *ifp, struct in_ifaddr *ia)
  815 {
  816 
  817         in_scrubprefix(ia);
  818 }
  819 
  820 /*
  821  * Initialize an interface's internet address
  822  * and routing table entry.
  823  */
  824 static int
  825 in_ifinit(struct ifnet *ifp, struct in_ifaddr *ia, struct sockaddr_in *sin,
  826     int scrub)
  827 {
  828         register u_long i = ntohl(sin->sin_addr.s_addr);
  829         struct sockaddr_in oldaddr;
  830         int s = splimp(), flags = RTF_UP, error = 0;
  831 
  832         oldaddr = ia->ia_addr;
  833         if (oldaddr.sin_family == AF_INET)
  834                 LIST_REMOVE(ia, ia_hash);
  835         ia->ia_addr = *sin;
  836         if (ia->ia_addr.sin_family == AF_INET) {
  837                 IN_IFADDR_WLOCK();
  838                 LIST_INSERT_HEAD(INADDR_HASH(ia->ia_addr.sin_addr.s_addr),
  839                     ia, ia_hash);
  840                 IN_IFADDR_WUNLOCK();
  841         }
  842         /*
  843          * Give the interface a chance to initialize
  844          * if this is its first address,
  845          * and to validate the address if necessary.
  846          */
  847         if (ifp->if_ioctl != NULL) {
  848                 error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia);
  849                 if (error) {
  850                         splx(s);
  851                         /* LIST_REMOVE(ia, ia_hash) is done in in_control */
  852                         ia->ia_addr = oldaddr;
  853                         IN_IFADDR_WLOCK();
  854                         if (ia->ia_addr.sin_family == AF_INET)
  855                                 LIST_INSERT_HEAD(INADDR_HASH(
  856                                     ia->ia_addr.sin_addr.s_addr), ia, ia_hash);
  857                         else 
  858                                 /* 
  859                                  * If oldaddr family is not AF_INET (e.g. 
  860                                  * interface has been just created) in_control 
  861                                  * does not call LIST_REMOVE, and we end up 
  862                                  * with bogus ia entries in hash
  863                                  */
  864                                 LIST_REMOVE(ia, ia_hash);
  865                         IN_IFADDR_WUNLOCK();
  866                         return (error);
  867                 }
  868         }
  869         splx(s);
  870         if (scrub) {
  871                 ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
  872                 in_ifscrub(ifp, ia);
  873                 ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  874         }
  875         if (IN_CLASSA(i))
  876                 ia->ia_netmask = IN_CLASSA_NET;
  877         else if (IN_CLASSB(i))
  878                 ia->ia_netmask = IN_CLASSB_NET;
  879         else
  880                 ia->ia_netmask = IN_CLASSC_NET;
  881         /*
  882          * The subnet mask usually includes at least the standard network part,
  883          * but may may be smaller in the case of supernetting.
  884          * If it is set, we believe it.
  885          */
  886         if (ia->ia_subnetmask == 0) {
  887                 ia->ia_subnetmask = ia->ia_netmask;
  888                 ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
  889         } else
  890                 ia->ia_netmask &= ia->ia_subnetmask;
  891         ia->ia_net = i & ia->ia_netmask;
  892         ia->ia_subnet = i & ia->ia_subnetmask;
  893         in_socktrim(&ia->ia_sockmask);
  894 #ifdef DEV_CARP
  895         /*
  896          * XXX: carp(4) does not have interface route
  897          */
  898         if (ifp->if_type == IFT_CARP)
  899                 return (0);
  900 #endif
  901         /*
  902          * Add route for the network.
  903          */
  904         ia->ia_ifa.ifa_metric = ifp->if_metric;
  905         if (ifp->if_flags & IFF_BROADCAST) {
  906                 ia->ia_broadaddr.sin_addr.s_addr =
  907                         htonl(ia->ia_subnet | ~ia->ia_subnetmask);
  908                 ia->ia_netbroadcast.s_addr =
  909                         htonl(ia->ia_net | ~ ia->ia_netmask);
  910         } else if (ifp->if_flags & IFF_LOOPBACK) {
  911                 ia->ia_dstaddr = ia->ia_addr;
  912                 flags |= RTF_HOST;
  913         } else if (ifp->if_flags & IFF_POINTOPOINT) {
  914                 if (ia->ia_dstaddr.sin_family != AF_INET)
  915                         return (0);
  916                 flags |= RTF_HOST;
  917         }
  918         if ((error = in_addprefix(ia, flags)) != 0)
  919                 return (error);
  920 
  921         if (ia->ia_addr.sin_addr.s_addr == INADDR_ANY)
  922                 return (0);
  923 
  924         /*
  925          * add a loopback route to self
  926          */
  927         if (V_useloopback && !(ifp->if_flags & IFF_LOOPBACK))
  928                 error = ifa_add_loopback_route((struct ifaddr *)ia, 
  929                                        (struct sockaddr *)&ia->ia_addr);
  930 
  931         return (error);
  932 }
  933 
  934 #define rtinitflags(x) \
  935         ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \
  936             ? RTF_HOST : 0)
  937 /*
  938  * Check if we have a route for the given prefix already or add one accordingly.
  939  */
  940 static int
  941 in_addprefix(struct in_ifaddr *target, int flags)
  942 {
  943         struct in_ifaddr *ia;
  944         struct in_addr prefix, mask, p, m;
  945         int error;
  946 
  947         if ((flags & RTF_HOST) != 0) {
  948                 prefix = target->ia_dstaddr.sin_addr;
  949                 mask.s_addr = 0;
  950         } else {
  951                 prefix = target->ia_addr.sin_addr;
  952                 mask = target->ia_sockmask.sin_addr;
  953                 prefix.s_addr &= mask.s_addr;
  954         }
  955 
  956         IN_IFADDR_RLOCK();
  957         TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
  958                 if (rtinitflags(ia)) {
  959                         p = ia->ia_addr.sin_addr;
  960 
  961                         if (prefix.s_addr != p.s_addr)
  962                                 continue;
  963                 } else {
  964                         p = ia->ia_addr.sin_addr;
  965                         m = ia->ia_sockmask.sin_addr;
  966                         p.s_addr &= m.s_addr;
  967 
  968                         if (prefix.s_addr != p.s_addr ||
  969                             mask.s_addr != m.s_addr)
  970                                 continue;
  971                 }
  972 
  973                 /*
  974                  * If we got a matching prefix route inserted by other
  975                  * interface address, we are done here.
  976                  */
  977                 if (ia->ia_flags & IFA_ROUTE) {
  978                         if (V_sameprefixcarponly &&
  979                             target->ia_ifp->if_type != IFT_CARP &&
  980                             ia->ia_ifp->if_type != IFT_CARP) {
  981                                 IN_IFADDR_RUNLOCK();
  982                                 return (EEXIST);
  983                         } else {
  984                                 struct route pfx_ro;
  985                                 struct sockaddr_in *pfx_addr;
  986                                 struct rtentry msg_rt;
  987 
  988                                 /* QL: XXX
  989                                  * This is a bit questionable because there is no
  990                                  * additional route entry added for an address alias.
  991                                  * Therefore this route report is inaccurate. Perhaps
  992                                  * it's better to supply a empty rtentry as how it
  993                                  * is done in in_scrubprefix().
  994                                  */
  995                                 bzero(&pfx_ro, sizeof(pfx_ro));
  996                                 pfx_addr = (struct sockaddr_in *)(&pfx_ro.ro_dst);
  997                                 pfx_addr->sin_len = sizeof(*pfx_addr);
  998                                 pfx_addr->sin_family = AF_INET;
  999                                 pfx_addr->sin_addr = prefix;
 1000                                 rtalloc_ign_fib(&pfx_ro, 0, 0);
 1001                                 if (pfx_ro.ro_rt != NULL) {
 1002                                         msg_rt = *pfx_ro.ro_rt;
 1003                                         /* QL: XXX
 1004                                          * Point the gateway to the given interface
 1005                                          * address as if a new prefix route entry has 
 1006                                          * been added through the new address alias. 
 1007                                          * All other parts of the rtentry is accurate, 
 1008                                          * e.g., rt_key, rt_mask, rt_ifp etc.
 1009                                          */
 1010                                         msg_rt.rt_gateway = 
 1011                                                 (struct sockaddr *)&ia->ia_addr;
 1012                                         rt_newaddrmsg(RTM_ADD, 
 1013                                                       (struct ifaddr *)target,
 1014                                                       0, &msg_rt);
 1015                                         RTFREE(pfx_ro.ro_rt);
 1016                                 }
 1017 
 1018                                 IN_IFADDR_RUNLOCK();
 1019                                 return (0);
 1020                         }
 1021                 }
 1022         }
 1023         IN_IFADDR_RUNLOCK();
 1024 
 1025         /*
 1026          * No-one seem to have this prefix route, so we try to insert it.
 1027          */
 1028         error = rtinit(&target->ia_ifa, (int)RTM_ADD, flags);
 1029         if (!error)
 1030                 target->ia_flags |= IFA_ROUTE;
 1031         return (error);
 1032 }
 1033 
 1034 extern void arp_ifscrub(struct ifnet *ifp, uint32_t addr);
 1035 
 1036 /*
 1037  * If there is no other address in the system that can serve a route to the
 1038  * same prefix, remove the route.  Hand over the route to the new address
 1039  * otherwise.
 1040  */
 1041 static int
 1042 in_scrubprefix(struct in_ifaddr *target)
 1043 {
 1044         struct in_ifaddr *ia;
 1045         struct in_addr prefix, mask, p;
 1046         int error;
 1047         struct sockaddr_in prefix0, mask0;
 1048 
 1049         /*
 1050          * Remove the loopback route to the interface address.
 1051          * The "useloopback" setting is not consulted because if the
 1052          * user configures an interface address, turns off this
 1053          * setting, and then tries to delete that interface address,
 1054          * checking the current setting of "useloopback" would leave
 1055          * that interface address loopback route untouched, which
 1056          * would be wrong. Therefore the interface address loopback route
 1057          * deletion is unconditional.
 1058          */
 1059         if ((target->ia_addr.sin_addr.s_addr != INADDR_ANY) &&
 1060             !(target->ia_ifp->if_flags & IFF_LOOPBACK)) {
 1061                 error = ifa_del_loopback_route((struct ifaddr *)target,
 1062                                        (struct sockaddr *)&target->ia_addr);
 1063                 /* remove arp cache */
 1064                 arp_ifscrub(target->ia_ifp, IA_SIN(target)->sin_addr.s_addr);
 1065         }
 1066 
 1067         if ((target->ia_flags & IFA_ROUTE) == 0) {
 1068                 struct rtentry rt;
 1069 
 1070                 /* QL: XXX
 1071                  * Report a blank rtentry when a route has not been
 1072                  * installed for the given interface address.
 1073                  */
 1074                 bzero(&rt, sizeof(rt));
 1075                 rt_newaddrmsg(RTM_DELETE, 
 1076                               (struct ifaddr *)target,
 1077                               0, &rt);
 1078                 return (0);
 1079         }
 1080 
 1081         if (rtinitflags(target))
 1082                 prefix = target->ia_dstaddr.sin_addr;
 1083         else {
 1084                 prefix = target->ia_addr.sin_addr;
 1085                 mask = target->ia_sockmask.sin_addr;
 1086                 prefix.s_addr &= mask.s_addr;
 1087         }
 1088 
 1089         IN_IFADDR_RLOCK();
 1090         TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
 1091                 if (rtinitflags(ia))
 1092                         p = ia->ia_dstaddr.sin_addr;
 1093                 else {
 1094                         p = ia->ia_addr.sin_addr;
 1095                         p.s_addr &= ia->ia_sockmask.sin_addr.s_addr;
 1096                 }
 1097 
 1098                 if (prefix.s_addr != p.s_addr)
 1099                         continue;
 1100 
 1101                 /*
 1102                  * If we got a matching prefix address, move IFA_ROUTE and
 1103                  * the route itself to it.  Make sure that routing daemons
 1104                  * get a heads-up.
 1105                  *
 1106                  * XXX: a special case for carp(4) interface
 1107                  */
 1108                 if ((ia->ia_flags & IFA_ROUTE) == 0
 1109 #ifdef DEV_CARP
 1110                     && (ia->ia_ifp->if_type != IFT_CARP)
 1111 #endif
 1112                                                         ) {
 1113                         IN_IFADDR_RUNLOCK();
 1114                         rtinit(&(target->ia_ifa), (int)RTM_DELETE,
 1115                             rtinitflags(target));
 1116                         target->ia_flags &= ~IFA_ROUTE;
 1117 
 1118                         error = rtinit(&ia->ia_ifa, (int)RTM_ADD,
 1119                             rtinitflags(ia) | RTF_UP);
 1120                         if (error == 0)
 1121                                 ia->ia_flags |= IFA_ROUTE;
 1122                         return (error);
 1123                 }
 1124         }
 1125         IN_IFADDR_RUNLOCK();
 1126 
 1127         /*
 1128          * remove all L2 entries on the given prefix
 1129          */
 1130         bzero(&prefix0, sizeof(prefix0));
 1131         prefix0.sin_len = sizeof(prefix0);
 1132         prefix0.sin_family = AF_INET;
 1133         prefix0.sin_addr.s_addr = target->ia_subnet;
 1134         bzero(&mask0, sizeof(mask0));
 1135         mask0.sin_len = sizeof(mask0);
 1136         mask0.sin_family = AF_INET;
 1137         mask0.sin_addr.s_addr = target->ia_subnetmask;
 1138         lltable_prefix_free(AF_INET, (struct sockaddr *)&prefix0, 
 1139                             (struct sockaddr *)&mask0);
 1140 
 1141         /*
 1142          * As no-one seem to have this prefix, we can remove the route.
 1143          */
 1144         rtinit(&(target->ia_ifa), (int)RTM_DELETE, rtinitflags(target));
 1145         target->ia_flags &= ~IFA_ROUTE;
 1146         return (0);
 1147 }
 1148 
 1149 #undef rtinitflags
 1150 
 1151 /*
 1152  * Return 1 if the address might be a local broadcast address.
 1153  */
 1154 int
 1155 in_broadcast(struct in_addr in, struct ifnet *ifp)
 1156 {
 1157         register struct ifaddr *ifa;
 1158         u_long t;
 1159 
 1160         if (in.s_addr == INADDR_BROADCAST ||
 1161             in.s_addr == INADDR_ANY)
 1162                 return (1);
 1163         if ((ifp->if_flags & IFF_BROADCAST) == 0)
 1164                 return (0);
 1165         t = ntohl(in.s_addr);
 1166         /*
 1167          * Look through the list of addresses for a match
 1168          * with a broadcast address.
 1169          */
 1170 #define ia ((struct in_ifaddr *)ifa)
 1171         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
 1172                 if (ifa->ifa_addr->sa_family == AF_INET &&
 1173                     (in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
 1174                      in.s_addr == ia->ia_netbroadcast.s_addr ||
 1175                      /*
 1176                       * Check for old-style (host 0) broadcast.
 1177                       */
 1178                      t == ia->ia_subnet || t == ia->ia_net) &&
 1179                      /*
 1180                       * Check for an all one subnetmask. These
 1181                       * only exist when an interface gets a secondary
 1182                       * address.
 1183                       */
 1184                      ia->ia_subnetmask != (u_long)0xffffffff)
 1185                             return (1);
 1186         return (0);
 1187 #undef ia
 1188 }
 1189 
 1190 /*
 1191  * On interface removal, clean up IPv4 data structures hung off of the ifnet.
 1192  */
 1193 void
 1194 in_ifdetach(struct ifnet *ifp)
 1195 {
 1196 
 1197         in_pcbpurgeif0(&V_ripcbinfo, ifp);
 1198         in_pcbpurgeif0(&V_udbinfo, ifp);
 1199         in_purgemaddrs(ifp);
 1200 }
 1201 
 1202 /*
 1203  * Delete all IPv4 multicast address records, and associated link-layer
 1204  * multicast address records, associated with ifp.
 1205  * XXX It looks like domifdetach runs AFTER the link layer cleanup.
 1206  * XXX This should not race with ifma_protospec being set during
 1207  * a new allocation, if it does, we have bigger problems.
 1208  */
 1209 static void
 1210 in_purgemaddrs(struct ifnet *ifp)
 1211 {
 1212         LIST_HEAD(,in_multi) purgeinms;
 1213         struct in_multi         *inm, *tinm;
 1214         struct ifmultiaddr      *ifma;
 1215 
 1216         LIST_INIT(&purgeinms);
 1217         IN_MULTI_LOCK();
 1218 
 1219         /*
 1220          * Extract list of in_multi associated with the detaching ifp
 1221          * which the PF_INET layer is about to release.
 1222          * We need to do this as IF_ADDR_LOCK() may be re-acquired
 1223          * by code further down.
 1224          */
 1225         IF_ADDR_LOCK(ifp);
 1226         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 1227                 if (ifma->ifma_addr->sa_family != AF_INET ||
 1228                     ifma->ifma_protospec == NULL)
 1229                         continue;
 1230 #if 0
 1231                 KASSERT(ifma->ifma_protospec != NULL,
 1232                     ("%s: ifma_protospec is NULL", __func__));
 1233 #endif
 1234                 inm = (struct in_multi *)ifma->ifma_protospec;
 1235                 LIST_INSERT_HEAD(&purgeinms, inm, inm_link);
 1236         }
 1237         IF_ADDR_UNLOCK(ifp);
 1238 
 1239         LIST_FOREACH_SAFE(inm, &purgeinms, inm_link, tinm) {
 1240                 LIST_REMOVE(inm, inm_link);
 1241                 inm_release_locked(inm);
 1242         }
 1243         igmp_ifdetach(ifp);
 1244 
 1245         IN_MULTI_UNLOCK();
 1246 }
 1247 
 1248 #include <net/if_dl.h>
 1249 #include <netinet/if_ether.h>
 1250 
 1251 struct in_llentry {
 1252         struct llentry          base;
 1253         struct sockaddr_in      l3_addr4;
 1254 };
 1255 
 1256 static struct llentry *
 1257 in_lltable_new(const struct sockaddr *l3addr, u_int flags)
 1258 {
 1259         struct in_llentry *lle;
 1260 
 1261         lle = malloc(sizeof(struct in_llentry), M_LLTABLE, M_DONTWAIT | M_ZERO);
 1262         if (lle == NULL)                /* NB: caller generates msg */
 1263                 return NULL;
 1264 
 1265         callout_init(&lle->base.la_timer, CALLOUT_MPSAFE);
 1266         /*
 1267          * For IPv4 this will trigger "arpresolve" to generate
 1268          * an ARP request.
 1269          */
 1270         lle->base.la_expire = time_second; /* mark expired */
 1271         lle->l3_addr4 = *(const struct sockaddr_in *)l3addr;
 1272         lle->base.lle_refcnt = 1;
 1273         LLE_LOCK_INIT(&lle->base);
 1274         return &lle->base;
 1275 }
 1276 
 1277 /*
 1278  * Deletes an address from the address table.
 1279  * This function is called by the timer functions
 1280  * such as arptimer() and nd6_llinfo_timer(), and
 1281  * the caller does the locking.
 1282  */
 1283 static void
 1284 in_lltable_free(struct lltable *llt, struct llentry *lle)
 1285 {
 1286         LLE_WUNLOCK(lle);
 1287         LLE_LOCK_DESTROY(lle);
 1288         free(lle, M_LLTABLE);
 1289 }
 1290 
 1291 
 1292 #define IN_ARE_MASKED_ADDR_EQUAL(d, a, m)       (                       \
 1293             (((ntohl((d)->sin_addr.s_addr) ^ (a)->sin_addr.s_addr) & (m)->sin_addr.s_addr)) == 0 )
 1294 
 1295 static void
 1296 in_lltable_prefix_free(struct lltable *llt, 
 1297                        const struct sockaddr *prefix,
 1298                        const struct sockaddr *mask)
 1299 {
 1300         const struct sockaddr_in *pfx = (const struct sockaddr_in *)prefix;
 1301         const struct sockaddr_in *msk = (const struct sockaddr_in *)mask;
 1302         struct llentry *lle, *next;
 1303         register int i;
 1304 
 1305         for (i=0; i < LLTBL_HASHTBL_SIZE; i++) {
 1306                 LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) {
 1307 
 1308                         if (IN_ARE_MASKED_ADDR_EQUAL((struct sockaddr_in *)L3_ADDR(lle), 
 1309                                                      pfx, msk)) {
 1310                                 callout_drain(&lle->la_timer);
 1311                                 LLE_WLOCK(lle);
 1312                                 llentry_free(lle);
 1313                         }
 1314                 }
 1315         }
 1316 }
 1317 
 1318 
 1319 static int
 1320 in_lltable_rtcheck(struct ifnet *ifp, const struct sockaddr *l3addr)
 1321 {
 1322         struct rtentry *rt;
 1323 
 1324         KASSERT(l3addr->sa_family == AF_INET,
 1325             ("sin_family %d", l3addr->sa_family));
 1326 
 1327         /* XXX rtalloc1 should take a const param */
 1328         rt = rtalloc1(__DECONST(struct sockaddr *, l3addr), 0, 0);
 1329         if (rt == NULL || (rt->rt_flags & RTF_GATEWAY) || rt->rt_ifp != ifp) {
 1330 #ifdef DIAGNOSTICS
 1331                 log(LOG_INFO, "IPv4 address: \"%s\" is not on the network\n",
 1332                     inet_ntoa(((const struct sockaddr_in *)l3addr)->sin_addr));
 1333 #endif
 1334                 if (rt != NULL)
 1335                         RTFREE_LOCKED(rt);
 1336                 return (EINVAL);
 1337         }
 1338         RTFREE_LOCKED(rt);
 1339         return 0;
 1340 }
 1341 
 1342 /*
 1343  * Return NULL if not found or marked for deletion.
 1344  * If found return lle read locked.
 1345  */
 1346 static struct llentry *
 1347 in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr)
 1348 {
 1349         const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr;
 1350         struct ifnet *ifp = llt->llt_ifp;
 1351         struct llentry *lle;
 1352         struct llentries *lleh;
 1353         u_int hashkey;
 1354 
 1355         IF_AFDATA_LOCK_ASSERT(ifp);
 1356         KASSERT(l3addr->sa_family == AF_INET,
 1357             ("sin_family %d", l3addr->sa_family));
 1358 
 1359         hashkey = sin->sin_addr.s_addr;
 1360         lleh = &llt->lle_head[LLATBL_HASH(hashkey, LLTBL_HASHMASK)];
 1361         LIST_FOREACH(lle, lleh, lle_next) {
 1362                 struct sockaddr_in *sa2 = (struct sockaddr_in *)L3_ADDR(lle);
 1363                 if (lle->la_flags & LLE_DELETED)
 1364                         continue;
 1365                 if (sa2->sin_addr.s_addr == sin->sin_addr.s_addr)
 1366                         break;
 1367         }
 1368         if (lle == NULL) {
 1369 #ifdef DIAGNOSTICS
 1370                 if (flags & LLE_DELETE)
 1371                         log(LOG_INFO, "interface address is missing from cache = %p  in delete\n", lle);        
 1372 #endif
 1373                 if (!(flags & LLE_CREATE))
 1374                         return (NULL);
 1375                 /*
 1376                  * A route that covers the given address must have
 1377                  * been installed 1st because we are doing a resolution,
 1378                  * verify this.
 1379                  */
 1380                 if (!(flags & LLE_IFADDR) &&
 1381                     in_lltable_rtcheck(ifp, l3addr) != 0)
 1382                         goto done;
 1383 
 1384                 lle = in_lltable_new(l3addr, flags);
 1385                 if (lle == NULL) {
 1386                         log(LOG_INFO, "lla_lookup: new lle malloc failed\n");
 1387                         goto done;
 1388                 }
 1389                 lle->la_flags = flags & ~LLE_CREATE;
 1390                 if ((flags & (LLE_CREATE | LLE_IFADDR)) == (LLE_CREATE | LLE_IFADDR)) {
 1391                         bcopy(IF_LLADDR(ifp), &lle->ll_addr, ifp->if_addrlen);
 1392                         lle->la_flags |= (LLE_VALID | LLE_STATIC);
 1393                 }
 1394 
 1395                 lle->lle_tbl  = llt;
 1396                 lle->lle_head = lleh;
 1397                 LIST_INSERT_HEAD(lleh, lle, lle_next);
 1398         } else if (flags & LLE_DELETE) {
 1399                 if (!(lle->la_flags & LLE_IFADDR) || (flags & LLE_IFADDR)) {
 1400                         LLE_WLOCK(lle);
 1401                         lle->la_flags = LLE_DELETED;
 1402                         LLE_WUNLOCK(lle);
 1403 #ifdef DIAGNOSTICS
 1404                         log(LOG_INFO, "ifaddr cache = %p  is deleted\n", lle);  
 1405 #endif
 1406                 }
 1407                 lle = (void *)-1;
 1408                 
 1409         }
 1410         if (LLE_IS_VALID(lle)) {
 1411                 if (flags & LLE_EXCLUSIVE)
 1412                         LLE_WLOCK(lle);
 1413                 else
 1414                         LLE_RLOCK(lle);
 1415         }
 1416 done:
 1417         return (lle);
 1418 }
 1419 
 1420 static int
 1421 in_lltable_dump(struct lltable *llt, struct sysctl_req *wr)
 1422 {
 1423 #define SIN(lle)        ((struct sockaddr_in *) L3_ADDR(lle))
 1424         struct ifnet *ifp = llt->llt_ifp;
 1425         struct llentry *lle;
 1426         /* XXX stack use */
 1427         struct {
 1428                 struct rt_msghdr        rtm;
 1429                 struct sockaddr_inarp   sin;
 1430                 struct sockaddr_dl      sdl;
 1431         } arpc;
 1432         int error, i;
 1433 
 1434         LLTABLE_LOCK_ASSERT();
 1435 
 1436         error = 0;
 1437         for (i = 0; i < LLTBL_HASHTBL_SIZE; i++) {
 1438                 LIST_FOREACH(lle, &llt->lle_head[i], lle_next) {
 1439                         struct sockaddr_dl *sdl;
 1440                         
 1441                         /* skip deleted entries */
 1442                         if ((lle->la_flags & LLE_DELETED) == LLE_DELETED)
 1443                                 continue;
 1444                         /* Skip if jailed and not a valid IP of the prison. */
 1445                         if (prison_if(wr->td->td_ucred, L3_ADDR(lle)) != 0)
 1446                                 continue;
 1447                         /*
 1448                          * produce a msg made of:
 1449                          *  struct rt_msghdr;
 1450                          *  struct sockaddr_inarp; (IPv4)
 1451                          *  struct sockaddr_dl;
 1452                          */
 1453                         bzero(&arpc, sizeof(arpc));
 1454                         arpc.rtm.rtm_msglen = sizeof(arpc);
 1455                         arpc.rtm.rtm_version = RTM_VERSION;
 1456                         arpc.rtm.rtm_type = RTM_GET;
 1457                         arpc.rtm.rtm_flags = RTF_UP;
 1458                         arpc.rtm.rtm_addrs = RTA_DST | RTA_GATEWAY;
 1459                         arpc.sin.sin_family = AF_INET;
 1460                         arpc.sin.sin_len = sizeof(arpc.sin);
 1461                         arpc.sin.sin_addr.s_addr = SIN(lle)->sin_addr.s_addr;
 1462 
 1463                         /* publish */
 1464                         if (lle->la_flags & LLE_PUB) {
 1465                                 arpc.rtm.rtm_flags |= RTF_ANNOUNCE;
 1466                                 /* proxy only */
 1467                                 if (lle->la_flags & LLE_PROXY)
 1468                                         arpc.sin.sin_other = SIN_PROXY;
 1469                         }
 1470 
 1471                         sdl = &arpc.sdl;
 1472                         sdl->sdl_family = AF_LINK;
 1473                         sdl->sdl_len = sizeof(*sdl);
 1474                         sdl->sdl_index = ifp->if_index;
 1475                         sdl->sdl_type = ifp->if_type;
 1476                         if ((lle->la_flags & LLE_VALID) == LLE_VALID) {
 1477                                 sdl->sdl_alen = ifp->if_addrlen;
 1478                                 bcopy(&lle->ll_addr, LLADDR(sdl), ifp->if_addrlen);
 1479                         } else {
 1480                                 sdl->sdl_alen = 0;
 1481                                 bzero(LLADDR(sdl), ifp->if_addrlen);
 1482                         }
 1483 
 1484                         arpc.rtm.rtm_rmx.rmx_expire =
 1485                             lle->la_flags & LLE_STATIC ? 0 : lle->la_expire;
 1486                         arpc.rtm.rtm_flags |= (RTF_HOST | RTF_LLDATA);
 1487                         if (lle->la_flags & LLE_STATIC)
 1488                                 arpc.rtm.rtm_flags |= RTF_STATIC;
 1489                         arpc.rtm.rtm_index = ifp->if_index;
 1490                         error = SYSCTL_OUT(wr, &arpc, sizeof(arpc));
 1491                         if (error)
 1492                                 break;
 1493                 }
 1494         }
 1495         return error;
 1496 #undef SIN
 1497 }
 1498 
 1499 void *
 1500 in_domifattach(struct ifnet *ifp)
 1501 {
 1502         struct in_ifinfo *ii;
 1503         struct lltable *llt;
 1504 
 1505         ii = malloc(sizeof(struct in_ifinfo), M_IFADDR, M_WAITOK|M_ZERO);
 1506 
 1507         llt = lltable_init(ifp, AF_INET);
 1508         if (llt != NULL) {
 1509                 llt->llt_new = in_lltable_new;
 1510                 llt->llt_free = in_lltable_free;
 1511                 llt->llt_prefix_free = in_lltable_prefix_free;
 1512                 llt->llt_rtcheck = in_lltable_rtcheck;
 1513                 llt->llt_lookup = in_lltable_lookup;
 1514                 llt->llt_dump = in_lltable_dump;
 1515         }
 1516         ii->ii_llt = llt;
 1517 
 1518         ii->ii_igmp = igmp_domifattach(ifp);
 1519 
 1520         return ii;
 1521 }
 1522 
 1523 void
 1524 in_domifdetach(struct ifnet *ifp, void *aux)
 1525 {
 1526         struct in_ifinfo *ii = (struct in_ifinfo *)aux;
 1527 
 1528         igmp_domifdetach(ifp);
 1529         lltable_free(ii->ii_llt);
 1530         free(ii, M_IFADDR);
 1531 }

Cache object: 4972b8c2ed7c95c38d58b92c53057700


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