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