sys/net/if.c

   1 /*
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)if.c        8.3 (Berkeley) 1/4/94
  34  * $FreeBSD: src/sys/net/if.c,v 1.85.2.23 2003/04/15 18:11:19 fjoe Exp $
  35  * $DragonFly: src/sys/net/if.c,v 1.7 2003/09/12 00:43:31 daver Exp $
  36  */
  37
  38 #include "opt_compat.h"
  39 #include "opt_inet6.h"
  40 #include "opt_inet.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/malloc.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/systm.h>
  46 #include <sys/proc.h>
  47 #include <sys/socket.h>
  48 #include <sys/socketvar.h>
  49 #include <sys/protosw.h>
  50 #include <sys/kernel.h>
  51 #include <sys/sockio.h>
  52 #include <sys/syslog.h>
  53 #include <sys/sysctl.h>
  54
  55 #include <net/if.h>
  56 #include <net/if_arp.h>
  57 #include <net/if_dl.h>
  58 #include <net/if_types.h>
  59 #include <net/if_var.h>
  60 #include <net/radix.h>
  61 #include <net/route.h>
  62 #include <machine/stdarg.h>
  63
  64 #if defined(INET) || defined(INET6)
  65 /*XXX*/
  66 #include <netinet/in.h>
  67 #include <netinet/in_var.h>
  68 #include <netinet/if_ether.h>
  69 #ifdef INET6
  70 #include <machine/clock.h> /* XXX: temporal workaround for fxp issue */
  71 #include <netinet6/in6_var.h>
  72 #include <netinet6/in6_ifattach.h>
  73 #endif
  74 #endif
  75
  76 #if defined(COMPAT_43)
  77 #include <emulation/43bsd/43bsd_socket.h>
  78 #endif /* COMPAT_43 */
  79
  80 /*
  81  * System initialization
  82  */
  83
  84 static int ifconf (u_long, caddr_t);
  85 static void ifinit (void *);
  86 static void if_qflush (struct ifqueue *);
  87 static void if_slowtimo (void *);
  88 static void link_rtrequest (int, struct rtentry *, struct rt_addrinfo *);
  89 static int  if_rtdel (struct radix_node *, void *);
  90
  91 SYSINIT(interfaces, SI_SUB_PROTO_IF, SI_ORDER_FIRST, ifinit, NULL)
  92
  93 MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
  94 MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
  95
  96 int     ifqmaxlen = IFQ_MAXLEN;
  97 struct  ifnethead ifnet;        /* depend on static init XXX */
  98
  99 #ifdef INET6
 100 /*
 101  * XXX: declare here to avoid to include many inet6 related files..
 102  * should be more generalized?
 103  */
 104 extern void     nd6_setmtu (struct ifnet *);
 105 #endif
 106
 107 struct if_clone *if_clone_lookup (const char *, int *);
 108 int if_clone_list (struct if_clonereq *);
 109
 110 LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
 111 int if_cloners_count;
 112
 113 /*
 114  * Network interface utility routines.
 115  *
 116  * Routines with ifa_ifwith* names take sockaddr *'s as
 117  * parameters.
 118  */
 119 /* ARGSUSED*/
 120 void
 121 ifinit(dummy)
 122         void *dummy;
 123 {
 124         struct ifnet *ifp;
 125         int s;
 126
 127         s = splimp();
 128         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 129                 if (ifp->if_snd.ifq_maxlen == 0) {
 130                         printf("%s%d XXX: driver didn't set ifq_maxlen\n",
 131                             ifp->if_name, ifp->if_unit);
 132                         ifp->if_snd.ifq_maxlen = ifqmaxlen;
 133                 }
 134         }
 135         splx(s);
 136         if_slowtimo(0);
 137 }
 138
 139 int if_index = 0;
 140 struct ifaddr **ifnet_addrs;
 141 struct ifnet **ifindex2ifnet = NULL;
 142
 143
 144 /*
 145  * Attach an interface to the
 146  * list of "active" interfaces.
 147  */
 148 void
 149 if_attach(ifp)
 150         struct ifnet *ifp;
 151 {
 152         unsigned socksize, ifasize;
 153         int namelen, masklen;
 154         char workbuf[64];
 155         struct sockaddr_dl *sdl;
 156         struct ifaddr *ifa;
 157         static int if_indexlim = 8;
 158         static int inited;
 159
 160         if (!inited) {
 161                 TAILQ_INIT(&ifnet);
 162                 inited = 1;
 163         }
 164
 165         TAILQ_INSERT_TAIL(&ifnet, ifp, if_link);
 166         ifp->if_index = ++if_index;
 167         /*
 168          * XXX -
 169          * The old code would work if the interface passed a pre-existing
 170          * chain of ifaddrs to this code.  We don't trust our callers to
 171          * properly initialize the tailq, however, so we no longer allow
 172          * this unlikely case.
 173          */
 174         TAILQ_INIT(&ifp->if_addrhead);
 175         TAILQ_INIT(&ifp->if_prefixhead);
 176         LIST_INIT(&ifp->if_multiaddrs);
 177         getmicrotime(&ifp->if_lastchange);
 178         if (ifnet_addrs == 0 || if_index >= if_indexlim) {
 179                 unsigned n = (if_indexlim <<= 1) * sizeof(ifa);
 180                 caddr_t q = malloc(n, M_IFADDR, M_WAITOK);
 181                 bzero(q, n);
 182                 if (ifnet_addrs) {
 183                         bcopy((caddr_t)ifnet_addrs, (caddr_t)q, n/2);
 184                         free((caddr_t)ifnet_addrs, M_IFADDR);
 185                 }
 186                 ifnet_addrs = (struct ifaddr **)q;
 187
 188                 /* grow ifindex2ifnet */
 189                 n = if_indexlim * sizeof(struct ifnet *);
 190                 q = malloc(n, M_IFADDR, M_WAITOK);
 191                 bzero(q, n);
 192                 if (ifindex2ifnet) {
 193                         bcopy((caddr_t)ifindex2ifnet, q, n/2);
 194                         free((caddr_t)ifindex2ifnet, M_IFADDR);
 195                 }
 196                 ifindex2ifnet = (struct ifnet **)q;
 197         }
 198
 199         ifindex2ifnet[if_index] = ifp;
 200
 201         /*
 202          * create a Link Level name for this device
 203          */
 204         namelen = snprintf(workbuf, sizeof(workbuf),
 205             "%s%d", ifp->if_name, ifp->if_unit);
 206 #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m))
 207         masklen = _offsetof(struct sockaddr_dl, sdl_data[0]) + namelen;
 208         socksize = masklen + ifp->if_addrlen;
 209 #define ROUNDUP(a) (1 + (((a) - 1) | (sizeof(long) - 1)))
 210         if (socksize < sizeof(*sdl))
 211                 socksize = sizeof(*sdl);
 212         socksize = ROUNDUP(socksize);
 213         ifasize = sizeof(*ifa) + 2 * socksize;
 214         ifa = (struct ifaddr *)malloc(ifasize, M_IFADDR, M_WAITOK);
 215         if (ifa) {
 216                 bzero((caddr_t)ifa, ifasize);
 217                 sdl = (struct sockaddr_dl *)(ifa + 1);
 218                 sdl->sdl_len = socksize;
 219                 sdl->sdl_family = AF_LINK;
 220                 bcopy(workbuf, sdl->sdl_data, namelen);
 221                 sdl->sdl_nlen = namelen;
 222                 sdl->sdl_index = ifp->if_index;
 223                 sdl->sdl_type = ifp->if_type;
 224                 ifnet_addrs[if_index - 1] = ifa;
 225                 ifa->ifa_ifp = ifp;
 226                 ifa->ifa_rtrequest = link_rtrequest;
 227                 ifa->ifa_addr = (struct sockaddr *)sdl;
 228                 sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
 229                 ifa->ifa_netmask = (struct sockaddr *)sdl;
 230                 sdl->sdl_len = masklen;
 231                 while (namelen != 0)
 232                         sdl->sdl_data[--namelen] = 0xff;
 233                 TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
 234         }
 235
 236         /* Announce the interface. */
 237         rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
 238 }
 239
 240 /*
 241  * Detach an interface, removing it from the
 242  * list of "active" interfaces.
 243  */
 244 void
 245 if_detach(ifp)
 246         struct ifnet *ifp;
 247 {
 248         struct ifaddr *ifa;
 249         struct radix_node_head  *rnh;
 250         int s;
 251         int i;
 252
 253         /*
 254          * Remove routes and flush queues.
 255          */
 256         s = splnet();
 257         if_down(ifp);
 258
 259         /*
 260          * Remove address from ifnet_addrs[] and maybe decrement if_index.
 261          * Clean up all addresses.
 262          */
 263         ifnet_addrs[ifp->if_index - 1] = 0;
 264         while (if_index > 0 && ifnet_addrs[if_index - 1] == 0)
 265                 if_index--;
 266
 267         for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa;
 268              ifa = TAILQ_FIRST(&ifp->if_addrhead)) {
 269 #ifdef INET
 270                 /* XXX: Ugly!! ad hoc just for INET */
 271                 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) {
 272                         struct ifaliasreq ifr;
 273
 274                         bzero(&ifr, sizeof(ifr));
 275                         ifr.ifra_addr = *ifa->ifa_addr;
 276                         if (ifa->ifa_dstaddr)
 277                                 ifr.ifra_broadaddr = *ifa->ifa_dstaddr;
 278                         if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp,
 279                             NULL) == 0)
 280                                 continue;
 281                 }
 282 #endif /* INET */
 283 #ifdef INET6
 284                 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET6) {
 285                         in6_purgeaddr(ifa);
 286                         /* ifp_addrhead is already updated */
 287                         continue;
 288                 }
 289 #endif /* INET6 */
 290                 TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
 291                 IFAFREE(ifa);
 292         }
 293
 294 #ifdef INET6
 295         /*
 296          * Remove all IPv6 kernel structs related to ifp.  This should be done
 297          * before removing routing entries below, since IPv6 interface direct
 298          * routes are expected to be removed by the IPv6-specific kernel API.
 299          * Otherwise, the kernel will detect some inconsistency and bark it.
 300          */
 301         in6_ifdetach(ifp);
 302 #endif
 303
 304         /*
 305          * Delete all remaining routes using this interface
 306          * Unfortuneatly the only way to do this is to slog through
 307          * the entire routing table looking for routes which point
 308          * to this interface...oh well...
 309          */
 310         for (i = 1; i <= AF_MAX; i++) {
 311                 if ((rnh = rt_tables[i]) == NULL)
 312                         continue;
 313                 (void) rnh->rnh_walktree(rnh, if_rtdel, ifp);
 314         }
 315
 316         /* Announce that the interface is gone. */
 317         rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
 318
 319         TAILQ_REMOVE(&ifnet, ifp, if_link);
 320         splx(s);
 321 }
 322
 323 /*
 324  * Delete Routes for a Network Interface
 325  *
 326  * Called for each routing entry via the rnh->rnh_walktree() call above
 327  * to delete all route entries referencing a detaching network interface.
 328  *
 329  * Arguments:
 330  *      rn      pointer to node in the routing table
 331  *      arg     argument passed to rnh->rnh_walktree() - detaching interface
 332  *
 333  * Returns:
 334  *      0       successful
 335  *      errno   failed - reason indicated
 336  *
 337  */
 338 static int
 339 if_rtdel(rn, arg)
 340         struct radix_node       *rn;
 341         void                    *arg;
 342 {
 343         struct rtentry  *rt = (struct rtentry *)rn;
 344         struct ifnet    *ifp = arg;
 345         int             err;
 346
 347         if (rt->rt_ifp == ifp) {
 348
 349                 /*
 350                  * Protect (sorta) against walktree recursion problems
 351                  * with cloned routes
 352                  */
 353                 if ((rt->rt_flags & RTF_UP) == 0)
 354                         return (0);
 355
 356                 err = rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway,
 357                                 rt_mask(rt), rt->rt_flags,
 358                                 (struct rtentry **) NULL);
 359                 if (err) {
 360                         log(LOG_WARNING, "if_rtdel: error %d\n", err);
 361                 }
 362         }
 363
 364         return (0);
 365 }
 366
 367 /*
 368  * Create a clone network interface.
 369  */
 370 int
 371 if_clone_create(name, len)
 372         char *name;
 373         int len;
 374 {
 375         struct if_clone *ifc;
 376         char *dp;
 377         int wildcard;
 378         int unit;
 379         int err;
 380
 381         ifc = if_clone_lookup(name, &unit);
 382         if (ifc == NULL)
 383                 return (EINVAL);
 384
 385         if (ifunit(name) != NULL)
 386                 return (EEXIST);
 387
 388         wildcard = (unit < 0);
 389
 390         err = (*ifc->ifc_create)(ifc, &unit);
 391         if (err != 0)
 392                 return (err);
 393
 394         /* In the wildcard case, we need to update the name. */
 395         if (wildcard) {
 396                 for (dp = name; *dp != '\0'; dp++);
 397                 if (snprintf(dp, len - (dp-name), "%d", unit) >
 398                     len - (dp-name) - 1) {
 399                         /*
 400                          * This can only be a programmer error and
 401                          * there's no straightforward way to recover if
 402                          * it happens.
 403                          */
 404                         panic("if_clone_create(): interface name too long");
 405                 }
 406
 407         }
 408
 409         return (0);
 410 }
 411
 412 /*
 413  * Destroy a clone network interface.
 414  */
 415 int
 416 if_clone_destroy(name)
 417         const char *name;
 418 {
 419         struct if_clone *ifc;
 420         struct ifnet *ifp;
 421
 422         ifc = if_clone_lookup(name, NULL);
 423         if (ifc == NULL)
 424                 return (EINVAL);
 425
 426         ifp = ifunit(name);
 427         if (ifp == NULL)
 428                 return (ENXIO);
 429
 430         if (ifc->ifc_destroy == NULL)
 431                 return (EOPNOTSUPP);
 432
 433         (*ifc->ifc_destroy)(ifp);
 434         return (0);
 435 }
 436
 437 /*
 438  * Look up a network interface cloner.
 439  */
 440 struct if_clone *
 441 if_clone_lookup(name, unitp)
 442         const char *name;
 443         int *unitp;
 444 {
 445         struct if_clone *ifc;
 446         const char *cp;
 447         int i;
 448
 449         for (ifc = LIST_FIRST(&if_cloners); ifc != NULL;) {
 450                 for (cp = name, i = 0; i < ifc->ifc_namelen; i++, cp++) {
 451                         if (ifc->ifc_name[i] != *cp)
 452                                 goto next_ifc;
 453                 }
 454                 goto found_name;
 455  next_ifc:
 456                 ifc = LIST_NEXT(ifc, ifc_list);
 457         }
 458
 459         /* No match. */
 460         return ((struct if_clone *)NULL);
 461
 462  found_name:
 463         if (*cp == '\0') {
 464                 i = -1;
 465         } else {
 466                 for (i = 0; *cp != '\0'; cp++) {
 467                         if (*cp < '0' || *cp > '9') {
 468                                 /* Bogus unit number. */
 469                                 return (NULL);
 470                         }
 471                         i = (i * 10) + (*cp - '0');
 472                 }
 473         }
 474
 475         if (unitp != NULL)
 476                 *unitp = i;
 477         return (ifc);
 478 }
 479
 480 /*
 481  * Register a network interface cloner.
 482  */
 483 void
 484 if_clone_attach(ifc)
 485         struct if_clone *ifc;
 486 {
 487
 488         LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
 489         if_cloners_count++;
 490 }
 491
 492 /*
 493  * Unregister a network interface cloner.
 494  */
 495 void
 496 if_clone_detach(ifc)
 497         struct if_clone *ifc;
 498 {
 499
 500         LIST_REMOVE(ifc, ifc_list);
 501         if_cloners_count--;
 502 }
 503
 504 /*
 505  * Provide list of interface cloners to userspace.
 506  */
 507 int
 508 if_clone_list(ifcr)
 509         struct if_clonereq *ifcr;
 510 {
 511         char outbuf[IFNAMSIZ], *dst;
 512         struct if_clone *ifc;
 513         int count, error = 0;
 514
 515         ifcr->ifcr_total = if_cloners_count;
 516         if ((dst = ifcr->ifcr_buffer) == NULL) {
 517                 /* Just asking how many there are. */
 518                 return (0);
 519         }
 520
 521         if (ifcr->ifcr_count < 0)
 522                 return (EINVAL);
 523
 524         count = (if_cloners_count < ifcr->ifcr_count) ?
 525             if_cloners_count : ifcr->ifcr_count;
 526
 527         for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0;
 528              ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) {
 529                 strncpy(outbuf, ifc->ifc_name, IFNAMSIZ);
 530                 outbuf[IFNAMSIZ - 1] = '\0';    /* sanity */
 531                 error = copyout(outbuf, dst, IFNAMSIZ);
 532                 if (error)
 533                         break;
 534         }
 535
 536         return (error);
 537 }
 538
 539 /*
 540  * Locate an interface based on a complete address.
 541  */
 542 /*ARGSUSED*/
 543 struct ifaddr *
 544 ifa_ifwithaddr(addr)
 545         struct sockaddr *addr;
 546 {
 547         struct ifnet *ifp;
 548         struct ifaddr *ifa;
 549
 550 #define equal(a1, a2) \
 551   (bcmp((caddr_t)(a1), (caddr_t)(a2), ((struct sockaddr *)(a1))->sa_len) == 0)
 552         TAILQ_FOREACH(ifp, &ifnet, if_link)
 553             TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 554                 if (ifa->ifa_addr->sa_family != addr->sa_family)
 555                         continue;
 556                 if (equal(addr, ifa->ifa_addr))
 557                         return (ifa);
 558                 if ((ifp->if_flags & IFF_BROADCAST) && ifa->ifa_broadaddr &&
 559                     /* IP6 doesn't have broadcast */
 560                     ifa->ifa_broadaddr->sa_len != 0 &&
 561                     equal(ifa->ifa_broadaddr, addr))
 562                         return (ifa);
 563         }
 564         return ((struct ifaddr *)0);
 565 }
 566 /*
 567  * Locate the point to point interface with a given destination address.
 568  */
 569 /*ARGSUSED*/
 570 struct ifaddr *
 571 ifa_ifwithdstaddr(addr)
 572         struct sockaddr *addr;
 573 {
 574         struct ifnet *ifp;
 575         struct ifaddr *ifa;
 576
 577         TAILQ_FOREACH(ifp, &ifnet, if_link)
 578             if (ifp->if_flags & IFF_POINTOPOINT)
 579                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 580                         if (ifa->ifa_addr->sa_family != addr->sa_family)
 581                                 continue;
 582                         if (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr))
 583                                 return (ifa);
 584         }
 585         return ((struct ifaddr *)0);
 586 }
 587
 588 /*
 589  * Find an interface on a specific network.  If many, choice
 590  * is most specific found.
 591  */
 592 struct ifaddr *
 593 ifa_ifwithnet(addr)
 594         struct sockaddr *addr;
 595 {
 596         struct ifnet *ifp;
 597         struct ifaddr *ifa;
 598         struct ifaddr *ifa_maybe = (struct ifaddr *) 0;
 599         u_int af = addr->sa_family;
 600         char *addr_data = addr->sa_data, *cplim;
 601
 602         /*
 603          * AF_LINK addresses can be looked up directly by their index number,
 604          * so do that if we can.
 605          */
 606         if (af == AF_LINK) {
 607             struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
 608             if (sdl->sdl_index && sdl->sdl_index <= if_index)
 609                 return (ifnet_addrs[sdl->sdl_index - 1]);
 610         }
 611
 612         /*
 613          * Scan though each interface, looking for ones that have
 614          * addresses in this address family.
 615          */
 616         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 617                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 618                         char *cp, *cp2, *cp3;
 619
 620                         if (ifa->ifa_addr->sa_family != af)
 621 next:                           continue;
 622                         if (af == AF_INET && ifp->if_flags & IFF_POINTOPOINT) {
 623                                 /*
 624                                  * This is a bit broken as it doesn't
 625                                  * take into account that the remote end may
 626                                  * be a single node in the network we are
 627                                  * looking for.
 628                                  * The trouble is that we don't know the
 629                                  * netmask for the remote end.
 630                                  */
 631                                 if (ifa->ifa_dstaddr != 0
 632                                     && equal(addr, ifa->ifa_dstaddr))
 633                                         return (ifa);
 634                         } else {
 635                                 /*
 636                                  * if we have a special address handler,
 637                                  * then use it instead of the generic one.
 638                                  */
 639                                 if (ifa->ifa_claim_addr) {
 640                                         if ((*ifa->ifa_claim_addr)(ifa, addr)) {
 641                                                 return (ifa);
 642                                         } else {
 643                                                 continue;
 644                                         }
 645                                 }
 646
 647                                 /*
 648                                  * Scan all the bits in the ifa's address.
 649                                  * If a bit dissagrees with what we are
 650                                  * looking for, mask it with the netmask
 651                                  * to see if it really matters.
 652                                  * (A byte at a time)
 653                                  */
 654                                 if (ifa->ifa_netmask == 0)
 655                                         continue;
 656                                 cp = addr_data;
 657                                 cp2 = ifa->ifa_addr->sa_data;
 658                                 cp3 = ifa->ifa_netmask->sa_data;
 659                                 cplim = ifa->ifa_netmask->sa_len
 660                                         + (char *)ifa->ifa_netmask;
 661                                 while (cp3 < cplim)
 662                                         if ((*cp++ ^ *cp2++) & *cp3++)
 663                                                 goto next; /* next address! */
 664                                 /*
 665                                  * If the netmask of what we just found
 666                                  * is more specific than what we had before
 667                                  * (if we had one) then remember the new one
 668                                  * before continuing to search
 669                                  * for an even better one.
 670                                  */
 671                                 if (ifa_maybe == 0 ||
 672                                     rn_refines((caddr_t)ifa->ifa_netmask,
 673                                     (caddr_t)ifa_maybe->ifa_netmask))
 674                                         ifa_maybe = ifa;
 675                         }
 676                 }
 677         }
 678         return (ifa_maybe);
 679 }
 680
 681 /*
 682  * Find an interface address specific to an interface best matching
 683  * a given address.
 684  */
 685 struct ifaddr *
 686 ifaof_ifpforaddr(addr, ifp)
 687         struct sockaddr *addr;
 688         struct ifnet *ifp;
 689 {
 690         struct ifaddr *ifa;
 691         char *cp, *cp2, *cp3;
 692         char *cplim;
 693         struct ifaddr *ifa_maybe = 0;
 694         u_int af = addr->sa_family;
 695
 696         if (af >= AF_MAX)
 697                 return (0);
 698         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 699                 if (ifa->ifa_addr->sa_family != af)
 700                         continue;
 701                 if (ifa_maybe == 0)
 702                         ifa_maybe = ifa;
 703                 if (ifa->ifa_netmask == 0) {
 704                         if (equal(addr, ifa->ifa_addr) ||
 705                             (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr)))
 706                                 return (ifa);
 707                         continue;
 708                 }
 709                 if (ifp->if_flags & IFF_POINTOPOINT) {
 710                         if (equal(addr, ifa->ifa_dstaddr))
 711                                 return (ifa);
 712                 } else {
 713                         cp = addr->sa_data;
 714                         cp2 = ifa->ifa_addr->sa_data;
 715                         cp3 = ifa->ifa_netmask->sa_data;
 716                         cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
 717                         for (; cp3 < cplim; cp3++)
 718                                 if ((*cp++ ^ *cp2++) & *cp3)
 719                                         break;
 720                         if (cp3 == cplim)
 721                                 return (ifa);
 722                 }
 723         }
 724         return (ifa_maybe);
 725 }
 726
 727 #include <net/route.h>
 728
 729 /*
 730  * Default action when installing a route with a Link Level gateway.
 731  * Lookup an appropriate real ifa to point to.
 732  * This should be moved to /sys/net/link.c eventually.
 733  */
 734 static void
 735 link_rtrequest(cmd, rt, info)
 736         int cmd;
 737         struct rtentry *rt;
 738         struct rt_addrinfo *info;
 739 {
 740         struct ifaddr *ifa;
 741         struct sockaddr *dst;
 742         struct ifnet *ifp;
 743
 744         if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) ||
 745             ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0))
 746                 return;
 747         ifa = ifaof_ifpforaddr(dst, ifp);
 748         if (ifa) {
 749                 IFAFREE(rt->rt_ifa);
 750                 rt->rt_ifa = ifa;
 751                 ifa->ifa_refcnt++;
 752                 if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
 753                         ifa->ifa_rtrequest(cmd, rt, info);
 754         }
 755 }
 756
 757 /*
 758  * Mark an interface down and notify protocols of
 759  * the transition.
 760  * NOTE: must be called at splnet or eqivalent.
 761  */
 762 void
 763 if_unroute(ifp, flag, fam)
 764         struct ifnet *ifp;
 765         int flag, fam;
 766 {
 767         struct ifaddr *ifa;
 768
 769         ifp->if_flags &= ~flag;
 770         getmicrotime(&ifp->if_lastchange);
 771         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
 772                 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
 773                         pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
 774         if_qflush(&ifp->if_snd);
 775         rt_ifmsg(ifp);
 776 }
 777
 778 /*
 779  * Mark an interface up and notify protocols of
 780  * the transition.
 781  * NOTE: must be called at splnet or eqivalent.
 782  */
 783 void
 784 if_route(ifp, flag, fam)
 785         struct ifnet *ifp;
 786         int flag, fam;
 787 {
 788         struct ifaddr *ifa;
 789
 790         ifp->if_flags |= flag;
 791         getmicrotime(&ifp->if_lastchange);
 792         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
 793                 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
 794                         pfctlinput(PRC_IFUP, ifa->ifa_addr);
 795         rt_ifmsg(ifp);
 796 #ifdef INET6
 797         in6_if_up(ifp);
 798 #endif
 799 }
 800
 801 /*
 802  * Mark an interface down and notify protocols of
 803  * the transition.
 804  * NOTE: must be called at splnet or eqivalent.
 805  */
 806 void
 807 if_down(ifp)
 808         struct ifnet *ifp;
 809 {
 810
 811         if_unroute(ifp, IFF_UP, AF_UNSPEC);
 812 }
 813
 814 /*
 815  * Mark an interface up and notify protocols of
 816  * the transition.
 817  * NOTE: must be called at splnet or eqivalent.
 818  */
 819 void
 820 if_up(ifp)
 821         struct ifnet *ifp;
 822 {
 823
 824         if_route(ifp, IFF_UP, AF_UNSPEC);
 825 }
 826
 827 /*
 828  * Flush an interface queue.
 829  */
 830 static void
 831 if_qflush(ifq)
 832         struct ifqueue *ifq;
 833 {
 834         struct mbuf *m, *n;
 835
 836         n = ifq->ifq_head;
 837         while ((m = n) != 0) {
 838                 n = m->m_act;
 839                 m_freem(m);
 840         }
 841         ifq->ifq_head = 0;
 842         ifq->ifq_tail = 0;
 843         ifq->ifq_len = 0;
 844 }
 845
 846 /*
 847  * Handle interface watchdog timer routines.  Called
 848  * from softclock, we decrement timers (if set) and
 849  * call the appropriate interface routine on expiration.
 850  */
 851 static void
 852 if_slowtimo(arg)
 853         void *arg;
 854 {
 855         struct ifnet *ifp;
 856         int s = splimp();
 857
 858         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 859                 if (ifp->if_timer == 0 || --ifp->if_timer)
 860                         continue;
 861                 if (ifp->if_watchdog)
 862                         (*ifp->if_watchdog)(ifp);
 863         }
 864         splx(s);
 865         timeout(if_slowtimo, (void *)0, hz / IFNET_SLOWHZ);
 866 }
 867
 868 /*
 869  * Map interface name to
 870  * interface structure pointer.
 871  */
 872 struct ifnet *
 873 ifunit(const char *name)
 874 {
 875         char namebuf[IFNAMSIZ + 1];
 876         const char *cp;
 877         struct ifnet *ifp;
 878         int unit;
 879         unsigned len, m;
 880         char c;
 881
 882         len = strlen(name);
 883         if (len < 2 || len > IFNAMSIZ)
 884                 return NULL;
 885         cp = name + len - 1;
 886         c = *cp;
 887         if (c < '0' || c > '9')
 888                 return NULL;            /* trailing garbage */
 889         unit = 0;
 890         m = 1;
 891         do {
 892                 if (cp == name)
 893                         return NULL;    /* no interface name */
 894                 unit += (c - '0') * m;
 895                 if (unit > 1000000)
 896                         return NULL;    /* number is unreasonable */
 897                 m *= 10;
 898                 c = *--cp;
 899         } while (c >= '0' && c <= '9');
 900         len = cp - name + 1;
 901         bcopy(name, namebuf, len);
 902         namebuf[len] = '\0';
 903         /*
 904          * Now search all the interfaces for this name/number
 905          */
 906         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 907                 if (strcmp(ifp->if_name, namebuf))
 908                         continue;
 909                 if (unit == ifp->if_unit)
 910                         break;
 911         }
 912         return (ifp);
 913 }
 914
 915
 916 /*
 917  * Map interface name in a sockaddr_dl to
 918  * interface structure pointer.
 919  */
 920 struct ifnet *
 921 if_withname(sa)
 922         struct sockaddr *sa;
 923 {
 924         char ifname[IFNAMSIZ+1];
 925         struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
 926
 927         if ( (sa->sa_family != AF_LINK) || (sdl->sdl_nlen == 0) ||
 928              (sdl->sdl_nlen > IFNAMSIZ) )
 929                 return NULL;
 930
 931         /*
 932          * ifunit wants a null-terminated name.  It may not be null-terminated
 933          * in the sockaddr.  We don't want to change the caller's sockaddr,
 934          * and there might not be room to put the trailing null anyway, so we
 935          * make a local copy that we know we can null terminate safely.
 936          */
 937
 938         bcopy(sdl->sdl_data, ifname, sdl->sdl_nlen);
 939         ifname[sdl->sdl_nlen] = '\0';
 940         return ifunit(ifname);
 941 }
 942
 943
 944 /*
 945  * Interface ioctls.
 946  */
 947 int
 948 ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td)
 949 {
 950         struct ifnet *ifp;
 951         struct ifreq *ifr;
 952         struct ifstat *ifs;
 953         int error;
 954         short oif_flags;
 955         int new_flags;
 956
 957         switch (cmd) {
 958
 959         case SIOCGIFCONF:
 960         case OSIOCGIFCONF:
 961                 return (ifconf(cmd, data));
 962         }
 963         ifr = (struct ifreq *)data;
 964
 965         switch (cmd) {
 966         case SIOCIFCREATE:
 967         case SIOCIFDESTROY:
 968                 if ((error = suser(td)) != 0)
 969                         return (error);
 970                 return ((cmd == SIOCIFCREATE) ?
 971                         if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name)) :
 972                         if_clone_destroy(ifr->ifr_name));
 973
 974         case SIOCIFGCLONERS:
 975                 return (if_clone_list((struct if_clonereq *)data));
 976         }
 977
 978         ifp = ifunit(ifr->ifr_name);
 979         if (ifp == 0)
 980                 return (ENXIO);
 981         switch (cmd) {
 982
 983         case SIOCGIFFLAGS:
 984                 ifr->ifr_flags = ifp->if_flags;
 985                 ifr->ifr_flagshigh = ifp->if_ipending >> 16;
 986                 break;
 987
 988         case SIOCGIFCAP:
 989                 ifr->ifr_reqcap = ifp->if_capabilities;
 990                 ifr->ifr_curcap = ifp->if_capenable;
 991                 break;
 992
 993         case SIOCGIFMETRIC:
 994                 ifr->ifr_metric = ifp->if_metric;
 995                 break;
 996
 997         case SIOCGIFMTU:
 998                 ifr->ifr_mtu = ifp->if_mtu;
 999                 break;
1000
1001         case SIOCGIFPHYS:
1002                 ifr->ifr_phys = ifp->if_physical;
1003                 break;
1004
1005         case SIOCSIFFLAGS:
1006                 error = suser(td);
1007                 if (error)
1008                         return (error);
1009                 new_flags = (ifr->ifr_flags & 0xffff) |
1010                     (ifr->ifr_flagshigh << 16);
1011                 if (ifp->if_flags & IFF_SMART) {
1012                         /* Smart drivers twiddle their own routes */
1013                 } else if (ifp->if_flags & IFF_UP &&
1014                     (new_flags & IFF_UP) == 0) {
1015                         int s = splimp();
1016                         if_down(ifp);
1017                         splx(s);
1018                 } else if (new_flags & IFF_UP &&
1019                     (ifp->if_flags & IFF_UP) == 0) {
1020                         int s = splimp();
1021                         if_up(ifp);
1022                         splx(s);
1023                 }
1024                 ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
1025                         (new_flags &~ IFF_CANTCHANGE);
1026                 ifp->if_ipending = (ifp->if_ipending & IFF_CANTCHANGE) |
1027                         (new_flags &~ IFF_CANTCHANGE);
1028                 if (new_flags & IFF_PPROMISC) {
1029                         /* Permanently promiscuous mode requested */
1030                         ifp->if_flags |= IFF_PROMISC;
1031                 } else if (ifp->if_pcount == 0) {
1032                         ifp->if_flags &= ~IFF_PROMISC;
1033                 }
1034                 if (ifp->if_ioctl)
1035                         (void) (*ifp->if_ioctl)(ifp, cmd, data);
1036                 getmicrotime(&ifp->if_lastchange);
1037                 break;
1038
1039         case SIOCSIFCAP:
1040                 error = suser(td);
1041                 if (error)
1042                         return (error);
1043                 if (ifr->ifr_reqcap & ~ifp->if_capabilities)
1044                         return (EINVAL);
1045                 (void) (*ifp->if_ioctl)(ifp, cmd, data);
1046                 break;
1047
1048         case SIOCSIFMETRIC:
1049                 error = suser(td);
1050                 if (error)
1051                         return (error);
1052                 ifp->if_metric = ifr->ifr_metric;
1053                 getmicrotime(&ifp->if_lastchange);
1054                 break;
1055
1056         case SIOCSIFPHYS:
1057                 error = suser(td);
1058                 if (error)
1059                         return error;
1060                 if (!ifp->if_ioctl)
1061                         return EOPNOTSUPP;
1062                 error = (*ifp->if_ioctl)(ifp, cmd, data);
1063                 if (error == 0)
1064                         getmicrotime(&ifp->if_lastchange);
1065                 return(error);
1066
1067         case SIOCSIFMTU:
1068         {
1069                 u_long oldmtu = ifp->if_mtu;
1070
1071                 error = suser(td);
1072                 if (error)
1073                         return (error);
1074                 if (ifp->if_ioctl == NULL)
1075                         return (EOPNOTSUPP);
1076                 if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU)
1077                         return (EINVAL);
1078                 error = (*ifp->if_ioctl)(ifp, cmd, data);
1079                 if (error == 0) {
1080                         getmicrotime(&ifp->if_lastchange);
1081                         rt_ifmsg(ifp);
1082                 }
1083                 /*
1084                  * If the link MTU changed, do network layer specific procedure.
1085                  */
1086                 if (ifp->if_mtu != oldmtu) {
1087 #ifdef INET6
1088                         nd6_setmtu(ifp);
1089 #endif
1090                 }
1091                 return (error);
1092         }
1093
1094         case SIOCADDMULTI:
1095         case SIOCDELMULTI:
1096                 error = suser(td);
1097                 if (error)
1098                         return (error);
1099
1100                 /* Don't allow group membership on non-multicast interfaces. */
1101                 if ((ifp->if_flags & IFF_MULTICAST) == 0)
1102                         return EOPNOTSUPP;
1103
1104                 /* Don't let users screw up protocols' entries. */
1105                 if (ifr->ifr_addr.sa_family != AF_LINK)
1106                         return EINVAL;
1107
1108                 if (cmd == SIOCADDMULTI) {
1109                         struct ifmultiaddr *ifma;
1110                         error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
1111                 } else {
1112                         error = if_delmulti(ifp, &ifr->ifr_addr);
1113                 }
1114                 if (error == 0)
1115                         getmicrotime(&ifp->if_lastchange);
1116                 return error;
1117
1118         case SIOCSIFPHYADDR:
1119         case SIOCDIFPHYADDR:
1120 #ifdef INET6
1121         case SIOCSIFPHYADDR_IN6:
1122 #endif
1123         case SIOCSLIFPHYADDR:
1124         case SIOCSIFMEDIA:
1125         case SIOCSIFGENERIC:
1126                 error = suser(td);
1127                 if (error)
1128                         return (error);
1129                 if (ifp->if_ioctl == 0)
1130                         return (EOPNOTSUPP);
1131                 error = (*ifp->if_ioctl)(ifp, cmd, data);
1132                 if (error == 0)
1133                         getmicrotime(&ifp->if_lastchange);
1134                 return error;
1135
1136         case SIOCGIFSTATUS:
1137                 ifs = (struct ifstat *)data;
1138                 ifs->ascii[0] = '\0';
1139
1140         case SIOCGIFPSRCADDR:
1141         case SIOCGIFPDSTADDR:
1142         case SIOCGLIFPHYADDR:
1143         case SIOCGIFMEDIA:
1144         case SIOCGIFGENERIC:
1145                 if (ifp->if_ioctl == 0)
1146                         return (EOPNOTSUPP);
1147                 return ((*ifp->if_ioctl)(ifp, cmd, data));
1148
1149         case SIOCSIFLLADDR:
1150                 error = suser(td);
1151                 if (error)
1152                         return (error);
1153                 return if_setlladdr(ifp,
1154                     ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len);
1155
1156         default:
1157                 oif_flags = ifp->if_flags;
1158                 if (so->so_proto == 0)
1159                         return (EOPNOTSUPP);
1160 #ifndef COMPAT_43
1161                 error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd,
1162                                                                  data,
1163                                                                  ifp, p));
1164 #else
1165             {
1166                 int ocmd = cmd;
1167
1168                 switch (cmd) {
1169
1170                 case SIOCSIFDSTADDR:
1171                 case SIOCSIFADDR:
1172                 case SIOCSIFBRDADDR:
1173                 case SIOCSIFNETMASK:
1174 #if BYTE_ORDER != BIG_ENDIAN
1175                         if (ifr->ifr_addr.sa_family == 0 &&
1176                             ifr->ifr_addr.sa_len < 16) {
1177                                 ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len;
1178                                 ifr->ifr_addr.sa_len = 16;
1179                         }
1180 #else
1181                         if (ifr->ifr_addr.sa_len == 0)
1182                                 ifr->ifr_addr.sa_len = 16;
1183 #endif
1184                         break;
1185
1186                 case OSIOCGIFADDR:
1187                         cmd = SIOCGIFADDR;
1188                         break;
1189
1190                 case OSIOCGIFDSTADDR:
1191                         cmd = SIOCGIFDSTADDR;
1192                         break;
1193
1194                 case OSIOCGIFBRDADDR:
1195                         cmd = SIOCGIFBRDADDR;
1196                         break;
1197
1198                 case OSIOCGIFNETMASK:
1199                         cmd = SIOCGIFNETMASK;
1200                 }
1201                 error =  ((*so->so_proto->pr_usrreqs->pru_control)
1202                                 (so, cmd, data, ifp, td));
1203                 switch (ocmd) {
1204
1205                 case OSIOCGIFADDR:
1206                 case OSIOCGIFDSTADDR:
1207                 case OSIOCGIFBRDADDR:
1208                 case OSIOCGIFNETMASK:
1209                         *(u_short *)&ifr->ifr_addr = ifr->ifr_addr.sa_family;
1210
1211                 }
1212             }
1213 #endif /* COMPAT_43 */
1214
1215                 if ((oif_flags ^ ifp->if_flags) & IFF_UP) {
1216 #ifdef INET6
1217                         DELAY(100);/* XXX: temporary workaround for fxp issue*/
1218                         if (ifp->if_flags & IFF_UP) {
1219                                 int s = splimp();
1220                                 in6_if_up(ifp);
1221                                 splx(s);
1222                         }
1223 #endif
1224                 }
1225                 return (error);
1226
1227         }
1228         return (0);
1229 }
1230
1231 /*
1232  * Set/clear promiscuous mode on interface ifp based on the truth value
1233  * of pswitch.  The calls are reference counted so that only the first
1234  * "on" request actually has an effect, as does the final "off" request.
1235  * Results are undefined if the "off" and "on" requests are not matched.
1236  */
1237 int
1238 ifpromisc(ifp, pswitch)
1239         struct ifnet *ifp;
1240         int pswitch;
1241 {
1242         struct ifreq ifr;
1243         int error;
1244         int oldflags;
1245
1246         oldflags = ifp->if_flags;
1247         if (ifp->if_ipending & IFF_PPROMISC) {
1248                 /* Do nothing if device is in permanently promiscuous mode */
1249                 ifp->if_pcount += pswitch ? 1 : -1;
1250                 return (0);
1251         }
1252         if (pswitch) {
1253                 /*
1254                  * If the device is not configured up, we cannot put it in
1255                  * promiscuous mode.
1256                  */
1257                 if ((ifp->if_flags & IFF_UP) == 0)
1258                         return (ENETDOWN);
1259                 if (ifp->if_pcount++ != 0)
1260                         return (0);
1261                 ifp->if_flags |= IFF_PROMISC;
1262                 log(LOG_INFO, "%s%d: promiscuous mode enabled\n",
1263                     ifp->if_name, ifp->if_unit);
1264         } else {
1265                 if (--ifp->if_pcount > 0)
1266                         return (0);
1267                 ifp->if_flags &= ~IFF_PROMISC;
1268                 log(LOG_INFO, "%s%d: promiscuous mode disabled\n",
1269                     ifp->if_name, ifp->if_unit);
1270         }
1271         ifr.ifr_flags = ifp->if_flags;
1272         ifr.ifr_flagshigh = ifp->if_ipending >> 16;
1273         error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
1274         if (error == 0)
1275                 rt_ifmsg(ifp);
1276         else
1277                 ifp->if_flags = oldflags;
1278         return error;
1279 }
1280
1281 /*
1282  * Return interface configuration
1283  * of system.  List may be used
1284  * in later ioctl's (above) to get
1285  * other information.
1286  */
1287 /*ARGSUSED*/
1288 static int
1289 ifconf(u_long cmd, caddr_t data)
1290 {
1291         struct ifconf *ifc = (struct ifconf *)data;
1292         struct ifnet *ifp;
1293         struct ifaddr *ifa;
1294         struct sockaddr *sa;
1295         struct ifreq ifr, *ifrp;
1296         int space = ifc->ifc_len, error = 0;
1297
1298         ifrp = ifc->ifc_req;
1299         TAILQ_FOREACH(ifp, &ifnet, if_link) {
1300                 char workbuf[64];
1301                 int ifnlen, addrs;
1302
1303                 if (space <= sizeof (ifr))
1304                         break;
1305                 ifnlen = snprintf(workbuf, sizeof(workbuf),
1306                     "%s%d", ifp->if_name, ifp->if_unit);
1307                 if(ifnlen + 1 > sizeof ifr.ifr_name) {
1308                         error = ENAMETOOLONG;
1309                         break;
1310                 } else {
1311                         strcpy(ifr.ifr_name, workbuf);
1312                 }
1313
1314                 addrs = 0;
1315                 ifa = ifp->if_addrhead.tqh_first;
1316                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1317                         if (space <= sizeof(ifr))
1318                                 break;
1319                         sa = ifa->ifa_addr;
1320                         if (curproc->p_ucred->cr_prison && prison_if(curthread, sa))
1321                                 continue;
1322                         addrs++;
1323 #ifdef COMPAT_43
1324                         if (cmd == OSIOCGIFCONF) {
1325                                 struct osockaddr *osa =
1326                                          (struct osockaddr *)&ifr.ifr_addr;
1327                                 ifr.ifr_addr = *sa;
1328                                 osa->sa_family = sa->sa_family;
1329                                 error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
1330                                                 sizeof (ifr));
1331                                 ifrp++;
1332                         } else
1333 #endif
1334                         if (sa->sa_len <= sizeof(*sa)) {
1335                                 ifr.ifr_addr = *sa;
1336                                 error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
1337                                                 sizeof (ifr));
1338                                 ifrp++;
1339                         } else {
1340                                 if (space < sizeof (ifr) + sa->sa_len -
1341                                             sizeof(*sa))
1342                                         break;
1343                                 space -= sa->sa_len - sizeof(*sa);
1344                                 error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
1345                                                 sizeof (ifr.ifr_name));
1346                                 if (error == 0)
1347                                     error = copyout((caddr_t)sa,
1348                                       (caddr_t)&ifrp->ifr_addr, sa->sa_len);
1349                                 ifrp = (struct ifreq *)
1350                                         (sa->sa_len + (caddr_t)&ifrp->ifr_addr);
1351                         }
1352                         if (error)
1353                                 break;
1354                         space -= sizeof (ifr);
1355                 }
1356                 if (error)
1357                         break;
1358                 if (!addrs) {
1359                         bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
1360                         error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
1361                             sizeof (ifr));
1362                         if (error)
1363                                 break;
1364                         space -= sizeof (ifr);
1365                         ifrp++;
1366                 }
1367         }
1368         ifc->ifc_len -= space;
1369         return (error);
1370 }
1371
1372 /*
1373  * Just like if_promisc(), but for all-multicast-reception mode.
1374  */
1375 int
1376 if_allmulti(ifp, onswitch)
1377         struct ifnet *ifp;
1378         int onswitch;
1379 {
1380         int error = 0;
1381         int s = splimp();
1382         struct ifreq ifr;
1383
1384         if (onswitch) {
1385                 if (ifp->if_amcount++ == 0) {
1386                         ifp->if_flags |= IFF_ALLMULTI;
1387                         ifr.ifr_flags = ifp->if_flags;
1388                         ifr.ifr_flagshigh = ifp->if_ipending >> 16;
1389                         error = ifp->if_ioctl(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
1390                 }
1391         } else {
1392                 if (ifp->if_amcount > 1) {
1393                         ifp->if_amcount--;
1394                 } else {
1395                         ifp->if_amcount = 0;
1396                         ifp->if_flags &= ~IFF_ALLMULTI;
1397                         ifr.ifr_flags = ifp->if_flags;
1398                         ifr.ifr_flagshigh = ifp->if_ipending >> 16;
1399                         error = ifp->if_ioctl(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
1400                 }
1401         }
1402         splx(s);
1403
1404         if (error == 0)
1405                 rt_ifmsg(ifp);
1406         return error;
1407 }
1408
1409 /*
1410  * Add a multicast listenership to the interface in question.
1411  * The link layer provides a routine which converts
1412  */
1413 int
1414 if_addmulti(ifp, sa, retifma)
1415         struct ifnet *ifp;      /* interface to manipulate */
1416         struct sockaddr *sa;    /* address to add */
1417         struct ifmultiaddr **retifma;
1418 {
1419         struct sockaddr *llsa, *dupsa;
1420         int error, s;
1421         struct ifmultiaddr *ifma;
1422
1423         /*
1424          * If the matching multicast address already exists
1425          * then don't add a new one, just add a reference
1426          */
1427         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1428                 if (equal(sa, ifma->ifma_addr)) {
1429                         ifma->ifma_refcount++;
1430                         if (retifma)
1431                                 *retifma = ifma;
1432                         return 0;
1433                 }
1434         }
1435
1436         /*
1437          * Give the link layer a chance to accept/reject it, and also
1438          * find out which AF_LINK address this maps to, if it isn't one
1439          * already.
1440          */
1441         if (ifp->if_resolvemulti) {
1442                 error = ifp->if_resolvemulti(ifp, &llsa, sa);
1443                 if (error) return error;
1444         } else {
1445                 llsa = 0;
1446         }
1447
1448         MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma, M_IFMADDR, M_WAITOK);
1449         MALLOC(dupsa, struct sockaddr *, sa->sa_len, M_IFMADDR, M_WAITOK);
1450         bcopy(sa, dupsa, sa->sa_len);
1451
1452         ifma->ifma_addr = dupsa;
1453         ifma->ifma_lladdr = llsa;
1454         ifma->ifma_ifp = ifp;
1455         ifma->ifma_refcount = 1;
1456         ifma->ifma_protospec = 0;
1457         rt_newmaddrmsg(RTM_NEWMADDR, ifma);
1458
1459         /*
1460          * Some network interfaces can scan the address list at
1461          * interrupt time; lock them out.
1462          */
1463         s = splimp();
1464         LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
1465         splx(s);
1466         *retifma = ifma;
1467
1468         if (llsa != 0) {
1469                 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1470                         if (equal(ifma->ifma_addr, llsa))
1471                                 break;
1472                 }
1473                 if (ifma) {
1474                         ifma->ifma_refcount++;
1475                 } else {
1476                         MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma,
1477                                M_IFMADDR, M_WAITOK);
1478                         MALLOC(dupsa, struct sockaddr *, llsa->sa_len,
1479                                M_IFMADDR, M_WAITOK);
1480                         bcopy(llsa, dupsa, llsa->sa_len);
1481                         ifma->ifma_addr = dupsa;
1482                         ifma->ifma_ifp = ifp;
1483                         ifma->ifma_refcount = 1;
1484                         s = splimp();
1485                         LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
1486                         splx(s);
1487                 }
1488         }
1489         /*
1490          * We are certain we have added something, so call down to the
1491          * interface to let them know about it.
1492          */
1493         s = splimp();
1494         ifp->if_ioctl(ifp, SIOCADDMULTI, 0);
1495         splx(s);
1496
1497         return 0;
1498 }
1499
1500 /*
1501  * Remove a reference to a multicast address on this interface.  Yell
1502  * if the request does not match an existing membership.
1503  */
1504 int
1505 if_delmulti(ifp, sa)
1506         struct ifnet *ifp;
1507         struct sockaddr *sa;
1508 {
1509         struct ifmultiaddr *ifma;
1510         int s;
1511
1512         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
1513                 if (equal(sa, ifma->ifma_addr))
1514                         break;
1515         if (ifma == 0)
1516                 return ENOENT;
1517
1518         if (ifma->ifma_refcount > 1) {
1519                 ifma->ifma_refcount--;
1520                 return 0;
1521         }
1522
1523         rt_newmaddrmsg(RTM_DELMADDR, ifma);
1524         sa = ifma->ifma_lladdr;
1525         s = splimp();
1526         LIST_REMOVE(ifma, ifma_link);
1527         /*
1528          * Make sure the interface driver is notified
1529          * in the case of a link layer mcast group being left.
1530          */
1531         if (ifma->ifma_addr->sa_family == AF_LINK && sa == 0)
1532                 ifp->if_ioctl(ifp, SIOCDELMULTI, 0);
1533         splx(s);
1534         free(ifma->ifma_addr, M_IFMADDR);
1535         free(ifma, M_IFMADDR);
1536         if (sa == 0)
1537                 return 0;
1538
1539         /*
1540          * Now look for the link-layer address which corresponds to
1541          * this network address.  It had been squirreled away in
1542          * ifma->ifma_lladdr for this purpose (so we don't have
1543          * to call ifp->if_resolvemulti() again), and we saved that
1544          * value in sa above.  If some nasty deleted the
1545          * link-layer address out from underneath us, we can deal because
1546          * the address we stored was is not the same as the one which was
1547          * in the record for the link-layer address.  (So we don't complain
1548          * in that case.)
1549          */
1550         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
1551                 if (equal(sa, ifma->ifma_addr))
1552                         break;
1553         if (ifma == 0)
1554                 return 0;
1555
1556         if (ifma->ifma_refcount > 1) {
1557                 ifma->ifma_refcount--;
1558                 return 0;
1559         }
1560
1561         s = splimp();
1562         LIST_REMOVE(ifma, ifma_link);
1563         ifp->if_ioctl(ifp, SIOCDELMULTI, 0);
1564         splx(s);
1565         free(ifma->ifma_addr, M_IFMADDR);
1566         free(sa, M_IFMADDR);
1567         free(ifma, M_IFMADDR);
1568
1569         return 0;
1570 }
1571
1572 /*
1573  * Set the link layer address on an interface.
1574  *
1575  * At this time we only support certain types of interfaces,
1576  * and we don't allow the length of the address to change.
1577  */
1578 int
1579 if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len)
1580 {
1581         struct sockaddr_dl *sdl;
1582         struct ifaddr *ifa;
1583         struct ifreq ifr;
1584
1585         ifa = ifnet_addrs[ifp->if_index - 1];
1586         if (ifa == NULL)
1587                 return (EINVAL);
1588         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
1589         if (sdl == NULL)
1590                 return (EINVAL);
1591         if (len != sdl->sdl_alen)       /* don't allow length to change */
1592                 return (EINVAL);
1593         switch (ifp->if_type) {
1594         case IFT_ETHER:                 /* these types use struct arpcom */
1595         case IFT_FDDI:
1596         case IFT_XETHER:
1597         case IFT_ISO88025:
1598         case IFT_L2VLAN:
1599                 bcopy(lladdr, ((struct arpcom *)ifp->if_softc)->ac_enaddr, len);
1600                 /* FALLTHROUGH */
1601         case IFT_ARCNET:
1602                 bcopy(lladdr, LLADDR(sdl), len);
1603                 break;
1604         default:
1605                 return (ENODEV);
1606         }
1607         /*
1608          * If the interface is already up, we need
1609          * to re-init it in order to reprogram its
1610          * address filter.
1611          */
1612         if ((ifp->if_flags & IFF_UP) != 0) {
1613                 ifp->if_flags &= ~IFF_UP;
1614                 ifr.ifr_flags = ifp->if_flags;
1615                 ifr.ifr_flagshigh = ifp->if_ipending >> 16;
1616                 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
1617                 ifp->if_flags |= IFF_UP;
1618                 ifr.ifr_flags = ifp->if_flags;
1619                 ifr.ifr_flagshigh = ifp->if_ipending >> 16;
1620                 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
1621 #ifdef INET
1622                 /*
1623                  * Also send gratuitous ARPs to notify other nodes about
1624                  * the address change.
1625                  */
1626                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1627                         if (ifa->ifa_addr != NULL &&
1628                             ifa->ifa_addr->sa_family == AF_INET)
1629                                 arp_ifinit(ifp, ifa);
1630                 }
1631 #endif
1632         }
1633         return (0);
1634 }
1635
1636 struct ifmultiaddr *
1637 ifmaof_ifpforaddr(sa, ifp)
1638         struct sockaddr *sa;
1639         struct ifnet *ifp;
1640 {
1641         struct ifmultiaddr *ifma;
1642
1643         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
1644                 if (equal(ifma->ifma_addr, sa))
1645                         break;
1646
1647         return ifma;
1648 }
1649
1650 int
1651 if_printf(struct ifnet *ifp, const char *fmt, ...)
1652 {
1653         va_list ap;
1654         int retval;
1655
1656         retval = printf("%s%d: ", ifp->if_name, ifp->if_unit);
1657         va_start(ap, fmt);
1658         retval += vprintf(fmt, ap);
1659         va_end(ap);
1660         return (retval);
1661 }
1662
1663 SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers");
1664 SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management");