sys/netinet/in.c

   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$");
  35
  36 #include "opt_mpath.h"
  37
  38 #include <sys/param.h>
  39 #include <sys/eventhandler.h>
  40 #include <sys/systm.h>
  41 #include <sys/sockio.h>
  42 #include <sys/malloc.h>
  43 #include <sys/priv.h>
  44 #include <sys/socket.h>
  45 #include <sys/jail.h>
  46 #include <sys/kernel.h>
  47 #include <sys/proc.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/syslog.h>
  50 #include <sys/sx.h>
  51
  52 #include <net/if.h>
  53 #include <net/if_var.h>
  54 #include <net/if_arp.h>
  55 #include <net/if_dl.h>
  56 #include <net/if_llatbl.h>
  57 #include <net/if_types.h>
  58 #include <net/route.h>
  59 #include <net/vnet.h>
  60
  61 #include <netinet/if_ether.h>
  62 #include <netinet/in.h>
  63 #include <netinet/in_var.h>
  64 #include <netinet/in_pcb.h>
  65 #include <netinet/ip_var.h>
  66 #include <netinet/ip_carp.h>
  67 #include <netinet/igmp_var.h>
  68 #include <netinet/udp.h>
  69 #include <netinet/udp_var.h>
  70
  71 static int in_aifaddr_ioctl(u_long, caddr_t, struct ifnet *, struct thread *);
  72 static int in_difaddr_ioctl(caddr_t, struct ifnet *, struct thread *);
  73
  74 static void     in_socktrim(struct sockaddr_in *);
  75 static void     in_purgemaddrs(struct ifnet *);
  76
  77 static VNET_DEFINE(int, nosameprefix);
  78 #define V_nosameprefix                  VNET(nosameprefix)
  79 SYSCTL_VNET_INT(_net_inet_ip, OID_AUTO, no_same_prefix, CTLFLAG_RW,
  80         &VNET_NAME(nosameprefix), 0,
  81         "Refuse to create same prefixes on different interfaces");
  82
  83 VNET_DECLARE(struct inpcbinfo, ripcbinfo);
  84 #define V_ripcbinfo                     VNET(ripcbinfo)
  85
  86 static struct sx in_control_sx;
  87 SX_SYSINIT(in_control_sx, &in_control_sx, "in_control");
  88
  89 /*
  90  * Return 1 if an internet address is for a ``local'' host
  91  * (one to which we have a connection).
  92  */
  93 int
  94 in_localaddr(struct in_addr in)
  95 {
  96         register u_long i = ntohl(in.s_addr);
  97         register struct in_ifaddr *ia;
  98
  99         IN_IFADDR_RLOCK();
 100         TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
 101                 if ((i & ia->ia_subnetmask) == ia->ia_subnet) {
 102                         IN_IFADDR_RUNLOCK();
 103                         return (1);
 104                 }
 105         }
 106         IN_IFADDR_RUNLOCK();
 107         return (0);
 108 }
 109
 110 /*
 111  * Return 1 if an internet address is for the local host and configured
 112  * on one of its interfaces.
 113  */
 114 int
 115 in_localip(struct in_addr in)
 116 {
 117         struct in_ifaddr *ia;
 118
 119         IN_IFADDR_RLOCK();
 120         LIST_FOREACH(ia, INADDR_HASH(in.s_addr), ia_hash) {
 121                 if (IA_SIN(ia)->sin_addr.s_addr == in.s_addr) {
 122                         IN_IFADDR_RUNLOCK();
 123                         return (1);
 124                 }
 125         }
 126         IN_IFADDR_RUNLOCK();
 127         return (0);
 128 }
 129
 130 /*
 131  * Return a reference to the interface address which is different to
 132  * the supplied one but with same IP address value.
 133  */
 134 static struct in_ifaddr *
 135 in_localip_more(struct in_ifaddr *ia)
 136 {
 137         in_addr_t in = IA_SIN(ia)->sin_addr.s_addr;
 138         struct in_ifaddr *it;
 139
 140         IN_IFADDR_RLOCK();
 141         LIST_FOREACH(it, INADDR_HASH(in), ia_hash) {
 142                 if (it != ia && IA_SIN(it)->sin_addr.s_addr == in) {
 143                         ifa_ref(&it->ia_ifa);
 144                         IN_IFADDR_RUNLOCK();
 145                         return (it);
 146                 }
 147         }
 148         IN_IFADDR_RUNLOCK();
 149
 150         return (NULL);
 151 }
 152
 153 /*
 154  * Determine whether an IP address is in a reserved set of addresses
 155  * that may not be forwarded, or whether datagrams to that destination
 156  * may be forwarded.
 157  */
 158 int
 159 in_canforward(struct in_addr in)
 160 {
 161         register u_long i = ntohl(in.s_addr);
 162         register u_long net;
 163
 164         if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i) || IN_LINKLOCAL(i))
 165                 return (0);
 166         if (IN_CLASSA(i)) {
 167                 net = i & IN_CLASSA_NET;
 168                 if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
 169                         return (0);
 170         }
 171         return (1);
 172 }
 173
 174 /*
 175  * Trim a mask in a sockaddr
 176  */
 177 static void
 178 in_socktrim(struct sockaddr_in *ap)
 179 {
 180     register char *cplim = (char *) &ap->sin_addr;
 181     register char *cp = (char *) (&ap->sin_addr + 1);
 182
 183     ap->sin_len = 0;
 184     while (--cp >= cplim)
 185         if (*cp) {
 186             (ap)->sin_len = cp - (char *) (ap) + 1;
 187             break;
 188         }
 189 }
 190
 191 /*
 192  * Generic internet control operations (ioctl's).
 193  */
 194 int
 195 in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp,
 196     struct thread *td)
 197 {
 198         struct ifreq *ifr = (struct ifreq *)data;
 199         struct sockaddr_in *addr = (struct sockaddr_in *)&ifr->ifr_addr;
 200         struct ifaddr *ifa;
 201         struct in_ifaddr *ia;
 202         int error;
 203
 204         if (ifp == NULL)
 205                 return (EADDRNOTAVAIL);
 206
 207         /*
 208          * Filter out 4 ioctls we implement directly.  Forward the rest
 209          * to specific functions and ifp->if_ioctl().
 210          */
 211         switch (cmd) {
 212         case SIOCGIFADDR:
 213         case SIOCGIFBRDADDR:
 214         case SIOCGIFDSTADDR:
 215         case SIOCGIFNETMASK:
 216                 break;
 217         case SIOCDIFADDR:
 218                 sx_xlock(&in_control_sx);
 219                 error = in_difaddr_ioctl(data, ifp, td);
 220                 sx_xunlock(&in_control_sx);
 221                 return (error);
 222         case OSIOCAIFADDR:      /* 9.x compat */
 223         case SIOCAIFADDR:
 224                 sx_xlock(&in_control_sx);
 225                 error = in_aifaddr_ioctl(cmd, data, ifp, td);
 226                 sx_xunlock(&in_control_sx);
 227                 return (error);
 228         case SIOCSIFADDR:
 229         case SIOCSIFBRDADDR:
 230         case SIOCSIFDSTADDR:
 231         case SIOCSIFNETMASK:
 232                 /* We no longer support that old commands. */
 233                 return (EINVAL);
 234         default:
 235                 if (ifp->if_ioctl == NULL)
 236                         return (EOPNOTSUPP);
 237                 return ((*ifp->if_ioctl)(ifp, cmd, data));
 238         }
 239
 240         if (addr->sin_addr.s_addr != INADDR_ANY &&
 241             prison_check_ip4(td->td_ucred, &addr->sin_addr) != 0)
 242                 return (EADDRNOTAVAIL);
 243
 244         /*
 245          * For SIOCGIFADDR, pick the first address.  For the rest of
 246          * ioctls, try to find specified address.
 247          */
 248         IF_ADDR_RLOCK(ifp);
 249         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 250                 if (ifa->ifa_addr->sa_family != AF_INET)
 251                         continue;
 252                 ia = (struct in_ifaddr *)ifa;
 253                 if (cmd == SIOCGIFADDR || addr->sin_addr.s_addr == INADDR_ANY)
 254                         break;
 255                 if (ia->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr)
 256                         break;
 257         }
 258
 259         if (ifa == NULL) {
 260                 IF_ADDR_RUNLOCK(ifp);
 261                 return (EADDRNOTAVAIL);
 262         }
 263
 264         error = 0;
 265         switch (cmd) {
 266         case SIOCGIFADDR:
 267                 *addr = ia->ia_addr;
 268                 break;
 269
 270         case SIOCGIFBRDADDR:
 271                 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
 272                         error = EINVAL;
 273                         break;
 274                 }
 275                 *addr = ia->ia_broadaddr;
 276                 break;
 277
 278         case SIOCGIFDSTADDR:
 279                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) {
 280                         error = EINVAL;
 281                         break;
 282                 }
 283                 *addr = ia->ia_dstaddr;
 284                 break;
 285
 286         case SIOCGIFNETMASK:
 287                 *addr = ia->ia_sockmask;
 288                 break;
 289         }
 290
 291         IF_ADDR_RUNLOCK(ifp);
 292
 293         return (error);
 294 }
 295
 296 static int
 297 in_aifaddr_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp, struct thread *td)
 298 {
 299         const struct in_aliasreq *ifra = (struct in_aliasreq *)data;
 300         const struct sockaddr_in *addr = &ifra->ifra_addr;
 301         const struct sockaddr_in *broadaddr = &ifra->ifra_broadaddr;
 302         const struct sockaddr_in *mask = &ifra->ifra_mask;
 303         const struct sockaddr_in *dstaddr = &ifra->ifra_dstaddr;
 304         const int vhid = (cmd == SIOCAIFADDR) ? ifra->ifra_vhid : 0;
 305         struct ifaddr *ifa;
 306         struct in_ifaddr *ia;
 307         bool iaIsFirst;
 308         int error = 0;
 309
 310         error = priv_check(td, PRIV_NET_ADDIFADDR);
 311         if (error)
 312                 return (error);
 313
 314         /*
 315          * ifra_addr must be present and be of INET family.
 316          * ifra_broadaddr/ifra_dstaddr and ifra_mask are optional.
 317          */
 318         if (addr->sin_len != sizeof(struct sockaddr_in) ||
 319             addr->sin_family != AF_INET)
 320                 return (EINVAL);
 321         if (broadaddr->sin_len != 0 &&
 322             (broadaddr->sin_len != sizeof(struct sockaddr_in) ||
 323             broadaddr->sin_family != AF_INET))
 324                 return (EINVAL);
 325         if (mask->sin_len != 0 &&
 326             (mask->sin_len != sizeof(struct sockaddr_in) ||
 327             mask->sin_family != AF_INET))
 328                 return (EINVAL);
 329         if ((ifp->if_flags & IFF_POINTOPOINT) &&
 330             (dstaddr->sin_len != sizeof(struct sockaddr_in) ||
 331              dstaddr->sin_addr.s_addr == INADDR_ANY))
 332                 return (EDESTADDRREQ);
 333         if (vhid > 0 && carp_attach_p == NULL)
 334                 return (EPROTONOSUPPORT);
 335
 336         /*
 337          * See whether address already exist.
 338          */
 339         iaIsFirst = true;
 340         ia = NULL;
 341         IF_ADDR_RLOCK(ifp);
 342         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 343                 struct in_ifaddr *it;
 344
 345                 if (ifa->ifa_addr->sa_family != AF_INET)
 346                         continue;
 347
 348                 it = (struct in_ifaddr *)ifa;
 349                 iaIsFirst = false;
 350                 if (it->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr &&
 351                     prison_check_ip4(td->td_ucred, &addr->sin_addr) == 0)
 352                         ia = it;
 353         }
 354         IF_ADDR_RUNLOCK(ifp);
 355
 356         if (ia != NULL)
 357                 (void )in_difaddr_ioctl(data, ifp, td);
 358
 359         ifa = ifa_alloc(sizeof(struct in_ifaddr), M_WAITOK);
 360         ia = (struct in_ifaddr *)ifa;
 361         ifa->ifa_addr = (struct sockaddr *)&ia->ia_addr;
 362         ifa->ifa_dstaddr = (struct sockaddr *)&ia->ia_dstaddr;
 363         ifa->ifa_netmask = (struct sockaddr *)&ia->ia_sockmask;
 364
 365         ia->ia_ifp = ifp;
 366         ia->ia_ifa.ifa_metric = ifp->if_metric;
 367         ia->ia_addr = *addr;
 368         if (mask->sin_len != 0) {
 369                 ia->ia_sockmask = *mask;
 370                 ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr);
 371         } else {
 372                 in_addr_t i = ntohl(addr->sin_addr.s_addr);
 373
 374                 /*
 375                  * Be compatible with network classes, if netmask isn't
 376                  * supplied, guess it based on classes.
 377                  */
 378                 if (IN_CLASSA(i))
 379                         ia->ia_subnetmask = IN_CLASSA_NET;
 380                 else if (IN_CLASSB(i))
 381                         ia->ia_subnetmask = IN_CLASSB_NET;
 382                 else
 383                         ia->ia_subnetmask = IN_CLASSC_NET;
 384                 ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
 385         }
 386         ia->ia_subnet = ntohl(addr->sin_addr.s_addr) & ia->ia_subnetmask;
 387         in_socktrim(&ia->ia_sockmask);
 388
 389         if (ifp->if_flags & IFF_BROADCAST) {
 390                 if (broadaddr->sin_len != 0) {
 391                         ia->ia_broadaddr = *broadaddr;
 392                 } else if (ia->ia_subnetmask == IN_RFC3021_MASK) {
 393                         ia->ia_broadaddr.sin_addr.s_addr = INADDR_BROADCAST;
 394                         ia->ia_broadaddr.sin_len = sizeof(struct sockaddr_in);
 395                         ia->ia_broadaddr.sin_family = AF_INET;
 396                 } else {
 397                         ia->ia_broadaddr.sin_addr.s_addr =
 398                             htonl(ia->ia_subnet | ~ia->ia_subnetmask);
 399                         ia->ia_broadaddr.sin_len = sizeof(struct sockaddr_in);
 400                         ia->ia_broadaddr.sin_family = AF_INET;
 401                 }
 402         }
 403
 404         if (ifp->if_flags & IFF_POINTOPOINT)
 405                 ia->ia_dstaddr = *dstaddr;
 406
 407         /* XXXGL: rtinit() needs this strange assignment. */
 408         if (ifp->if_flags & IFF_LOOPBACK)
 409                 ia->ia_dstaddr = ia->ia_addr;
 410
 411         ifa_ref(ifa);                   /* if_addrhead */
 412         IF_ADDR_WLOCK(ifp);
 413         TAILQ_INSERT_TAIL(&ifp->if_addrhead, ifa, ifa_link);
 414         IF_ADDR_WUNLOCK(ifp);
 415
 416         ifa_ref(ifa);                   /* in_ifaddrhead */
 417         IN_IFADDR_WLOCK();
 418         TAILQ_INSERT_TAIL(&V_in_ifaddrhead, ia, ia_link);
 419         LIST_INSERT_HEAD(INADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, ia_hash);
 420         IN_IFADDR_WUNLOCK();
 421
 422         if (vhid != 0)
 423                 error = (*carp_attach_p)(&ia->ia_ifa, vhid);
 424         if (error)
 425                 goto fail1;
 426
 427         /*
 428          * Give the interface a chance to initialize
 429          * if this is its first address,
 430          * and to validate the address if necessary.
 431          */
 432         if (ifp->if_ioctl != NULL)
 433                 error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia);
 434         if (error)
 435                 goto fail2;
 436
 437         /*
 438          * Add route for the network.
 439          */
 440         if (vhid == 0) {
 441                 int flags = RTF_UP;
 442
 443                 if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))
 444                         flags |= RTF_HOST;
 445
 446                 error = in_addprefix(ia, flags);
 447                 if (error)
 448                         goto fail2;
 449         }
 450
 451         /*
 452          * Add a loopback route to self.
 453          */
 454         if (vhid == 0 && (ifp->if_flags & IFF_LOOPBACK) == 0 &&
 455             ia->ia_addr.sin_addr.s_addr != INADDR_ANY &&
 456             !((ifp->if_flags & IFF_POINTOPOINT) &&
 457              ia->ia_dstaddr.sin_addr.s_addr == ia->ia_addr.sin_addr.s_addr)) {
 458                 struct in_ifaddr *eia;
 459
 460                 eia = in_localip_more(ia);
 461
 462                 if (eia == NULL) {
 463                         error = ifa_add_loopback_route((struct ifaddr *)ia,
 464                             (struct sockaddr *)&ia->ia_addr);
 465                         if (error)
 466                                 goto fail3;
 467                 } else
 468                         ifa_free(&eia->ia_ifa);
 469         }
 470
 471         if (iaIsFirst && (ifp->if_flags & IFF_MULTICAST)) {
 472                 struct in_addr allhosts_addr;
 473                 struct in_ifinfo *ii;
 474
 475                 ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]);
 476                 allhosts_addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
 477
 478                 error = in_joingroup(ifp, &allhosts_addr, NULL,
 479                         &ii->ii_allhosts);
 480         }
 481
 482         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
 483
 484         return (error);
 485
 486 fail3:
 487         if (vhid == 0)
 488                 (void )in_scrubprefix(ia, LLE_STATIC);
 489
 490 fail2:
 491         if (ia->ia_ifa.ifa_carp)
 492                 (*carp_detach_p)(&ia->ia_ifa);
 493
 494 fail1:
 495         IF_ADDR_WLOCK(ifp);
 496         TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
 497         IF_ADDR_WUNLOCK(ifp);
 498         ifa_free(&ia->ia_ifa);
 499
 500         IN_IFADDR_WLOCK();
 501         TAILQ_REMOVE(&V_in_ifaddrhead, ia, ia_link);
 502         LIST_REMOVE(ia, ia_hash);
 503         IN_IFADDR_WUNLOCK();
 504         ifa_free(&ia->ia_ifa);
 505
 506         return (error);
 507 }
 508
 509 static int
 510 in_difaddr_ioctl(caddr_t data, struct ifnet *ifp, struct thread *td)
 511 {
 512         const struct ifreq *ifr = (struct ifreq *)data;
 513         const struct sockaddr_in *addr = (const struct sockaddr_in *)
 514             &ifr->ifr_addr;
 515         struct ifaddr *ifa;
 516         struct in_ifaddr *ia;
 517         bool deleteAny, iaIsLast;
 518         int error;
 519
 520         if (td != NULL) {
 521                 error = priv_check(td, PRIV_NET_DELIFADDR);
 522                 if (error)
 523                         return (error);
 524         }
 525
 526         if (addr->sin_len != sizeof(struct sockaddr_in) ||
 527             addr->sin_family != AF_INET)
 528                 deleteAny = true;
 529         else
 530                 deleteAny = false;
 531
 532         iaIsLast = true;
 533         ia = NULL;
 534         IF_ADDR_WLOCK(ifp);
 535         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 536                 struct in_ifaddr *it;
 537
 538                 if (ifa->ifa_addr->sa_family != AF_INET)
 539                         continue;
 540
 541                 it = (struct in_ifaddr *)ifa;
 542                 if (deleteAny && ia == NULL && (td == NULL ||
 543                     prison_check_ip4(td->td_ucred, &it->ia_addr.sin_addr) == 0))
 544                         ia = it;
 545
 546                 if (it->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr &&
 547                     (td == NULL || prison_check_ip4(td->td_ucred,
 548                     &addr->sin_addr) == 0))
 549                         ia = it;
 550
 551                 if (it != ia)
 552                         iaIsLast = false;
 553         }
 554
 555         if (ia == NULL) {
 556                 IF_ADDR_WUNLOCK(ifp);
 557                 return (EADDRNOTAVAIL);
 558         }
 559
 560         TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link);
 561         IF_ADDR_WUNLOCK(ifp);
 562         ifa_free(&ia->ia_ifa);          /* if_addrhead */
 563
 564         IN_IFADDR_WLOCK();
 565         TAILQ_REMOVE(&V_in_ifaddrhead, ia, ia_link);
 566         LIST_REMOVE(ia, ia_hash);
 567         IN_IFADDR_WUNLOCK();
 568         ifa_free(&ia->ia_ifa);          /* in_ifaddrhead */
 569
 570         /*
 571          * in_scrubprefix() kills the interface route.
 572          */
 573         in_scrubprefix(ia, LLE_STATIC);
 574
 575         /*
 576          * in_ifadown gets rid of all the rest of
 577          * the routes.  This is not quite the right
 578          * thing to do, but at least if we are running
 579          * a routing process they will come back.
 580          */
 581         in_ifadown(&ia->ia_ifa, 1);
 582
 583         if (ia->ia_ifa.ifa_carp)
 584                 (*carp_detach_p)(&ia->ia_ifa);
 585
 586         /*
 587          * If this is the last IPv4 address configured on this
 588          * interface, leave the all-hosts group.
 589          * No state-change report need be transmitted.
 590          */
 591         if (iaIsLast && (ifp->if_flags & IFF_MULTICAST)) {
 592                 struct in_ifinfo *ii;
 593
 594                 ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]);
 595                 IN_MULTI_LOCK();
 596                 if (ii->ii_allhosts) {
 597                         (void)in_leavegroup_locked(ii->ii_allhosts, NULL);
 598                         ii->ii_allhosts = NULL;
 599                 }
 600                 IN_MULTI_UNLOCK();
 601         }
 602
 603         EVENTHANDLER_INVOKE(ifaddr_event, ifp);
 604
 605         return (0);
 606 }
 607
 608 #define rtinitflags(x) \
 609         ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \
 610             ? RTF_HOST : 0)
 611
 612 /*
 613  * Generate a routing message when inserting or deleting
 614  * an interface address alias.
 615  */
 616 static void in_addralias_rtmsg(int cmd, struct in_addr *prefix,
 617     struct in_ifaddr *target)
 618 {
 619         struct route pfx_ro;
 620         struct sockaddr_in *pfx_addr;
 621         struct rtentry msg_rt;
 622
 623         /* QL: XXX
 624          * This is a bit questionable because there is no
 625          * additional route entry added/deleted for an address
 626          * alias. Therefore this route report is inaccurate.
 627          */
 628         bzero(&pfx_ro, sizeof(pfx_ro));
 629         pfx_addr = (struct sockaddr_in *)(&pfx_ro.ro_dst);
 630         pfx_addr->sin_len = sizeof(*pfx_addr);
 631         pfx_addr->sin_family = AF_INET;
 632         pfx_addr->sin_addr = *prefix;
 633         rtalloc_ign_fib(&pfx_ro, 0, 0);
 634         if (pfx_ro.ro_rt != NULL) {
 635                 msg_rt = *pfx_ro.ro_rt;
 636
 637                 /* QL: XXX
 638                  * Point the gateway to the new interface
 639                  * address as if a new prefix route entry has
 640                  * been added through the new address alias.
 641                  * All other parts of the rtentry is accurate,
 642                  * e.g., rt_key, rt_mask, rt_ifp etc.
 643                  */
 644                 msg_rt.rt_gateway = (struct sockaddr *)&target->ia_addr;
 645                 rt_newaddrmsg(cmd, (struct ifaddr *)target, 0, &msg_rt);
 646                 RTFREE(pfx_ro.ro_rt);
 647         }
 648         return;
 649 }
 650
 651 /*
 652  * Check if we have a route for the given prefix already or add one accordingly.
 653  */
 654 int
 655 in_addprefix(struct in_ifaddr *target, int flags)
 656 {
 657         struct in_ifaddr *ia;
 658         struct in_addr prefix, mask, p, m;
 659         int error;
 660
 661         if ((flags & RTF_HOST) != 0) {
 662                 prefix = target->ia_dstaddr.sin_addr;
 663                 mask.s_addr = 0;
 664         } else {
 665                 prefix = target->ia_addr.sin_addr;
 666                 mask = target->ia_sockmask.sin_addr;
 667                 prefix.s_addr &= mask.s_addr;
 668         }
 669
 670         IN_IFADDR_RLOCK();
 671         TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
 672                 if (rtinitflags(ia)) {
 673                         p = ia->ia_dstaddr.sin_addr;
 674
 675                         if (prefix.s_addr != p.s_addr)
 676                                 continue;
 677                 } else {
 678                         p = ia->ia_addr.sin_addr;
 679                         m = ia->ia_sockmask.sin_addr;
 680                         p.s_addr &= m.s_addr;
 681
 682                         if (prefix.s_addr != p.s_addr ||
 683                             mask.s_addr != m.s_addr)
 684                                 continue;
 685                 }
 686
 687                 /*
 688                  * If we got a matching prefix route inserted by other
 689                  * interface address, we are done here.
 690                  */
 691                 if (ia->ia_flags & IFA_ROUTE) {
 692 #ifdef RADIX_MPATH
 693                         if (ia->ia_addr.sin_addr.s_addr ==
 694                             target->ia_addr.sin_addr.s_addr) {
 695                                 IN_IFADDR_RUNLOCK();
 696                                 return (EEXIST);
 697                         } else
 698                                 break;
 699 #endif
 700                         if (V_nosameprefix) {
 701                                 IN_IFADDR_RUNLOCK();
 702                                 return (EEXIST);
 703                         } else {
 704                                 in_addralias_rtmsg(RTM_ADD, &prefix, target);
 705                                 IN_IFADDR_RUNLOCK();
 706                                 return (0);
 707                         }
 708                 }
 709         }
 710         IN_IFADDR_RUNLOCK();
 711
 712         /*
 713          * No-one seem to have this prefix route, so we try to insert it.
 714          */
 715         error = rtinit(&target->ia_ifa, (int)RTM_ADD, flags);
 716         if (!error)
 717                 target->ia_flags |= IFA_ROUTE;
 718         return (error);
 719 }
 720
 721 /*
 722  * If there is no other address in the system that can serve a route to the
 723  * same prefix, remove the route.  Hand over the route to the new address
 724  * otherwise.
 725  */
 726 int
 727 in_scrubprefix(struct in_ifaddr *target, u_int flags)
 728 {
 729         struct in_ifaddr *ia;
 730         struct in_addr prefix, mask, p, m;
 731         int error = 0;
 732         struct sockaddr_in prefix0, mask0;
 733
 734         /*
 735          * Remove the loopback route to the interface address.
 736          */
 737         if ((target->ia_addr.sin_addr.s_addr != INADDR_ANY) &&
 738             !(target->ia_ifp->if_flags & IFF_LOOPBACK) &&
 739             (flags & LLE_STATIC)) {
 740                 struct in_ifaddr *eia;
 741
 742                 eia = in_localip_more(target);
 743
 744                 if (eia != NULL) {
 745                         error = ifa_switch_loopback_route((struct ifaddr *)eia,
 746                             (struct sockaddr *)&target->ia_addr);
 747                         ifa_free(&eia->ia_ifa);
 748                 } else {
 749                         error = ifa_del_loopback_route((struct ifaddr *)target,
 750                             (struct sockaddr *)&target->ia_addr);
 751                 }
 752
 753                 if (!(target->ia_ifp->if_flags & IFF_NOARP))
 754                         /* remove arp cache */
 755                         arp_ifscrub(target->ia_ifp,
 756                             IA_SIN(target)->sin_addr.s_addr);
 757         }
 758
 759         if (rtinitflags(target)) {
 760                 prefix = target->ia_dstaddr.sin_addr;
 761                 mask.s_addr = 0;
 762         } else {
 763                 prefix = target->ia_addr.sin_addr;
 764                 mask = target->ia_sockmask.sin_addr;
 765                 prefix.s_addr &= mask.s_addr;
 766         }
 767
 768         if ((target->ia_flags & IFA_ROUTE) == 0) {
 769                 in_addralias_rtmsg(RTM_DELETE, &prefix, target);
 770                 return (0);
 771         }
 772
 773         IN_IFADDR_RLOCK();
 774         TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
 775                 if (rtinitflags(ia)) {
 776                         p = ia->ia_dstaddr.sin_addr;
 777
 778                         if (prefix.s_addr != p.s_addr)
 779                                 continue;
 780                 } else {
 781                         p = ia->ia_addr.sin_addr;
 782                         m = ia->ia_sockmask.sin_addr;
 783                         p.s_addr &= m.s_addr;
 784
 785                         if (prefix.s_addr != p.s_addr ||
 786                             mask.s_addr != m.s_addr)
 787                                 continue;
 788                 }
 789
 790                 if ((ia->ia_ifp->if_flags & IFF_UP) == 0)
 791                         continue;
 792
 793                 /*
 794                  * If we got a matching prefix address, move IFA_ROUTE and
 795                  * the route itself to it.  Make sure that routing daemons
 796                  * get a heads-up.
 797                  */
 798                 if ((ia->ia_flags & IFA_ROUTE) == 0) {
 799                         ifa_ref(&ia->ia_ifa);
 800                         IN_IFADDR_RUNLOCK();
 801                         error = rtinit(&(target->ia_ifa), (int)RTM_DELETE,
 802                             rtinitflags(target));
 803                         if (error == 0)
 804                                 target->ia_flags &= ~IFA_ROUTE;
 805                         else
 806                                 log(LOG_INFO, "in_scrubprefix: err=%d, old prefix delete failed\n",
 807                                         error);
 808                         error = rtinit(&ia->ia_ifa, (int)RTM_ADD,
 809                             rtinitflags(ia) | RTF_UP);
 810                         if (error == 0)
 811                                 ia->ia_flags |= IFA_ROUTE;
 812                         else
 813                                 log(LOG_INFO, "in_scrubprefix: err=%d, new prefix add failed\n",
 814                                         error);
 815                         ifa_free(&ia->ia_ifa);
 816                         return (error);
 817                 }
 818         }
 819         IN_IFADDR_RUNLOCK();
 820
 821         /*
 822          * remove all L2 entries on the given prefix
 823          */
 824         bzero(&prefix0, sizeof(prefix0));
 825         prefix0.sin_len = sizeof(prefix0);
 826         prefix0.sin_family = AF_INET;
 827         prefix0.sin_addr.s_addr = target->ia_subnet;
 828         bzero(&mask0, sizeof(mask0));
 829         mask0.sin_len = sizeof(mask0);
 830         mask0.sin_family = AF_INET;
 831         mask0.sin_addr.s_addr = target->ia_subnetmask;
 832         lltable_prefix_free(AF_INET, (struct sockaddr *)&prefix0,
 833             (struct sockaddr *)&mask0, flags);
 834
 835         /*
 836          * As no-one seem to have this prefix, we can remove the route.
 837          */
 838         error = rtinit(&(target->ia_ifa), (int)RTM_DELETE, rtinitflags(target));
 839         if (error == 0)
 840                 target->ia_flags &= ~IFA_ROUTE;
 841         else
 842                 log(LOG_INFO, "in_scrubprefix: err=%d, prefix delete failed\n", error);
 843         return (error);
 844 }
 845
 846 #undef rtinitflags
 847
 848 /*
 849  * Return 1 if the address might be a local broadcast address.
 850  */
 851 int
 852 in_broadcast(struct in_addr in, struct ifnet *ifp)
 853 {
 854         register struct ifaddr *ifa;
 855         u_long t;
 856
 857         if (in.s_addr == INADDR_BROADCAST ||
 858             in.s_addr == INADDR_ANY)
 859                 return (1);
 860         if ((ifp->if_flags & IFF_BROADCAST) == 0)
 861                 return (0);
 862         t = ntohl(in.s_addr);
 863         /*
 864          * Look through the list of addresses for a match
 865          * with a broadcast address.
 866          */
 867 #define ia ((struct in_ifaddr *)ifa)
 868         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
 869                 if (ifa->ifa_addr->sa_family == AF_INET &&
 870                     (in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
 871                      /*
 872                       * Check for old-style (host 0) broadcast, but
 873                       * taking into account that RFC 3021 obsoletes it.
 874                       */
 875                     (ia->ia_subnetmask != IN_RFC3021_MASK &&
 876                     t == ia->ia_subnet)) &&
 877                      /*
 878                       * Check for an all one subnetmask. These
 879                       * only exist when an interface gets a secondary
 880                       * address.
 881                       */
 882                     ia->ia_subnetmask != (u_long)0xffffffff)
 883                             return (1);
 884         return (0);
 885 #undef ia
 886 }
 887
 888 /*
 889  * On interface removal, clean up IPv4 data structures hung off of the ifnet.
 890  */
 891 void
 892 in_ifdetach(struct ifnet *ifp)
 893 {
 894
 895         in_pcbpurgeif0(&V_ripcbinfo, ifp);
 896         in_pcbpurgeif0(&V_udbinfo, ifp);
 897         in_purgemaddrs(ifp);
 898 }
 899
 900 /*
 901  * Delete all IPv4 multicast address records, and associated link-layer
 902  * multicast address records, associated with ifp.
 903  * XXX It looks like domifdetach runs AFTER the link layer cleanup.
 904  * XXX This should not race with ifma_protospec being set during
 905  * a new allocation, if it does, we have bigger problems.
 906  */
 907 static void
 908 in_purgemaddrs(struct ifnet *ifp)
 909 {
 910         LIST_HEAD(,in_multi) purgeinms;
 911         struct in_multi         *inm, *tinm;
 912         struct ifmultiaddr      *ifma;
 913
 914         LIST_INIT(&purgeinms);
 915         IN_MULTI_LOCK();
 916
 917         /*
 918          * Extract list of in_multi associated with the detaching ifp
 919          * which the PF_INET layer is about to release.
 920          * We need to do this as IF_ADDR_LOCK() may be re-acquired
 921          * by code further down.
 922          */
 923         IF_ADDR_RLOCK(ifp);
 924         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 925                 if (ifma->ifma_addr->sa_family != AF_INET ||
 926                     ifma->ifma_protospec == NULL)
 927                         continue;
 928 #if 0
 929                 KASSERT(ifma->ifma_protospec != NULL,
 930                     ("%s: ifma_protospec is NULL", __func__));
 931 #endif
 932                 inm = (struct in_multi *)ifma->ifma_protospec;
 933                 LIST_INSERT_HEAD(&purgeinms, inm, inm_link);
 934         }
 935         IF_ADDR_RUNLOCK(ifp);
 936
 937         LIST_FOREACH_SAFE(inm, &purgeinms, inm_link, tinm) {
 938                 LIST_REMOVE(inm, inm_link);
 939                 inm_release_locked(inm);
 940         }
 941         igmp_ifdetach(ifp);
 942
 943         IN_MULTI_UNLOCK();
 944 }
 945
 946 struct in_llentry {
 947         struct llentry          base;
 948         struct sockaddr_in      l3_addr4;
 949 };
 950
 951 /*
 952  * Deletes an address from the address table.
 953  * This function is called by the timer functions
 954  * such as arptimer() and nd6_llinfo_timer(), and
 955  * the caller does the locking.
 956  */
 957 static void
 958 in_lltable_free(struct lltable *llt, struct llentry *lle)
 959 {
 960         LLE_WUNLOCK(lle);
 961         LLE_LOCK_DESTROY(lle);
 962         free(lle, M_LLTABLE);
 963 }
 964
 965 static struct llentry *
 966 in_lltable_new(const struct sockaddr *l3addr, u_int flags)
 967 {
 968         struct in_llentry *lle;
 969
 970         lle = malloc(sizeof(struct in_llentry), M_LLTABLE, M_NOWAIT | M_ZERO);
 971         if (lle == NULL)                /* NB: caller generates msg */
 972                 return NULL;
 973
 974         /*
 975          * For IPv4 this will trigger "arpresolve" to generate
 976          * an ARP request.
 977          */
 978         lle->base.la_expire = time_uptime; /* mark expired */
 979         lle->l3_addr4 = *(const struct sockaddr_in *)l3addr;
 980         lle->base.lle_refcnt = 1;
 981         lle->base.lle_free = in_lltable_free;
 982         LLE_LOCK_INIT(&lle->base);
 983         callout_init_rw(&lle->base.la_timer, &lle->base.lle_lock,
 984             CALLOUT_RETURNUNLOCKED);
 985
 986         return (&lle->base);
 987 }
 988
 989 #define IN_ARE_MASKED_ADDR_EQUAL(d, a, m)       (                       \
 990             (((ntohl((d)->sin_addr.s_addr) ^ (a)->sin_addr.s_addr) & (m)->sin_addr.s_addr)) == 0 )
 991
 992 static void
 993 in_lltable_prefix_free(struct lltable *llt, const struct sockaddr *prefix,
 994     const struct sockaddr *mask, u_int flags)
 995 {
 996         const struct sockaddr_in *pfx = (const struct sockaddr_in *)prefix;
 997         const struct sockaddr_in *msk = (const struct sockaddr_in *)mask;
 998         struct llentry *lle, *next;
 999         int i;
1000         size_t pkts_dropped;
1001
1002         IF_AFDATA_WLOCK(llt->llt_ifp);
1003         for (i = 0; i < LLTBL_HASHTBL_SIZE; i++) {
1004                 LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) {
1005                         /*
1006                          * (flags & LLE_STATIC) means deleting all entries
1007                          * including static ARP entries.
1008                          */
1009                         if (IN_ARE_MASKED_ADDR_EQUAL(satosin(L3_ADDR(lle)),
1010                             pfx, msk) && ((flags & LLE_STATIC) ||
1011                             !(lle->la_flags & LLE_STATIC))) {
1012                                 LLE_WLOCK(lle);
1013                                 if (callout_stop(&lle->la_timer))
1014                                         LLE_REMREF(lle);
1015                                 pkts_dropped = llentry_free(lle);
1016                                 ARPSTAT_ADD(dropped, pkts_dropped);
1017                         }
1018                 }
1019         }
1020         IF_AFDATA_WUNLOCK(llt->llt_ifp);
1021 }
1022
1023
1024 static int
1025 in_lltable_rtcheck(struct ifnet *ifp, u_int flags, const struct sockaddr *l3addr)
1026 {
1027         struct rtentry *rt;
1028
1029         KASSERT(l3addr->sa_family == AF_INET,
1030             ("sin_family %d", l3addr->sa_family));
1031
1032         /* XXX rtalloc1 should take a const param */
1033         rt = rtalloc1(__DECONST(struct sockaddr *, l3addr), 0, 0);
1034
1035         if (rt == NULL)
1036                 return (EINVAL);
1037
1038         /*
1039          * If the gateway for an existing host route matches the target L3
1040          * address, which is a special route inserted by some implementation
1041          * such as MANET, and the interface is of the correct type, then
1042          * allow for ARP to proceed.
1043          */
1044         if (rt->rt_flags & RTF_GATEWAY) {
1045                 if (!(rt->rt_flags & RTF_HOST) || !rt->rt_ifp ||
1046                     rt->rt_ifp->if_type != IFT_ETHER ||
1047                     (rt->rt_ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) != 0 ||
1048                     memcmp(rt->rt_gateway->sa_data, l3addr->sa_data,
1049                     sizeof(in_addr_t)) != 0) {
1050                         RTFREE_LOCKED(rt);
1051                         return (EINVAL);
1052                 }
1053         }
1054
1055         /*
1056          * Make sure that at least the destination address is covered
1057          * by the route. This is for handling the case where 2 or more
1058          * interfaces have the same prefix. An incoming packet arrives
1059          * on one interface and the corresponding outgoing packet leaves
1060          * another interface.
1061          */
1062         if (!(rt->rt_flags & RTF_HOST) && rt->rt_ifp != ifp) {
1063                 const char *sa, *mask, *addr, *lim;
1064                 int len;
1065
1066                 mask = (const char *)rt_mask(rt);
1067                 /*
1068                  * Just being extra cautious to avoid some custom
1069                  * code getting into trouble.
1070                  */
1071                 if (mask == NULL) {
1072                         RTFREE_LOCKED(rt);
1073                         return (EINVAL);
1074                 }
1075
1076                 sa = (const char *)rt_key(rt);
1077                 addr = (const char *)l3addr;
1078                 len = ((const struct sockaddr_in *)l3addr)->sin_len;
1079                 lim = addr + len;
1080
1081                 for ( ; addr < lim; sa++, mask++, addr++) {
1082                         if ((*sa ^ *addr) & *mask) {
1083 #ifdef DIAGNOSTIC
1084                                 log(LOG_INFO, "IPv4 address: \"%s\" is not on the network\n",
1085                                     inet_ntoa(((const struct sockaddr_in *)l3addr)->sin_addr));
1086 #endif
1087                                 RTFREE_LOCKED(rt);
1088                                 return (EINVAL);
1089                         }
1090                 }
1091         }
1092
1093         RTFREE_LOCKED(rt);
1094         return (0);
1095 }
1096
1097 /*
1098  * Return NULL if not found or marked for deletion.
1099  * If found return lle read locked.
1100  */
1101 static struct llentry *
1102 in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr)
1103 {
1104         const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr;
1105         struct ifnet *ifp = llt->llt_ifp;
1106         struct llentry *lle;
1107         struct llentries *lleh;
1108         u_int hashkey;
1109
1110         IF_AFDATA_LOCK_ASSERT(ifp);
1111         KASSERT(l3addr->sa_family == AF_INET,
1112             ("sin_family %d", l3addr->sa_family));
1113
1114         hashkey = sin->sin_addr.s_addr;
1115         lleh = &llt->lle_head[LLATBL_HASH(hashkey, LLTBL_HASHMASK)];
1116         LIST_FOREACH(lle, lleh, lle_next) {
1117                 struct sockaddr_in *sa2 = satosin(L3_ADDR(lle));
1118                 if (lle->la_flags & LLE_DELETED)
1119                         continue;
1120                 if (sa2->sin_addr.s_addr == sin->sin_addr.s_addr)
1121                         break;
1122         }
1123         if (lle == NULL) {
1124 #ifdef DIAGNOSTIC
1125                 if (flags & LLE_DELETE)
1126                         log(LOG_INFO, "interface address is missing from cache = %p  in delete\n", lle);
1127 #endif
1128                 if (!(flags & LLE_CREATE))
1129                         return (NULL);
1130                 IF_AFDATA_WLOCK_ASSERT(ifp);
1131                 /*
1132                  * A route that covers the given address must have
1133                  * been installed 1st because we are doing a resolution,
1134                  * verify this.
1135                  */
1136                 if (!(flags & LLE_IFADDR) &&
1137                     in_lltable_rtcheck(ifp, flags, l3addr) != 0)
1138                         goto done;
1139
1140                 lle = in_lltable_new(l3addr, flags);
1141                 if (lle == NULL) {
1142                         log(LOG_INFO, "lla_lookup: new lle malloc failed\n");
1143                         goto done;
1144                 }
1145                 lle->la_flags = flags & ~LLE_CREATE;
1146                 if ((flags & (LLE_CREATE | LLE_IFADDR)) == (LLE_CREATE | LLE_IFADDR)) {
1147                         bcopy(IF_LLADDR(ifp), &lle->ll_addr, ifp->if_addrlen);
1148                         lle->la_flags |= (LLE_VALID | LLE_STATIC);
1149                 }
1150
1151                 lle->lle_tbl  = llt;
1152                 lle->lle_head = lleh;
1153                 lle->la_flags |= LLE_LINKED;
1154                 LIST_INSERT_HEAD(lleh, lle, lle_next);
1155         } else if (flags & LLE_DELETE) {
1156                 if (!(lle->la_flags & LLE_IFADDR) || (flags & LLE_IFADDR)) {
1157                         LLE_WLOCK(lle);
1158                         lle->la_flags |= LLE_DELETED;
1159                         EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_DELETED);
1160 #ifdef DIAGNOSTIC
1161                         log(LOG_INFO, "ifaddr cache = %p is deleted\n", lle);
1162 #endif
1163                         if ((lle->la_flags &
1164                             (LLE_STATIC | LLE_IFADDR)) == LLE_STATIC)
1165                                 llentry_free(lle);
1166                         else
1167                                 LLE_WUNLOCK(lle);
1168                 }
1169                 lle = (void *)-1;
1170
1171         }
1172         if (LLE_IS_VALID(lle)) {
1173                 if (flags & LLE_EXCLUSIVE)
1174                         LLE_WLOCK(lle);
1175                 else
1176                         LLE_RLOCK(lle);
1177         }
1178 done:
1179         return (lle);
1180 }
1181
1182 static int
1183 in_lltable_dump(struct lltable *llt, struct sysctl_req *wr)
1184 {
1185 #define SIN(lle)        ((struct sockaddr_in *) L3_ADDR(lle))
1186         struct ifnet *ifp = llt->llt_ifp;
1187         struct llentry *lle;
1188         /* XXX stack use */
1189         struct {
1190                 struct rt_msghdr        rtm;
1191                 struct sockaddr_in      sin;
1192                 struct sockaddr_dl      sdl;
1193         } arpc;
1194         int error, i;
1195
1196         LLTABLE_LOCK_ASSERT();
1197
1198         error = 0;
1199         for (i = 0; i < LLTBL_HASHTBL_SIZE; i++) {
1200                 LIST_FOREACH(lle, &llt->lle_head[i], lle_next) {
1201                         struct sockaddr_dl *sdl;
1202
1203                         /* skip deleted entries */
1204                         if ((lle->la_flags & LLE_DELETED) == LLE_DELETED)
1205                                 continue;
1206                         /* Skip if jailed and not a valid IP of the prison. */
1207                         if (prison_if(wr->td->td_ucred, L3_ADDR(lle)) != 0)
1208                                 continue;
1209                         /*
1210                          * produce a msg made of:
1211                          *  struct rt_msghdr;
1212                          *  struct sockaddr_in; (IPv4)
1213                          *  struct sockaddr_dl;
1214                          */
1215                         bzero(&arpc, sizeof(arpc));
1216                         arpc.rtm.rtm_msglen = sizeof(arpc);
1217                         arpc.rtm.rtm_version = RTM_VERSION;
1218                         arpc.rtm.rtm_type = RTM_GET;
1219                         arpc.rtm.rtm_flags = RTF_UP;
1220                         arpc.rtm.rtm_addrs = RTA_DST | RTA_GATEWAY;
1221                         arpc.sin.sin_family = AF_INET;
1222                         arpc.sin.sin_len = sizeof(arpc.sin);
1223                         arpc.sin.sin_addr.s_addr = SIN(lle)->sin_addr.s_addr;
1224
1225                         /* publish */
1226                         if (lle->la_flags & LLE_PUB)
1227                                 arpc.rtm.rtm_flags |= RTF_ANNOUNCE;
1228
1229                         sdl = &arpc.sdl;
1230                         sdl->sdl_family = AF_LINK;
1231                         sdl->sdl_len = sizeof(*sdl);
1232                         sdl->sdl_index = ifp->if_index;
1233                         sdl->sdl_type = ifp->if_type;
1234                         if ((lle->la_flags & LLE_VALID) == LLE_VALID) {
1235                                 sdl->sdl_alen = ifp->if_addrlen;
1236                                 bcopy(&lle->ll_addr, LLADDR(sdl), ifp->if_addrlen);
1237                         } else {
1238                                 sdl->sdl_alen = 0;
1239                                 bzero(LLADDR(sdl), ifp->if_addrlen);
1240                         }
1241
1242                         arpc.rtm.rtm_rmx.rmx_expire =
1243                             lle->la_flags & LLE_STATIC ? 0 : lle->la_expire;
1244                         arpc.rtm.rtm_flags |= (RTF_HOST | RTF_LLDATA);
1245                         if (lle->la_flags & LLE_STATIC)
1246                                 arpc.rtm.rtm_flags |= RTF_STATIC;
1247                         arpc.rtm.rtm_index = ifp->if_index;
1248                         error = SYSCTL_OUT(wr, &arpc, sizeof(arpc));
1249                         if (error)
1250                                 break;
1251                 }
1252         }
1253         return error;
1254 #undef SIN
1255 }
1256
1257 void *
1258 in_domifattach(struct ifnet *ifp)
1259 {
1260         struct in_ifinfo *ii;
1261         struct lltable *llt;
1262
1263         ii = malloc(sizeof(struct in_ifinfo), M_IFADDR, M_WAITOK|M_ZERO);
1264
1265         llt = lltable_init(ifp, AF_INET);
1266         if (llt != NULL) {
1267                 llt->llt_prefix_free = in_lltable_prefix_free;
1268                 llt->llt_lookup = in_lltable_lookup;
1269                 llt->llt_dump = in_lltable_dump;
1270         }
1271         ii->ii_llt = llt;
1272
1273         ii->ii_igmp = igmp_domifattach(ifp);
1274
1275         return ii;
1276 }
1277
1278 void
1279 in_domifdetach(struct ifnet *ifp, void *aux)
1280 {
1281         struct in_ifinfo *ii = (struct in_ifinfo *)aux;
1282
1283         igmp_domifdetach(ifp);
1284         lltable_free(ii->ii_llt);
1285         free(ii, M_IFADDR);
1286 }