sys/net/if.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1980, 1986, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)if.c        8.5 (Berkeley) 1/9/95
  32  * $FreeBSD$
  33  */
  34
  35 #include "opt_compat.h"
  36 #include "opt_inet6.h"
  37 #include "opt_inet.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/types.h>
  41 #include <sys/conf.h>
  42 #include <sys/malloc.h>
  43 #include <sys/sbuf.h>
  44 #include <sys/bus.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/systm.h>
  47 #include <sys/priv.h>
  48 #include <sys/proc.h>
  49 #include <sys/socket.h>
  50 #include <sys/socketvar.h>
  51 #include <sys/protosw.h>
  52 #include <sys/kernel.h>
  53 #include <sys/lock.h>
  54 #include <sys/refcount.h>
  55 #include <sys/module.h>
  56 #include <sys/rwlock.h>
  57 #include <sys/sockio.h>
  58 #include <sys/syslog.h>
  59 #include <sys/sysctl.h>
  60 #include <sys/taskqueue.h>
  61 #include <sys/domain.h>
  62 #include <sys/jail.h>
  63 #include <sys/priv.h>
  64
  65 #include <machine/stdarg.h>
  66 #include <vm/uma.h>
  67
  68 #include <net/bpf.h>
  69 #include <net/ethernet.h>
  70 #include <net/if.h>
  71 #include <net/if_arp.h>
  72 #include <net/if_clone.h>
  73 #include <net/if_dl.h>
  74 #include <net/if_types.h>
  75 #include <net/if_var.h>
  76 #include <net/if_media.h>
  77 #include <net/if_vlan_var.h>
  78 #include <net/radix.h>
  79 #include <net/route.h>
  80 #include <net/vnet.h>
  81
  82 #if defined(INET) || defined(INET6)
  83 #include <net/ethernet.h>
  84 #include <netinet/in.h>
  85 #include <netinet/in_var.h>
  86 #include <netinet/ip.h>
  87 #include <netinet/ip_carp.h>
  88 #ifdef INET
  89 #include <netinet/if_ether.h>
  90 #endif /* INET */
  91 #ifdef INET6
  92 #include <netinet6/in6_var.h>
  93 #include <netinet6/in6_ifattach.h>
  94 #endif /* INET6 */
  95 #endif /* INET || INET6 */
  96
  97 #include <security/mac/mac_framework.h>
  98
  99 #ifdef COMPAT_FREEBSD32
 100 #include <sys/mount.h>
 101 #include <compat/freebsd32/freebsd32.h>
 102 #endif
 103
 104 SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers");
 105 SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management");
 106
 107 SYSCTL_INT(_net_link, OID_AUTO, ifqmaxlen, CTLFLAG_RDTUN,
 108     &ifqmaxlen, 0, "max send queue size");
 109
 110 /* Log link state change events */
 111 static int log_link_state_change = 1;
 112
 113 SYSCTL_INT(_net_link, OID_AUTO, log_link_state_change, CTLFLAG_RW,
 114         &log_link_state_change, 0,
 115         "log interface link state change events");
 116
 117 /* Log promiscuous mode change events */
 118 static int log_promisc_mode_change = 1;
 119
 120 SYSCTL_INT(_net_link, OID_AUTO, log_promisc_mode_change, CTLFLAG_RDTUN,
 121         &log_promisc_mode_change, 1,
 122         "log promiscuous mode change events");
 123
 124 /* Interface description */
 125 static unsigned int ifdescr_maxlen = 1024;
 126 SYSCTL_UINT(_net, OID_AUTO, ifdescr_maxlen, CTLFLAG_RW,
 127         &ifdescr_maxlen, 0,
 128         "administrative maximum length for interface description");
 129
 130 static MALLOC_DEFINE(M_IFDESCR, "ifdescr", "ifnet descriptions");
 131
 132 /* global sx for non-critical path ifdescr */
 133 static struct sx ifdescr_sx;
 134 SX_SYSINIT(ifdescr_sx, &ifdescr_sx, "ifnet descr");
 135
 136 void    (*bridge_linkstate_p)(struct ifnet *ifp);
 137 void    (*ng_ether_link_state_p)(struct ifnet *ifp, int state);
 138 void    (*lagg_linkstate_p)(struct ifnet *ifp, int state);
 139 /* These are external hooks for CARP. */
 140 void    (*carp_linkstate_p)(struct ifnet *ifp);
 141 void    (*carp_demote_adj_p)(int, char *);
 142 int     (*carp_master_p)(struct ifaddr *);
 143 #if defined(INET) || defined(INET6)
 144 int     (*carp_forus_p)(struct ifnet *ifp, u_char *dhost);
 145 int     (*carp_output_p)(struct ifnet *ifp, struct mbuf *m,
 146     const struct sockaddr *sa);
 147 int     (*carp_ioctl_p)(struct ifreq *, u_long, struct thread *);
 148 int     (*carp_attach_p)(struct ifaddr *, int);
 149 void    (*carp_detach_p)(struct ifaddr *, bool);
 150 #endif
 151 #ifdef INET
 152 int     (*carp_iamatch_p)(struct ifaddr *, uint8_t **);
 153 #endif
 154 #ifdef INET6
 155 struct ifaddr *(*carp_iamatch6_p)(struct ifnet *ifp, struct in6_addr *taddr6);
 156 caddr_t (*carp_macmatch6_p)(struct ifnet *ifp, struct mbuf *m,
 157     const struct in6_addr *taddr);
 158 #endif
 159
 160 struct mbuf *(*tbr_dequeue_ptr)(struct ifaltq *, int) = NULL;
 161
 162 /*
 163  * XXX: Style; these should be sorted alphabetically, and unprototyped
 164  * static functions should be prototyped. Currently they are sorted by
 165  * declaration order.
 166  */
 167 static void     if_attachdomain(void *);
 168 static void     if_attachdomain1(struct ifnet *);
 169 static int      ifconf(u_long, caddr_t);
 170 static void     if_freemulti(struct ifmultiaddr *);
 171 static void     if_grow(void);
 172 static void     if_input_default(struct ifnet *, struct mbuf *);
 173 static int      if_requestencap_default(struct ifnet *, struct if_encap_req *);
 174 static void     if_route(struct ifnet *, int flag, int fam);
 175 static int      if_setflag(struct ifnet *, int, int, int *, int);
 176 static int      if_transmit(struct ifnet *ifp, struct mbuf *m);
 177 static void     if_unroute(struct ifnet *, int flag, int fam);
 178 static void     link_rtrequest(int, struct rtentry *, struct rt_addrinfo *);
 179 static int      ifhwioctl(u_long, struct ifnet *, caddr_t, struct thread *);
 180 static int      if_delmulti_locked(struct ifnet *, struct ifmultiaddr *, int);
 181 static void     do_link_state_change(void *, int);
 182 static int      if_getgroup(struct ifgroupreq *, struct ifnet *);
 183 static int      if_getgroupmembers(struct ifgroupreq *);
 184 static void     if_delgroups(struct ifnet *);
 185 static void     if_attach_internal(struct ifnet *, int, struct if_clone *);
 186 static int      if_detach_internal(struct ifnet *, int, struct if_clone **);
 187 #ifdef VIMAGE
 188 static void     if_vmove(struct ifnet *, struct vnet *);
 189 #endif
 190
 191 #ifdef INET6
 192 /*
 193  * XXX: declare here to avoid to include many inet6 related files..
 194  * should be more generalized?
 195  */
 196 extern void     nd6_setmtu(struct ifnet *);
 197 #endif
 198
 199 /* ipsec helper hooks */
 200 VNET_DEFINE(struct hhook_head *, ipsec_hhh_in[HHOOK_IPSEC_COUNT]);
 201 VNET_DEFINE(struct hhook_head *, ipsec_hhh_out[HHOOK_IPSEC_COUNT]);
 202
 203 VNET_DEFINE(int, if_index);
 204 int     ifqmaxlen = IFQ_MAXLEN;
 205 VNET_DEFINE(struct ifnethead, ifnet);   /* depend on static init XXX */
 206 VNET_DEFINE(struct ifgrouphead, ifg_head);
 207
 208 static VNET_DEFINE(int, if_indexlim) = 8;
 209
 210 /* Table of ifnet by index. */
 211 VNET_DEFINE(struct ifnet **, ifindex_table);
 212
 213 #define V_if_indexlim           VNET(if_indexlim)
 214 #define V_ifindex_table         VNET(ifindex_table)
 215
 216 /*
 217  * The global network interface list (V_ifnet) and related state (such as
 218  * if_index, if_indexlim, and ifindex_table) are protected by an sxlock and
 219  * an rwlock.  Either may be acquired shared to stablize the list, but both
 220  * must be acquired writable to modify the list.  This model allows us to
 221  * both stablize the interface list during interrupt thread processing, but
 222  * also to stablize it over long-running ioctls, without introducing priority
 223  * inversions and deadlocks.
 224  */
 225 struct rwlock ifnet_rwlock;
 226 RW_SYSINIT_FLAGS(ifnet_rw, &ifnet_rwlock, "ifnet_rw", RW_RECURSE);
 227 struct sx ifnet_sxlock;
 228 SX_SYSINIT_FLAGS(ifnet_sx, &ifnet_sxlock, "ifnet_sx", SX_RECURSE);
 229
 230 /*
 231  * The allocation of network interfaces is a rather non-atomic affair; we
 232  * need to select an index before we are ready to expose the interface for
 233  * use, so will use this pointer value to indicate reservation.
 234  */
 235 #define IFNET_HOLD      (void *)(uintptr_t)(-1)
 236
 237 static  if_com_alloc_t *if_com_alloc[256];
 238 static  if_com_free_t *if_com_free[256];
 239
 240 static MALLOC_DEFINE(M_IFNET, "ifnet", "interface internals");
 241 MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
 242 MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
 243
 244 struct ifnet *
 245 ifnet_byindex_locked(u_short idx)
 246 {
 247
 248         if (idx > V_if_index)
 249                 return (NULL);
 250         if (V_ifindex_table[idx] == IFNET_HOLD)
 251                 return (NULL);
 252         return (V_ifindex_table[idx]);
 253 }
 254
 255 struct ifnet *
 256 ifnet_byindex(u_short idx)
 257 {
 258         struct ifnet *ifp;
 259
 260         IFNET_RLOCK_NOSLEEP();
 261         ifp = ifnet_byindex_locked(idx);
 262         IFNET_RUNLOCK_NOSLEEP();
 263         return (ifp);
 264 }
 265
 266 struct ifnet *
 267 ifnet_byindex_ref(u_short idx)
 268 {
 269         struct ifnet *ifp;
 270
 271         IFNET_RLOCK_NOSLEEP();
 272         ifp = ifnet_byindex_locked(idx);
 273         if (ifp == NULL || (ifp->if_flags & IFF_DYING)) {
 274                 IFNET_RUNLOCK_NOSLEEP();
 275                 return (NULL);
 276         }
 277         if_ref(ifp);
 278         IFNET_RUNLOCK_NOSLEEP();
 279         return (ifp);
 280 }
 281
 282 /*
 283  * Allocate an ifindex array entry; return 0 on success or an error on
 284  * failure.
 285  */
 286 static u_short
 287 ifindex_alloc(void)
 288 {
 289         u_short idx;
 290
 291         IFNET_WLOCK_ASSERT();
 292 retry:
 293         /*
 294          * Try to find an empty slot below V_if_index.  If we fail, take the
 295          * next slot.
 296          */
 297         for (idx = 1; idx <= V_if_index; idx++) {
 298                 if (V_ifindex_table[idx] == NULL)
 299                         break;
 300         }
 301
 302         /* Catch if_index overflow. */
 303         if (idx >= V_if_indexlim) {
 304                 if_grow();
 305                 goto retry;
 306         }
 307         if (idx > V_if_index)
 308                 V_if_index = idx;
 309         return (idx);
 310 }
 311
 312 static void
 313 ifindex_free_locked(u_short idx)
 314 {
 315
 316         IFNET_WLOCK_ASSERT();
 317
 318         V_ifindex_table[idx] = NULL;
 319         while (V_if_index > 0 &&
 320             V_ifindex_table[V_if_index] == NULL)
 321                 V_if_index--;
 322 }
 323
 324 static void
 325 ifindex_free(u_short idx)
 326 {
 327
 328         IFNET_WLOCK();
 329         ifindex_free_locked(idx);
 330         IFNET_WUNLOCK();
 331 }
 332
 333 static void
 334 ifnet_setbyindex_locked(u_short idx, struct ifnet *ifp)
 335 {
 336
 337         IFNET_WLOCK_ASSERT();
 338
 339         V_ifindex_table[idx] = ifp;
 340 }
 341
 342 static void
 343 ifnet_setbyindex(u_short idx, struct ifnet *ifp)
 344 {
 345
 346         IFNET_WLOCK();
 347         ifnet_setbyindex_locked(idx, ifp);
 348         IFNET_WUNLOCK();
 349 }
 350
 351 struct ifaddr *
 352 ifaddr_byindex(u_short idx)
 353 {
 354         struct ifnet *ifp;
 355         struct ifaddr *ifa = NULL;
 356
 357         IFNET_RLOCK_NOSLEEP();
 358         ifp = ifnet_byindex_locked(idx);
 359         if (ifp != NULL && (ifa = ifp->if_addr) != NULL)
 360                 ifa_ref(ifa);
 361         IFNET_RUNLOCK_NOSLEEP();
 362         return (ifa);
 363 }
 364
 365 /*
 366  * Network interface utility routines.
 367  *
 368  * Routines with ifa_ifwith* names take sockaddr *'s as
 369  * parameters.
 370  */
 371
 372 static void
 373 vnet_if_init(const void *unused __unused)
 374 {
 375
 376         TAILQ_INIT(&V_ifnet);
 377         TAILQ_INIT(&V_ifg_head);
 378         IFNET_WLOCK();
 379         if_grow();                              /* create initial table */
 380         IFNET_WUNLOCK();
 381         vnet_if_clone_init();
 382 }
 383 VNET_SYSINIT(vnet_if_init, SI_SUB_INIT_IF, SI_ORDER_SECOND, vnet_if_init,
 384     NULL);
 385
 386 #ifdef VIMAGE
 387 static void
 388 vnet_if_uninit(const void *unused __unused)
 389 {
 390
 391         VNET_ASSERT(TAILQ_EMPTY(&V_ifnet), ("%s:%d tailq &V_ifnet=%p "
 392             "not empty", __func__, __LINE__, &V_ifnet));
 393         VNET_ASSERT(TAILQ_EMPTY(&V_ifg_head), ("%s:%d tailq &V_ifg_head=%p "
 394             "not empty", __func__, __LINE__, &V_ifg_head));
 395
 396         free((caddr_t)V_ifindex_table, M_IFNET);
 397 }
 398 VNET_SYSUNINIT(vnet_if_uninit, SI_SUB_INIT_IF, SI_ORDER_FIRST,
 399     vnet_if_uninit, NULL);
 400
 401 static void
 402 vnet_if_return(const void *unused __unused)
 403 {
 404         struct ifnet *ifp, *nifp;
 405
 406         /* Return all inherited interfaces to their parent vnets. */
 407         TAILQ_FOREACH_SAFE(ifp, &V_ifnet, if_link, nifp) {
 408                 if (ifp->if_home_vnet != ifp->if_vnet)
 409                         if_vmove(ifp, ifp->if_home_vnet);
 410         }
 411 }
 412 VNET_SYSUNINIT(vnet_if_return, SI_SUB_VNET_DONE, SI_ORDER_ANY,
 413     vnet_if_return, NULL);
 414 #endif
 415
 416 static void
 417 if_grow(void)
 418 {
 419         int oldlim;
 420         u_int n;
 421         struct ifnet **e;
 422
 423         IFNET_WLOCK_ASSERT();
 424         oldlim = V_if_indexlim;
 425         IFNET_WUNLOCK();
 426         n = (oldlim << 1) * sizeof(*e);
 427         e = malloc(n, M_IFNET, M_WAITOK | M_ZERO);
 428         IFNET_WLOCK();
 429         if (V_if_indexlim != oldlim) {
 430                 free(e, M_IFNET);
 431                 return;
 432         }
 433         if (V_ifindex_table != NULL) {
 434                 memcpy((caddr_t)e, (caddr_t)V_ifindex_table, n/2);
 435                 free((caddr_t)V_ifindex_table, M_IFNET);
 436         }
 437         V_if_indexlim <<= 1;
 438         V_ifindex_table = e;
 439 }
 440
 441 /*
 442  * Allocate a struct ifnet and an index for an interface.  A layer 2
 443  * common structure will also be allocated if an allocation routine is
 444  * registered for the passed type.
 445  */
 446 struct ifnet *
 447 if_alloc(u_char type)
 448 {
 449         struct ifnet *ifp;
 450         u_short idx;
 451
 452         ifp = malloc(sizeof(struct ifnet), M_IFNET, M_WAITOK|M_ZERO);
 453         IFNET_WLOCK();
 454         idx = ifindex_alloc();
 455         ifnet_setbyindex_locked(idx, IFNET_HOLD);
 456         IFNET_WUNLOCK();
 457         ifp->if_index = idx;
 458         ifp->if_type = type;
 459         ifp->if_alloctype = type;
 460 #ifdef VIMAGE
 461         ifp->if_vnet = curvnet;
 462 #endif
 463         if (if_com_alloc[type] != NULL) {
 464                 ifp->if_l2com = if_com_alloc[type](type, ifp);
 465                 if (ifp->if_l2com == NULL) {
 466                         free(ifp, M_IFNET);
 467                         ifindex_free(idx);
 468                         return (NULL);
 469                 }
 470         }
 471
 472         IF_ADDR_LOCK_INIT(ifp);
 473         TASK_INIT(&ifp->if_linktask, 0, do_link_state_change, ifp);
 474         ifp->if_afdata_initialized = 0;
 475         IF_AFDATA_LOCK_INIT(ifp);
 476         TAILQ_INIT(&ifp->if_addrhead);
 477         TAILQ_INIT(&ifp->if_multiaddrs);
 478         TAILQ_INIT(&ifp->if_groups);
 479 #ifdef MAC
 480         mac_ifnet_init(ifp);
 481 #endif
 482         ifq_init(&ifp->if_snd, ifp);
 483
 484         refcount_init(&ifp->if_refcount, 1);    /* Index reference. */
 485         for (int i = 0; i < IFCOUNTERS; i++)
 486                 ifp->if_counters[i] = counter_u64_alloc(M_WAITOK);
 487         ifp->if_get_counter = if_get_counter_default;
 488         ifnet_setbyindex(ifp->if_index, ifp);
 489         return (ifp);
 490 }
 491
 492 /*
 493  * Do the actual work of freeing a struct ifnet, and layer 2 common
 494  * structure.  This call is made when the last reference to an
 495  * interface is released.
 496  */
 497 static void
 498 if_free_internal(struct ifnet *ifp)
 499 {
 500
 501         KASSERT((ifp->if_flags & IFF_DYING),
 502             ("if_free_internal: interface not dying"));
 503
 504         if (if_com_free[ifp->if_alloctype] != NULL)
 505                 if_com_free[ifp->if_alloctype](ifp->if_l2com,
 506                     ifp->if_alloctype);
 507
 508 #ifdef MAC
 509         mac_ifnet_destroy(ifp);
 510 #endif /* MAC */
 511         if (ifp->if_description != NULL)
 512                 free(ifp->if_description, M_IFDESCR);
 513         IF_AFDATA_DESTROY(ifp);
 514         IF_ADDR_LOCK_DESTROY(ifp);
 515         ifq_delete(&ifp->if_snd);
 516
 517         for (int i = 0; i < IFCOUNTERS; i++)
 518                 counter_u64_free(ifp->if_counters[i]);
 519
 520         free(ifp, M_IFNET);
 521 }
 522
 523 /*
 524  * Deregister an interface and free the associated storage.
 525  */
 526 void
 527 if_free(struct ifnet *ifp)
 528 {
 529
 530         ifp->if_flags |= IFF_DYING;                     /* XXX: Locking */
 531
 532         CURVNET_SET_QUIET(ifp->if_vnet);
 533         IFNET_WLOCK();
 534         KASSERT(ifp == ifnet_byindex_locked(ifp->if_index),
 535             ("%s: freeing unallocated ifnet", ifp->if_xname));
 536
 537         ifindex_free_locked(ifp->if_index);
 538         IFNET_WUNLOCK();
 539
 540         if (refcount_release(&ifp->if_refcount))
 541                 if_free_internal(ifp);
 542         CURVNET_RESTORE();
 543 }
 544
 545 /*
 546  * Interfaces to keep an ifnet type-stable despite the possibility of the
 547  * driver calling if_free().  If there are additional references, we defer
 548  * freeing the underlying data structure.
 549  */
 550 void
 551 if_ref(struct ifnet *ifp)
 552 {
 553
 554         /* We don't assert the ifnet list lock here, but arguably should. */
 555         refcount_acquire(&ifp->if_refcount);
 556 }
 557
 558 void
 559 if_rele(struct ifnet *ifp)
 560 {
 561
 562         if (!refcount_release(&ifp->if_refcount))
 563                 return;
 564         if_free_internal(ifp);
 565 }
 566
 567 void
 568 ifq_init(struct ifaltq *ifq, struct ifnet *ifp)
 569 {
 570
 571         mtx_init(&ifq->ifq_mtx, ifp->if_xname, "if send queue", MTX_DEF);
 572
 573         if (ifq->ifq_maxlen == 0)
 574                 ifq->ifq_maxlen = ifqmaxlen;
 575
 576         ifq->altq_type = 0;
 577         ifq->altq_disc = NULL;
 578         ifq->altq_flags &= ALTQF_CANTCHANGE;
 579         ifq->altq_tbr  = NULL;
 580         ifq->altq_ifp  = ifp;
 581 }
 582
 583 void
 584 ifq_delete(struct ifaltq *ifq)
 585 {
 586         mtx_destroy(&ifq->ifq_mtx);
 587 }
 588
 589 /*
 590  * Perform generic interface initialization tasks and attach the interface
 591  * to the list of "active" interfaces.  If vmove flag is set on entry
 592  * to if_attach_internal(), perform only a limited subset of initialization
 593  * tasks, given that we are moving from one vnet to another an ifnet which
 594  * has already been fully initialized.
 595  *
 596  * Note that if_detach_internal() removes group membership unconditionally
 597  * even when vmove flag is set, and if_attach_internal() adds only IFG_ALL.
 598  * Thus, when if_vmove() is applied to a cloned interface, group membership
 599  * is lost while a cloned one always joins a group whose name is
 600  * ifc->ifc_name.  To recover this after if_detach_internal() and
 601  * if_attach_internal(), the cloner should be specified to
 602  * if_attach_internal() via ifc.  If it is non-NULL, if_attach_internal()
 603  * attempts to join a group whose name is ifc->ifc_name.
 604  *
 605  * XXX:
 606  *  - The decision to return void and thus require this function to
 607  *    succeed is questionable.
 608  *  - We should probably do more sanity checking.  For instance we don't
 609  *    do anything to insure if_xname is unique or non-empty.
 610  */
 611 void
 612 if_attach(struct ifnet *ifp)
 613 {
 614
 615         if_attach_internal(ifp, 0, NULL);
 616 }
 617
 618 /*
 619  * Compute the least common TSO limit.
 620  */
 621 void
 622 if_hw_tsomax_common(if_t ifp, struct ifnet_hw_tsomax *pmax)
 623 {
 624         /*
 625          * 1) If there is no limit currently, take the limit from
 626          * the network adapter.
 627          *
 628          * 2) If the network adapter has a limit below the current
 629          * limit, apply it.
 630          */
 631         if (pmax->tsomaxbytes == 0 || (ifp->if_hw_tsomax != 0 &&
 632             ifp->if_hw_tsomax < pmax->tsomaxbytes)) {
 633                 pmax->tsomaxbytes = ifp->if_hw_tsomax;
 634         }
 635         if (pmax->tsomaxsegcount == 0 || (ifp->if_hw_tsomaxsegcount != 0 &&
 636             ifp->if_hw_tsomaxsegcount < pmax->tsomaxsegcount)) {
 637                 pmax->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
 638         }
 639         if (pmax->tsomaxsegsize == 0 || (ifp->if_hw_tsomaxsegsize != 0 &&
 640             ifp->if_hw_tsomaxsegsize < pmax->tsomaxsegsize)) {
 641                 pmax->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
 642         }
 643 }
 644
 645 /*
 646  * Update TSO limit of a network adapter.
 647  *
 648  * Returns zero if no change. Else non-zero.
 649  */
 650 int
 651 if_hw_tsomax_update(if_t ifp, struct ifnet_hw_tsomax *pmax)
 652 {
 653         int retval = 0;
 654         if (ifp->if_hw_tsomax != pmax->tsomaxbytes) {
 655                 ifp->if_hw_tsomax = pmax->tsomaxbytes;
 656                 retval++;
 657         }
 658         if (ifp->if_hw_tsomaxsegsize != pmax->tsomaxsegsize) {
 659                 ifp->if_hw_tsomaxsegsize = pmax->tsomaxsegsize;
 660                 retval++;
 661         }
 662         if (ifp->if_hw_tsomaxsegcount != pmax->tsomaxsegcount) {
 663                 ifp->if_hw_tsomaxsegcount = pmax->tsomaxsegcount;
 664                 retval++;
 665         }
 666         return (retval);
 667 }
 668
 669 static void
 670 if_attach_internal(struct ifnet *ifp, int vmove, struct if_clone *ifc)
 671 {
 672         unsigned socksize, ifasize;
 673         int namelen, masklen;
 674         struct sockaddr_dl *sdl;
 675         struct ifaddr *ifa;
 676
 677         if (ifp->if_index == 0 || ifp != ifnet_byindex(ifp->if_index))
 678                 panic ("%s: BUG: if_attach called without if_alloc'd input()\n",
 679                     ifp->if_xname);
 680
 681 #ifdef VIMAGE
 682         ifp->if_vnet = curvnet;
 683         if (ifp->if_home_vnet == NULL)
 684                 ifp->if_home_vnet = curvnet;
 685 #endif
 686
 687         if_addgroup(ifp, IFG_ALL);
 688
 689         /* Restore group membership for cloned interfaces. */
 690         if (vmove && ifc != NULL)
 691                 if_clone_addgroup(ifp, ifc);
 692
 693         getmicrotime(&ifp->if_lastchange);
 694         ifp->if_epoch = time_uptime;
 695
 696         KASSERT((ifp->if_transmit == NULL && ifp->if_qflush == NULL) ||
 697             (ifp->if_transmit != NULL && ifp->if_qflush != NULL),
 698             ("transmit and qflush must both either be set or both be NULL"));
 699         if (ifp->if_transmit == NULL) {
 700                 ifp->if_transmit = if_transmit;
 701                 ifp->if_qflush = if_qflush;
 702         }
 703         if (ifp->if_input == NULL)
 704                 ifp->if_input = if_input_default;
 705
 706         if (ifp->if_requestencap == NULL)
 707                 ifp->if_requestencap = if_requestencap_default;
 708
 709         if (!vmove) {
 710 #ifdef MAC
 711                 mac_ifnet_create(ifp);
 712 #endif
 713
 714                 /*
 715                  * Create a Link Level name for this device.
 716                  */
 717                 namelen = strlen(ifp->if_xname);
 718                 /*
 719                  * Always save enough space for any possiable name so we
 720                  * can do a rename in place later.
 721                  */
 722                 masklen = offsetof(struct sockaddr_dl, sdl_data[0]) + IFNAMSIZ;
 723                 socksize = masklen + ifp->if_addrlen;
 724                 if (socksize < sizeof(*sdl))
 725                         socksize = sizeof(*sdl);
 726                 socksize = roundup2(socksize, sizeof(long));
 727                 ifasize = sizeof(*ifa) + 2 * socksize;
 728                 ifa = ifa_alloc(ifasize, M_WAITOK);
 729                 sdl = (struct sockaddr_dl *)(ifa + 1);
 730                 sdl->sdl_len = socksize;
 731                 sdl->sdl_family = AF_LINK;
 732                 bcopy(ifp->if_xname, sdl->sdl_data, namelen);
 733                 sdl->sdl_nlen = namelen;
 734                 sdl->sdl_index = ifp->if_index;
 735                 sdl->sdl_type = ifp->if_type;
 736                 ifp->if_addr = ifa;
 737                 ifa->ifa_ifp = ifp;
 738                 ifa->ifa_rtrequest = link_rtrequest;
 739                 ifa->ifa_addr = (struct sockaddr *)sdl;
 740                 sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
 741                 ifa->ifa_netmask = (struct sockaddr *)sdl;
 742                 sdl->sdl_len = masklen;
 743                 while (namelen != 0)
 744                         sdl->sdl_data[--namelen] = 0xff;
 745                 TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
 746                 /* Reliably crash if used uninitialized. */
 747                 ifp->if_broadcastaddr = NULL;
 748
 749                 if (ifp->if_type == IFT_ETHER) {
 750                         ifp->if_hw_addr = malloc(ifp->if_addrlen, M_IFADDR,
 751                             M_WAITOK | M_ZERO);
 752                 }
 753
 754 #if defined(INET) || defined(INET6)
 755                 /* Use defaults for TSO, if nothing is set */
 756                 if (ifp->if_hw_tsomax == 0 &&
 757                     ifp->if_hw_tsomaxsegcount == 0 &&
 758                     ifp->if_hw_tsomaxsegsize == 0) {
 759                         /*
 760                          * The TSO defaults needs to be such that an
 761                          * NFS mbuf list of 35 mbufs totalling just
 762                          * below 64K works and that a chain of mbufs
 763                          * can be defragged into at most 32 segments:
 764                          */
 765                         ifp->if_hw_tsomax = min(IP_MAXPACKET, (32 * MCLBYTES) -
 766                             (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN));
 767                         ifp->if_hw_tsomaxsegcount = 35;
 768                         ifp->if_hw_tsomaxsegsize = 2048;        /* 2K */
 769
 770                         /* XXX some drivers set IFCAP_TSO after ethernet attach */
 771                         if (ifp->if_capabilities & IFCAP_TSO) {
 772                                 if_printf(ifp, "Using defaults for TSO: %u/%u/%u\n",
 773                                     ifp->if_hw_tsomax,
 774                                     ifp->if_hw_tsomaxsegcount,
 775                                     ifp->if_hw_tsomaxsegsize);
 776                         }
 777                 }
 778 #endif
 779         }
 780 #ifdef VIMAGE
 781         else {
 782                 /*
 783                  * Update the interface index in the link layer address
 784                  * of the interface.
 785                  */
 786                 for (ifa = ifp->if_addr; ifa != NULL;
 787                     ifa = TAILQ_NEXT(ifa, ifa_link)) {
 788                         if (ifa->ifa_addr->sa_family == AF_LINK) {
 789                                 sdl = (struct sockaddr_dl *)ifa->ifa_addr;
 790                                 sdl->sdl_index = ifp->if_index;
 791                         }
 792                 }
 793         }
 794 #endif
 795
 796         IFNET_WLOCK();
 797         TAILQ_INSERT_TAIL(&V_ifnet, ifp, if_link);
 798 #ifdef VIMAGE
 799         curvnet->vnet_ifcnt++;
 800 #endif
 801         IFNET_WUNLOCK();
 802
 803         if (domain_init_status >= 2)
 804                 if_attachdomain1(ifp);
 805
 806         EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
 807         if (IS_DEFAULT_VNET(curvnet))
 808                 devctl_notify("IFNET", ifp->if_xname, "ATTACH", NULL);
 809
 810         /* Announce the interface. */
 811         rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
 812 }
 813
 814 static void
 815 if_attachdomain(void *dummy)
 816 {
 817         struct ifnet *ifp;
 818
 819         TAILQ_FOREACH(ifp, &V_ifnet, if_link)
 820                 if_attachdomain1(ifp);
 821 }
 822 SYSINIT(domainifattach, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_SECOND,
 823     if_attachdomain, NULL);
 824
 825 static void
 826 if_attachdomain1(struct ifnet *ifp)
 827 {
 828         struct domain *dp;
 829
 830         /*
 831          * Since dp->dom_ifattach calls malloc() with M_WAITOK, we
 832          * cannot lock ifp->if_afdata initialization, entirely.
 833          */
 834         IF_AFDATA_LOCK(ifp);
 835         if (ifp->if_afdata_initialized >= domain_init_status) {
 836                 IF_AFDATA_UNLOCK(ifp);
 837                 log(LOG_WARNING, "%s called more than once on %s\n",
 838                     __func__, ifp->if_xname);
 839                 return;
 840         }
 841         ifp->if_afdata_initialized = domain_init_status;
 842         IF_AFDATA_UNLOCK(ifp);
 843
 844         /* address family dependent data region */
 845         bzero(ifp->if_afdata, sizeof(ifp->if_afdata));
 846         for (dp = domains; dp; dp = dp->dom_next) {
 847                 if (dp->dom_ifattach)
 848                         ifp->if_afdata[dp->dom_family] =
 849                             (*dp->dom_ifattach)(ifp);
 850         }
 851 }
 852
 853 /*
 854  * Remove any unicast or broadcast network addresses from an interface.
 855  */
 856 void
 857 if_purgeaddrs(struct ifnet *ifp)
 858 {
 859         struct ifaddr *ifa, *next;
 860
 861         /* XXX cannot hold IF_ADDR_WLOCK over called functions. */
 862         TAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, next) {
 863                 if (ifa->ifa_addr->sa_family == AF_LINK)
 864                         continue;
 865 #ifdef INET
 866                 /* XXX: Ugly!! ad hoc just for INET */
 867                 if (ifa->ifa_addr->sa_family == AF_INET) {
 868                         struct ifaliasreq ifr;
 869
 870                         bzero(&ifr, sizeof(ifr));
 871                         ifr.ifra_addr = *ifa->ifa_addr;
 872                         if (ifa->ifa_dstaddr)
 873                                 ifr.ifra_broadaddr = *ifa->ifa_dstaddr;
 874                         if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp,
 875                             NULL) == 0)
 876                                 continue;
 877                 }
 878 #endif /* INET */
 879 #ifdef INET6
 880                 if (ifa->ifa_addr->sa_family == AF_INET6) {
 881                         in6_purgeaddr(ifa);
 882                         /* ifp_addrhead is already updated */
 883                         continue;
 884                 }
 885 #endif /* INET6 */
 886                 IF_ADDR_WLOCK(ifp);
 887                 TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
 888                 IF_ADDR_WUNLOCK(ifp);
 889                 ifa_free(ifa);
 890         }
 891 }
 892
 893 /*
 894  * Remove any multicast network addresses from an interface when an ifnet
 895  * is going away.
 896  */
 897 static void
 898 if_purgemaddrs(struct ifnet *ifp)
 899 {
 900         struct ifmultiaddr *ifma;
 901         struct ifmultiaddr *next;
 902
 903         IF_ADDR_WLOCK(ifp);
 904         TAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
 905                 if_delmulti_locked(ifp, ifma, 1);
 906         IF_ADDR_WUNLOCK(ifp);
 907 }
 908
 909 /*
 910  * Detach an interface, removing it from the list of "active" interfaces.
 911  * If vmove flag is set on entry to if_detach_internal(), perform only a
 912  * limited subset of cleanup tasks, given that we are moving an ifnet from
 913  * one vnet to another, where it must be fully operational.
 914  *
 915  * XXXRW: There are some significant questions about event ordering, and
 916  * how to prevent things from starting to use the interface during detach.
 917  */
 918 void
 919 if_detach(struct ifnet *ifp)
 920 {
 921
 922         CURVNET_SET_QUIET(ifp->if_vnet);
 923         if_detach_internal(ifp, 0, NULL);
 924         CURVNET_RESTORE();
 925 }
 926
 927 /*
 928  * The vmove flag, if set, indicates that we are called from a callpath
 929  * that is moving an interface to a different vnet instance.
 930  *
 931  * The shutdown flag, if set, indicates that we are called in the
 932  * process of shutting down a vnet instance.  Currently only the
 933  * vnet_if_return SYSUNINIT function sets it.  Note: we can be called
 934  * on a vnet instance shutdown without this flag being set, e.g., when
 935  * the cloned interfaces are destoyed as first thing of teardown.
 936  */
 937 static int
 938 if_detach_internal(struct ifnet *ifp, int vmove, struct if_clone **ifcp)
 939 {
 940         struct ifaddr *ifa;
 941         int i;
 942         struct domain *dp;
 943         struct ifnet *iter;
 944         int found = 0;
 945 #ifdef VIMAGE
 946         int shutdown;
 947
 948         shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
 949                  ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
 950 #endif
 951         IFNET_WLOCK();
 952         TAILQ_FOREACH(iter, &V_ifnet, if_link)
 953                 if (iter == ifp) {
 954                         TAILQ_REMOVE(&V_ifnet, ifp, if_link);
 955                         found = 1;
 956                         break;
 957                 }
 958         IFNET_WUNLOCK();
 959         if (!found) {
 960                 /*
 961                  * While we would want to panic here, we cannot
 962                  * guarantee that the interface is indeed still on
 963                  * the list given we don't hold locks all the way.
 964                  */
 965                 return (ENOENT);
 966 #if 0
 967                 if (vmove)
 968                         panic("%s: ifp=%p not on the ifnet tailq %p",
 969                             __func__, ifp, &V_ifnet);
 970                 else
 971                         return; /* XXX this should panic as well? */
 972 #endif
 973         }
 974
 975         /*
 976          * At this point we know the interface still was on the ifnet list
 977          * and we removed it so we are in a stable state.
 978          */
 979 #ifdef VIMAGE
 980         curvnet->vnet_ifcnt--;
 981 #endif
 982
 983         /*
 984          * In any case (destroy or vmove) detach us from the groups
 985          * and remove/wait for pending events on the taskq.
 986          * XXX-BZ in theory an interface could still enqueue a taskq change?
 987          */
 988         if_delgroups(ifp);
 989
 990         taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
 991
 992         /*
 993          * Check if this is a cloned interface or not. Must do even if
 994          * shutting down as a if_vmove_reclaim() would move the ifp and
 995          * the if_clone_addgroup() will have a corrupted string overwise
 996          * from a gibberish pointer.
 997          */
 998         if (vmove && ifcp != NULL)
 999                 *ifcp = if_clone_findifc(ifp);
1000
1001         if_down(ifp);
1002
1003 #ifdef VIMAGE
1004         /*
1005          * On VNET shutdown abort here as the stack teardown will do all
1006          * the work top-down for us.
1007          */
1008         if (shutdown) {
1009                 /*
1010                  * In case of a vmove we are done here without error.
1011                  * If we would signal an error it would lead to the same
1012                  * abort as if we did not find the ifnet anymore.
1013                  * if_detach() calls us in void context and does not care
1014                  * about an early abort notification, so life is splendid :)
1015                  */
1016                 goto finish_vnet_shutdown;
1017         }
1018 #endif
1019
1020         /*
1021          * At this point we are not tearing down a VNET and are either
1022          * going to destroy or vmove the interface and have to cleanup
1023          * accordingly.
1024          */
1025
1026         /*
1027          * Remove routes and flush queues.
1028          */
1029 #ifdef ALTQ
1030         if (ALTQ_IS_ENABLED(&ifp->if_snd))
1031                 altq_disable(&ifp->if_snd);
1032         if (ALTQ_IS_ATTACHED(&ifp->if_snd))
1033                 altq_detach(&ifp->if_snd);
1034 #endif
1035
1036         if_purgeaddrs(ifp);
1037
1038 #ifdef INET
1039         in_ifdetach(ifp);
1040 #endif
1041
1042 #ifdef INET6
1043         /*
1044          * Remove all IPv6 kernel structs related to ifp.  This should be done
1045          * before removing routing entries below, since IPv6 interface direct
1046          * routes are expected to be removed by the IPv6-specific kernel API.
1047          * Otherwise, the kernel will detect some inconsistency and bark it.
1048          */
1049         in6_ifdetach(ifp);
1050 #endif
1051         if_purgemaddrs(ifp);
1052
1053         /* Announce that the interface is gone. */
1054         rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
1055         EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
1056         if (IS_DEFAULT_VNET(curvnet))
1057                 devctl_notify("IFNET", ifp->if_xname, "DETACH", NULL);
1058
1059         if (!vmove) {
1060                 /*
1061                  * Prevent further calls into the device driver via ifnet.
1062                  */
1063                 if_dead(ifp);
1064
1065                 /*
1066                  * Remove link ifaddr pointer and maybe decrement if_index.
1067                  * Clean up all addresses.
1068                  */
1069                 free(ifp->if_hw_addr, M_IFADDR);
1070                 ifp->if_hw_addr = NULL;
1071                 ifp->if_addr = NULL;
1072
1073                 /* We can now free link ifaddr. */
1074                 IF_ADDR_WLOCK(ifp);
1075                 if (!TAILQ_EMPTY(&ifp->if_addrhead)) {
1076                         ifa = TAILQ_FIRST(&ifp->if_addrhead);
1077                         TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
1078                         IF_ADDR_WUNLOCK(ifp);
1079                         ifa_free(ifa);
1080                 } else
1081                         IF_ADDR_WUNLOCK(ifp);
1082         }
1083
1084         rt_flushifroutes(ifp);
1085
1086 #ifdef VIMAGE
1087 finish_vnet_shutdown:
1088 #endif
1089         /*
1090          * We cannot hold the lock over dom_ifdetach calls as they might
1091          * sleep, for example trying to drain a callout, thus open up the
1092          * theoretical race with re-attaching.
1093          */
1094         IF_AFDATA_LOCK(ifp);
1095         i = ifp->if_afdata_initialized;
1096         ifp->if_afdata_initialized = 0;
1097         IF_AFDATA_UNLOCK(ifp);
1098         for (dp = domains; i > 0 && dp; dp = dp->dom_next) {
1099                 if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family]) {
1100                         (*dp->dom_ifdetach)(ifp,
1101                             ifp->if_afdata[dp->dom_family]);
1102                         ifp->if_afdata[dp->dom_family] = NULL;
1103                 }
1104         }
1105
1106         return (0);
1107 }
1108
1109 #ifdef VIMAGE
1110 /*
1111  * if_vmove() performs a limited version of if_detach() in current
1112  * vnet and if_attach()es the ifnet to the vnet specified as 2nd arg.
1113  * An attempt is made to shrink if_index in current vnet, find an
1114  * unused if_index in target vnet and calls if_grow() if necessary,
1115  * and finally find an unused if_xname for the target vnet.
1116  */
1117 static void
1118 if_vmove(struct ifnet *ifp, struct vnet *new_vnet)
1119 {
1120         struct if_clone *ifc;
1121         u_int bif_dlt, bif_hdrlen;
1122         int rc;
1123
1124         /*
1125          * if_detach_internal() will call the eventhandler to notify
1126          * interface departure.  That will detach if_bpf.  We need to
1127          * safe the dlt and hdrlen so we can re-attach it later.
1128          */
1129         bpf_get_bp_params(ifp->if_bpf, &bif_dlt, &bif_hdrlen);
1130
1131         /*
1132          * Detach from current vnet, but preserve LLADDR info, do not
1133          * mark as dead etc. so that the ifnet can be reattached later.
1134          * If we cannot find it, we lost the race to someone else.
1135          */
1136         rc = if_detach_internal(ifp, 1, &ifc);
1137         if (rc != 0)
1138                 return;
1139
1140         /*
1141          * Unlink the ifnet from ifindex_table[] in current vnet, and shrink
1142          * the if_index for that vnet if possible.
1143          *
1144          * NOTE: IFNET_WLOCK/IFNET_WUNLOCK() are assumed to be unvirtualized,
1145          * or we'd lock on one vnet and unlock on another.
1146          */
1147         IFNET_WLOCK();
1148         ifindex_free_locked(ifp->if_index);
1149         IFNET_WUNLOCK();
1150
1151         /*
1152          * Perform interface-specific reassignment tasks, if provided by
1153          * the driver.
1154          */
1155         if (ifp->if_reassign != NULL)
1156                 ifp->if_reassign(ifp, new_vnet, NULL);
1157
1158         /*
1159          * Switch to the context of the target vnet.
1160          */
1161         CURVNET_SET_QUIET(new_vnet);
1162
1163         IFNET_WLOCK();
1164         ifp->if_index = ifindex_alloc();
1165         ifnet_setbyindex_locked(ifp->if_index, ifp);
1166         IFNET_WUNLOCK();
1167
1168         if_attach_internal(ifp, 1, ifc);
1169
1170         if (ifp->if_bpf == NULL)
1171                 bpfattach(ifp, bif_dlt, bif_hdrlen);
1172
1173         CURVNET_RESTORE();
1174 }
1175
1176 /*
1177  * Move an ifnet to or from another child prison/vnet, specified by the jail id.
1178  */
1179 static int
1180 if_vmove_loan(struct thread *td, struct ifnet *ifp, char *ifname, int jid)
1181 {
1182         struct prison *pr;
1183         struct ifnet *difp;
1184         int shutdown;
1185
1186         /* Try to find the prison within our visibility. */
1187         sx_slock(&allprison_lock);
1188         pr = prison_find_child(td->td_ucred->cr_prison, jid);
1189         sx_sunlock(&allprison_lock);
1190         if (pr == NULL)
1191                 return (ENXIO);
1192         prison_hold_locked(pr);
1193         mtx_unlock(&pr->pr_mtx);
1194
1195         /* Do not try to move the iface from and to the same prison. */
1196         if (pr->pr_vnet == ifp->if_vnet) {
1197                 prison_free(pr);
1198                 return (EEXIST);
1199         }
1200
1201         /* Make sure the named iface does not exists in the dst. prison/vnet. */
1202         /* XXX Lock interfaces to avoid races. */
1203         CURVNET_SET_QUIET(pr->pr_vnet);
1204         difp = ifunit(ifname);
1205         if (difp != NULL) {
1206                 CURVNET_RESTORE();
1207                 prison_free(pr);
1208                 return (EEXIST);
1209         }
1210
1211         /* Make sure the VNET is stable. */
1212         shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
1213                  ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
1214         if (shutdown) {
1215                 CURVNET_RESTORE();
1216                 prison_free(pr);
1217                 return (EBUSY);
1218         }
1219         CURVNET_RESTORE();
1220
1221         /* Move the interface into the child jail/vnet. */
1222         if_vmove(ifp, pr->pr_vnet);
1223
1224         /* Report the new if_xname back to the userland. */
1225         sprintf(ifname, "%s", ifp->if_xname);
1226
1227         prison_free(pr);
1228         return (0);
1229 }
1230
1231 static int
1232 if_vmove_reclaim(struct thread *td, char *ifname, int jid)
1233 {
1234         struct prison *pr;
1235         struct vnet *vnet_dst;
1236         struct ifnet *ifp;
1237         int shutdown;
1238
1239         /* Try to find the prison within our visibility. */
1240         sx_slock(&allprison_lock);
1241         pr = prison_find_child(td->td_ucred->cr_prison, jid);
1242         sx_sunlock(&allprison_lock);
1243         if (pr == NULL)
1244                 return (ENXIO);
1245         prison_hold_locked(pr);
1246         mtx_unlock(&pr->pr_mtx);
1247
1248         /* Make sure the named iface exists in the source prison/vnet. */
1249         CURVNET_SET(pr->pr_vnet);
1250         ifp = ifunit(ifname);           /* XXX Lock to avoid races. */
1251         if (ifp == NULL) {
1252                 CURVNET_RESTORE();
1253                 prison_free(pr);
1254                 return (ENXIO);
1255         }
1256
1257         /* Do not try to move the iface from and to the same prison. */
1258         vnet_dst = TD_TO_VNET(td);
1259         if (vnet_dst == ifp->if_vnet) {
1260                 CURVNET_RESTORE();
1261                 prison_free(pr);
1262                 return (EEXIST);
1263         }
1264
1265         /* Make sure the VNET is stable. */
1266         shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
1267                  ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
1268         if (shutdown) {
1269                 CURVNET_RESTORE();
1270                 prison_free(pr);
1271                 return (EBUSY);
1272         }
1273
1274         /* Get interface back from child jail/vnet. */
1275         if_vmove(ifp, vnet_dst);
1276         CURVNET_RESTORE();
1277
1278         /* Report the new if_xname back to the userland. */
1279         sprintf(ifname, "%s", ifp->if_xname);
1280
1281         prison_free(pr);
1282         return (0);
1283 }
1284 #endif /* VIMAGE */
1285
1286 /*
1287  * Add a group to an interface
1288  */
1289 int
1290 if_addgroup(struct ifnet *ifp, const char *groupname)
1291 {
1292         struct ifg_list         *ifgl;
1293         struct ifg_group        *ifg = NULL;
1294         struct ifg_member       *ifgm;
1295         int                      new = 0;
1296
1297         if (groupname[0] && groupname[strlen(groupname) - 1] >= '0' &&
1298             groupname[strlen(groupname) - 1] <= '9')
1299                 return (EINVAL);
1300
1301         IFNET_WLOCK();
1302         TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
1303                 if (!strcmp(ifgl->ifgl_group->ifg_group, groupname)) {
1304                         IFNET_WUNLOCK();
1305                         return (EEXIST);
1306                 }
1307
1308         if ((ifgl = (struct ifg_list *)malloc(sizeof(struct ifg_list), M_TEMP,
1309             M_NOWAIT)) == NULL) {
1310                 IFNET_WUNLOCK();
1311                 return (ENOMEM);
1312         }
1313
1314         if ((ifgm = (struct ifg_member *)malloc(sizeof(struct ifg_member),
1315             M_TEMP, M_NOWAIT)) == NULL) {
1316                 free(ifgl, M_TEMP);
1317                 IFNET_WUNLOCK();
1318                 return (ENOMEM);
1319         }
1320
1321         TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
1322                 if (!strcmp(ifg->ifg_group, groupname))
1323                         break;
1324
1325         if (ifg == NULL) {
1326                 if ((ifg = (struct ifg_group *)malloc(sizeof(struct ifg_group),
1327                     M_TEMP, M_NOWAIT)) == NULL) {
1328                         free(ifgl, M_TEMP);
1329                         free(ifgm, M_TEMP);
1330                         IFNET_WUNLOCK();
1331                         return (ENOMEM);
1332                 }
1333                 strlcpy(ifg->ifg_group, groupname, sizeof(ifg->ifg_group));
1334                 ifg->ifg_refcnt = 0;
1335                 TAILQ_INIT(&ifg->ifg_members);
1336                 TAILQ_INSERT_TAIL(&V_ifg_head, ifg, ifg_next);
1337                 new = 1;
1338         }
1339
1340         ifg->ifg_refcnt++;
1341         ifgl->ifgl_group = ifg;
1342         ifgm->ifgm_ifp = ifp;
1343
1344         IF_ADDR_WLOCK(ifp);
1345         TAILQ_INSERT_TAIL(&ifg->ifg_members, ifgm, ifgm_next);
1346         TAILQ_INSERT_TAIL(&ifp->if_groups, ifgl, ifgl_next);
1347         IF_ADDR_WUNLOCK(ifp);
1348
1349         IFNET_WUNLOCK();
1350
1351         if (new)
1352                 EVENTHANDLER_INVOKE(group_attach_event, ifg);
1353         EVENTHANDLER_INVOKE(group_change_event, groupname);
1354
1355         return (0);
1356 }
1357
1358 /*
1359  * Remove a group from an interface
1360  */
1361 int
1362 if_delgroup(struct ifnet *ifp, const char *groupname)
1363 {
1364         struct ifg_list         *ifgl;
1365         struct ifg_member       *ifgm;
1366
1367         IFNET_WLOCK();
1368         TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
1369                 if (!strcmp(ifgl->ifgl_group->ifg_group, groupname))
1370                         break;
1371         if (ifgl == NULL) {
1372                 IFNET_WUNLOCK();
1373                 return (ENOENT);
1374         }
1375
1376         IF_ADDR_WLOCK(ifp);
1377         TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
1378         IF_ADDR_WUNLOCK(ifp);
1379
1380         TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
1381                 if (ifgm->ifgm_ifp == ifp)
1382                         break;
1383
1384         if (ifgm != NULL) {
1385                 TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm, ifgm_next);
1386                 free(ifgm, M_TEMP);
1387         }
1388
1389         if (--ifgl->ifgl_group->ifg_refcnt == 0) {
1390                 TAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_next);
1391                 IFNET_WUNLOCK();
1392                 EVENTHANDLER_INVOKE(group_detach_event, ifgl->ifgl_group);
1393                 free(ifgl->ifgl_group, M_TEMP);
1394         } else
1395                 IFNET_WUNLOCK();
1396
1397         free(ifgl, M_TEMP);
1398
1399         EVENTHANDLER_INVOKE(group_change_event, groupname);
1400
1401         return (0);
1402 }
1403
1404 /*
1405  * Remove an interface from all groups
1406  */
1407 static void
1408 if_delgroups(struct ifnet *ifp)
1409 {
1410         struct ifg_list         *ifgl;
1411         struct ifg_member       *ifgm;
1412         char groupname[IFNAMSIZ];
1413
1414         IFNET_WLOCK();
1415         while (!TAILQ_EMPTY(&ifp->if_groups)) {
1416                 ifgl = TAILQ_FIRST(&ifp->if_groups);
1417
1418                 strlcpy(groupname, ifgl->ifgl_group->ifg_group, IFNAMSIZ);
1419
1420                 IF_ADDR_WLOCK(ifp);
1421                 TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
1422                 IF_ADDR_WUNLOCK(ifp);
1423
1424                 TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
1425                         if (ifgm->ifgm_ifp == ifp)
1426                                 break;
1427
1428                 if (ifgm != NULL) {
1429                         TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm,
1430                             ifgm_next);
1431                         free(ifgm, M_TEMP);
1432                 }
1433
1434                 if (--ifgl->ifgl_group->ifg_refcnt == 0) {
1435                         TAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_next);
1436                         IFNET_WUNLOCK();
1437                         EVENTHANDLER_INVOKE(group_detach_event,
1438                             ifgl->ifgl_group);
1439                         free(ifgl->ifgl_group, M_TEMP);
1440                 } else
1441                         IFNET_WUNLOCK();
1442
1443                 free(ifgl, M_TEMP);
1444
1445                 EVENTHANDLER_INVOKE(group_change_event, groupname);
1446
1447                 IFNET_WLOCK();
1448         }
1449         IFNET_WUNLOCK();
1450 }
1451
1452 /*
1453  * Stores all groups from an interface in memory pointed
1454  * to by data
1455  */
1456 static int
1457 if_getgroup(struct ifgroupreq *data, struct ifnet *ifp)
1458 {
1459         int                      len, error;
1460         struct ifg_list         *ifgl;
1461         struct ifg_req           ifgrq, *ifgp;
1462         struct ifgroupreq       *ifgr = data;
1463
1464         if (ifgr->ifgr_len == 0) {
1465                 IF_ADDR_RLOCK(ifp);
1466                 TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
1467                         ifgr->ifgr_len += sizeof(struct ifg_req);
1468                 IF_ADDR_RUNLOCK(ifp);
1469                 return (0);
1470         }
1471
1472         len = ifgr->ifgr_len;
1473         ifgp = ifgr->ifgr_groups;
1474         /* XXX: wire */
1475         IF_ADDR_RLOCK(ifp);
1476         TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
1477                 if (len < sizeof(ifgrq)) {
1478                         IF_ADDR_RUNLOCK(ifp);
1479                         return (EINVAL);
1480                 }
1481                 bzero(&ifgrq, sizeof ifgrq);
1482                 strlcpy(ifgrq.ifgrq_group, ifgl->ifgl_group->ifg_group,
1483                     sizeof(ifgrq.ifgrq_group));
1484                 if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
1485                         IF_ADDR_RUNLOCK(ifp);
1486                         return (error);
1487                 }
1488                 len -= sizeof(ifgrq);
1489                 ifgp++;
1490         }
1491         IF_ADDR_RUNLOCK(ifp);
1492
1493         return (0);
1494 }
1495
1496 /*
1497  * Stores all members of a group in memory pointed to by data
1498  */
1499 static int
1500 if_getgroupmembers(struct ifgroupreq *data)
1501 {
1502         struct ifgroupreq       *ifgr = data;
1503         struct ifg_group        *ifg;
1504         struct ifg_member       *ifgm;
1505         struct ifg_req           ifgrq, *ifgp;
1506         int                      len, error;
1507
1508         IFNET_RLOCK();
1509         TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
1510                 if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
1511                         break;
1512         if (ifg == NULL) {
1513                 IFNET_RUNLOCK();
1514                 return (ENOENT);
1515         }
1516
1517         if (ifgr->ifgr_len == 0) {
1518                 TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
1519                         ifgr->ifgr_len += sizeof(ifgrq);
1520                 IFNET_RUNLOCK();
1521                 return (0);
1522         }
1523
1524         len = ifgr->ifgr_len;
1525         ifgp = ifgr->ifgr_groups;
1526         TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next) {
1527                 if (len < sizeof(ifgrq)) {
1528                         IFNET_RUNLOCK();
1529                         return (EINVAL);
1530                 }
1531                 bzero(&ifgrq, sizeof ifgrq);
1532                 strlcpy(ifgrq.ifgrq_member, ifgm->ifgm_ifp->if_xname,
1533                     sizeof(ifgrq.ifgrq_member));
1534                 if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
1535                         IFNET_RUNLOCK();
1536                         return (error);
1537                 }
1538                 len -= sizeof(ifgrq);
1539                 ifgp++;
1540         }
1541         IFNET_RUNLOCK();
1542
1543         return (0);
1544 }
1545
1546 /*
1547  * Return counter values from counter(9)s stored in ifnet.
1548  */
1549 uint64_t
1550 if_get_counter_default(struct ifnet *ifp, ift_counter cnt)
1551 {
1552
1553         KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1554
1555         return (counter_u64_fetch(ifp->if_counters[cnt]));
1556 }
1557
1558 /*
1559  * Increase an ifnet counter. Usually used for counters shared
1560  * between the stack and a driver, but function supports them all.
1561  */
1562 void
1563 if_inc_counter(struct ifnet *ifp, ift_counter cnt, int64_t inc)
1564 {
1565
1566         KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1567
1568         counter_u64_add(ifp->if_counters[cnt], inc);
1569 }
1570
1571 /*
1572  * Copy data from ifnet to userland API structure if_data.
1573  */
1574 void
1575 if_data_copy(struct ifnet *ifp, struct if_data *ifd)
1576 {
1577
1578         ifd->ifi_type = ifp->if_type;
1579         ifd->ifi_physical = 0;
1580         ifd->ifi_addrlen = ifp->if_addrlen;
1581         ifd->ifi_hdrlen = ifp->if_hdrlen;
1582         ifd->ifi_link_state = ifp->if_link_state;
1583         ifd->ifi_vhid = 0;
1584         ifd->ifi_datalen = sizeof(struct if_data);
1585         ifd->ifi_mtu = ifp->if_mtu;
1586         ifd->ifi_metric = ifp->if_metric;
1587         ifd->ifi_baudrate = ifp->if_baudrate;
1588         ifd->ifi_hwassist = ifp->if_hwassist;
1589         ifd->ifi_epoch = ifp->if_epoch;
1590         ifd->ifi_lastchange = ifp->if_lastchange;
1591
1592         ifd->ifi_ipackets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS);
1593         ifd->ifi_ierrors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS);
1594         ifd->ifi_opackets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS);
1595         ifd->ifi_oerrors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS);
1596         ifd->ifi_collisions = ifp->if_get_counter(ifp, IFCOUNTER_COLLISIONS);
1597         ifd->ifi_ibytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES);
1598         ifd->ifi_obytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES);
1599         ifd->ifi_imcasts = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS);
1600         ifd->ifi_omcasts = ifp->if_get_counter(ifp, IFCOUNTER_OMCASTS);
1601         ifd->ifi_iqdrops = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS);
1602         ifd->ifi_oqdrops = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS);
1603         ifd->ifi_noproto = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO);
1604 }
1605
1606 /*
1607  * Wrapper functions for struct ifnet address list locking macros.  These are
1608  * used by kernel modules to avoid encoding programming interface or binary
1609  * interface assumptions that may be violated when kernel-internal locking
1610  * approaches change.
1611  */
1612 void
1613 if_addr_rlock(struct ifnet *ifp)
1614 {
1615
1616         IF_ADDR_RLOCK(ifp);
1617 }
1618
1619 void
1620 if_addr_runlock(struct ifnet *ifp)
1621 {
1622
1623         IF_ADDR_RUNLOCK(ifp);
1624 }
1625
1626 void
1627 if_maddr_rlock(if_t ifp)
1628 {
1629
1630         IF_ADDR_RLOCK((struct ifnet *)ifp);
1631 }
1632
1633 void
1634 if_maddr_runlock(if_t ifp)
1635 {
1636
1637         IF_ADDR_RUNLOCK((struct ifnet *)ifp);
1638 }
1639
1640 /*
1641  * Initialization, destruction and refcounting functions for ifaddrs.
1642  */
1643 struct ifaddr *
1644 ifa_alloc(size_t size, int flags)
1645 {
1646         struct ifaddr *ifa;
1647
1648         KASSERT(size >= sizeof(struct ifaddr),
1649             ("%s: invalid size %zu", __func__, size));
1650
1651         ifa = malloc(size, M_IFADDR, M_ZERO | flags);
1652         if (ifa == NULL)
1653                 return (NULL);
1654
1655         if ((ifa->ifa_opackets = counter_u64_alloc(flags)) == NULL)
1656                 goto fail;
1657         if ((ifa->ifa_ipackets = counter_u64_alloc(flags)) == NULL)
1658                 goto fail;
1659         if ((ifa->ifa_obytes = counter_u64_alloc(flags)) == NULL)
1660                 goto fail;
1661         if ((ifa->ifa_ibytes = counter_u64_alloc(flags)) == NULL)
1662                 goto fail;
1663
1664         refcount_init(&ifa->ifa_refcnt, 1);
1665
1666         return (ifa);
1667
1668 fail:
1669         /* free(NULL) is okay */
1670         counter_u64_free(ifa->ifa_opackets);
1671         counter_u64_free(ifa->ifa_ipackets);
1672         counter_u64_free(ifa->ifa_obytes);
1673         counter_u64_free(ifa->ifa_ibytes);
1674         free(ifa, M_IFADDR);
1675
1676         return (NULL);
1677 }
1678
1679 void
1680 ifa_ref(struct ifaddr *ifa)
1681 {
1682
1683         refcount_acquire(&ifa->ifa_refcnt);
1684 }
1685
1686 void
1687 ifa_free(struct ifaddr *ifa)
1688 {
1689
1690         if (refcount_release(&ifa->ifa_refcnt)) {
1691                 counter_u64_free(ifa->ifa_opackets);
1692                 counter_u64_free(ifa->ifa_ipackets);
1693                 counter_u64_free(ifa->ifa_obytes);
1694                 counter_u64_free(ifa->ifa_ibytes);
1695                 free(ifa, M_IFADDR);
1696         }
1697 }
1698
1699 static int
1700 ifa_maintain_loopback_route(int cmd, const char *otype, struct ifaddr *ifa,
1701     struct sockaddr *ia)
1702 {
1703         int error;
1704         struct rt_addrinfo info;
1705         struct sockaddr_dl null_sdl;
1706         struct ifnet *ifp;
1707
1708         ifp = ifa->ifa_ifp;
1709
1710         bzero(&info, sizeof(info));
1711         if (cmd != RTM_DELETE)
1712                 info.rti_ifp = V_loif;
1713         info.rti_flags = ifa->ifa_flags | RTF_HOST | RTF_STATIC | RTF_PINNED;
1714         info.rti_info[RTAX_DST] = ia;
1715         info.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&null_sdl;
1716         link_init_sdl(ifp, (struct sockaddr *)&null_sdl, ifp->if_type);
1717
1718         error = rtrequest1_fib(cmd, &info, NULL, ifp->if_fib);
1719
1720         if (error != 0)
1721                 log(LOG_DEBUG, "%s: %s failed for interface %s: %u\n",
1722                     __func__, otype, if_name(ifp), error);
1723
1724         return (error);
1725 }
1726
1727 int
1728 ifa_add_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
1729 {
1730
1731         return (ifa_maintain_loopback_route(RTM_ADD, "insertion", ifa, ia));
1732 }
1733
1734 int
1735 ifa_del_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
1736 {
1737
1738         return (ifa_maintain_loopback_route(RTM_DELETE, "deletion", ifa, ia));
1739 }
1740
1741 int
1742 ifa_switch_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
1743 {
1744
1745         return (ifa_maintain_loopback_route(RTM_CHANGE, "switch", ifa, ia));
1746 }
1747
1748 /*
1749  * XXX: Because sockaddr_dl has deeper structure than the sockaddr
1750  * structs used to represent other address families, it is necessary
1751  * to perform a different comparison.
1752  */
1753
1754 #define sa_dl_equal(a1, a2)     \
1755         ((((const struct sockaddr_dl *)(a1))->sdl_len ==                \
1756          ((const struct sockaddr_dl *)(a2))->sdl_len) &&                \
1757          (bcmp(CLLADDR((const struct sockaddr_dl *)(a1)),               \
1758                CLLADDR((const struct sockaddr_dl *)(a2)),               \
1759                ((const struct sockaddr_dl *)(a1))->sdl_alen) == 0))
1760
1761 /*
1762  * Locate an interface based on a complete address.
1763  */
1764 /*ARGSUSED*/
1765 static struct ifaddr *
1766 ifa_ifwithaddr_internal(const struct sockaddr *addr, int getref)
1767 {
1768         struct ifnet *ifp;
1769         struct ifaddr *ifa;
1770
1771         IFNET_RLOCK_NOSLEEP();
1772         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1773                 IF_ADDR_RLOCK(ifp);
1774                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1775                         if (ifa->ifa_addr->sa_family != addr->sa_family)
1776                                 continue;
1777                         if (sa_equal(addr, ifa->ifa_addr)) {
1778                                 if (getref)
1779                                         ifa_ref(ifa);
1780                                 IF_ADDR_RUNLOCK(ifp);
1781                                 goto done;
1782                         }
1783                         /* IP6 doesn't have broadcast */
1784                         if ((ifp->if_flags & IFF_BROADCAST) &&
1785                             ifa->ifa_broadaddr &&
1786                             ifa->ifa_broadaddr->sa_len != 0 &&
1787                             sa_equal(ifa->ifa_broadaddr, addr)) {
1788                                 if (getref)
1789                                         ifa_ref(ifa);
1790                                 IF_ADDR_RUNLOCK(ifp);
1791                                 goto done;
1792                         }
1793                 }
1794                 IF_ADDR_RUNLOCK(ifp);
1795         }
1796         ifa = NULL;
1797 done:
1798         IFNET_RUNLOCK_NOSLEEP();
1799         return (ifa);
1800 }
1801
1802 struct ifaddr *
1803 ifa_ifwithaddr(const struct sockaddr *addr)
1804 {
1805
1806         return (ifa_ifwithaddr_internal(addr, 1));
1807 }
1808
1809 int
1810 ifa_ifwithaddr_check(const struct sockaddr *addr)
1811 {
1812
1813         return (ifa_ifwithaddr_internal(addr, 0) != NULL);
1814 }
1815
1816 /*
1817  * Locate an interface based on the broadcast address.
1818  */
1819 /* ARGSUSED */
1820 struct ifaddr *
1821 ifa_ifwithbroadaddr(const struct sockaddr *addr, int fibnum)
1822 {
1823         struct ifnet *ifp;
1824         struct ifaddr *ifa;
1825
1826         IFNET_RLOCK_NOSLEEP();
1827         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1828                 if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
1829                         continue;
1830                 IF_ADDR_RLOCK(ifp);
1831                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1832                         if (ifa->ifa_addr->sa_family != addr->sa_family)
1833                                 continue;
1834                         if ((ifp->if_flags & IFF_BROADCAST) &&
1835                             ifa->ifa_broadaddr &&
1836                             ifa->ifa_broadaddr->sa_len != 0 &&
1837                             sa_equal(ifa->ifa_broadaddr, addr)) {
1838                                 ifa_ref(ifa);
1839                                 IF_ADDR_RUNLOCK(ifp);
1840                                 goto done;
1841                         }
1842                 }
1843                 IF_ADDR_RUNLOCK(ifp);
1844         }
1845         ifa = NULL;
1846 done:
1847         IFNET_RUNLOCK_NOSLEEP();
1848         return (ifa);
1849 }
1850
1851 /*
1852  * Locate the point to point interface with a given destination address.
1853  */
1854 /*ARGSUSED*/
1855 struct ifaddr *
1856 ifa_ifwithdstaddr(const struct sockaddr *addr, int fibnum)
1857 {
1858         struct ifnet *ifp;
1859         struct ifaddr *ifa;
1860
1861         IFNET_RLOCK_NOSLEEP();
1862         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1863                 if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
1864                         continue;
1865                 if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
1866                         continue;
1867                 IF_ADDR_RLOCK(ifp);
1868                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1869                         if (ifa->ifa_addr->sa_family != addr->sa_family)
1870                                 continue;
1871                         if (ifa->ifa_dstaddr != NULL &&
1872                             sa_equal(addr, ifa->ifa_dstaddr)) {
1873                                 ifa_ref(ifa);
1874                                 IF_ADDR_RUNLOCK(ifp);
1875                                 goto done;
1876                         }
1877                 }
1878                 IF_ADDR_RUNLOCK(ifp);
1879         }
1880         ifa = NULL;
1881 done:
1882         IFNET_RUNLOCK_NOSLEEP();
1883         return (ifa);
1884 }
1885
1886 /*
1887  * Find an interface on a specific network.  If many, choice
1888  * is most specific found.
1889  */
1890 struct ifaddr *
1891 ifa_ifwithnet(const struct sockaddr *addr, int ignore_ptp, int fibnum)
1892 {
1893         struct ifnet *ifp;
1894         struct ifaddr *ifa;
1895         struct ifaddr *ifa_maybe = NULL;
1896         u_int af = addr->sa_family;
1897         const char *addr_data = addr->sa_data, *cplim;
1898
1899         /*
1900          * AF_LINK addresses can be looked up directly by their index number,
1901          * so do that if we can.
1902          */
1903         if (af == AF_LINK) {
1904             const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)addr;
1905             if (sdl->sdl_index && sdl->sdl_index <= V_if_index)
1906                 return (ifaddr_byindex(sdl->sdl_index));
1907         }
1908
1909         /*
1910          * Scan though each interface, looking for ones that have addresses
1911          * in this address family and the requested fib.  Maintain a reference
1912          * on ifa_maybe once we find one, as we release the IF_ADDR_RLOCK() that
1913          * kept it stable when we move onto the next interface.
1914          */
1915         IFNET_RLOCK_NOSLEEP();
1916         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1917                 if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
1918                         continue;
1919                 IF_ADDR_RLOCK(ifp);
1920                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1921                         const char *cp, *cp2, *cp3;
1922
1923                         if (ifa->ifa_addr->sa_family != af)
1924 next:                           continue;
1925                         if (af == AF_INET &&
1926                             ifp->if_flags & IFF_POINTOPOINT && !ignore_ptp) {
1927                                 /*
1928                                  * This is a bit broken as it doesn't
1929                                  * take into account that the remote end may
1930                                  * be a single node in the network we are
1931                                  * looking for.
1932                                  * The trouble is that we don't know the
1933                                  * netmask for the remote end.
1934                                  */
1935                                 if (ifa->ifa_dstaddr != NULL &&
1936                                     sa_equal(addr, ifa->ifa_dstaddr)) {
1937                                         ifa_ref(ifa);
1938                                         IF_ADDR_RUNLOCK(ifp);
1939                                         goto done;
1940                                 }
1941                         } else {
1942                                 /*
1943                                  * Scan all the bits in the ifa's address.
1944                                  * If a bit dissagrees with what we are
1945                                  * looking for, mask it with the netmask
1946                                  * to see if it really matters.
1947                                  * (A byte at a time)
1948                                  */
1949                                 if (ifa->ifa_netmask == 0)
1950                                         continue;
1951                                 cp = addr_data;
1952                                 cp2 = ifa->ifa_addr->sa_data;
1953                                 cp3 = ifa->ifa_netmask->sa_data;
1954                                 cplim = ifa->ifa_netmask->sa_len
1955                                         + (char *)ifa->ifa_netmask;
1956                                 while (cp3 < cplim)
1957                                         if ((*cp++ ^ *cp2++) & *cp3++)
1958                                                 goto next; /* next address! */
1959                                 /*
1960                                  * If the netmask of what we just found
1961                                  * is more specific than what we had before
1962                                  * (if we had one), or if the virtual status
1963                                  * of new prefix is better than of the old one,
1964                                  * then remember the new one before continuing
1965                                  * to search for an even better one.
1966                                  */
1967                                 if (ifa_maybe == NULL ||
1968                                     ifa_preferred(ifa_maybe, ifa) ||
1969                                     rn_refines((caddr_t)ifa->ifa_netmask,
1970                                     (caddr_t)ifa_maybe->ifa_netmask)) {
1971                                         if (ifa_maybe != NULL)
1972                                                 ifa_free(ifa_maybe);
1973                                         ifa_maybe = ifa;
1974                                         ifa_ref(ifa_maybe);
1975                                 }
1976                         }
1977                 }
1978                 IF_ADDR_RUNLOCK(ifp);
1979         }
1980         ifa = ifa_maybe;
1981         ifa_maybe = NULL;
1982 done:
1983         IFNET_RUNLOCK_NOSLEEP();
1984         if (ifa_maybe != NULL)
1985                 ifa_free(ifa_maybe);
1986         return (ifa);
1987 }
1988
1989 /*
1990  * Find an interface address specific to an interface best matching
1991  * a given address.
1992  */
1993 struct ifaddr *
1994 ifaof_ifpforaddr(const struct sockaddr *addr, struct ifnet *ifp)
1995 {
1996         struct ifaddr *ifa;
1997         const char *cp, *cp2, *cp3;
1998         char *cplim;
1999         struct ifaddr *ifa_maybe = NULL;
2000         u_int af = addr->sa_family;
2001
2002         if (af >= AF_MAX)
2003                 return (NULL);
2004         IF_ADDR_RLOCK(ifp);
2005         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2006                 if (ifa->ifa_addr->sa_family != af)
2007                         continue;
2008                 if (ifa_maybe == NULL)
2009                         ifa_maybe = ifa;
2010                 if (ifa->ifa_netmask == 0) {
2011                         if (sa_equal(addr, ifa->ifa_addr) ||
2012                             (ifa->ifa_dstaddr &&
2013                             sa_equal(addr, ifa->ifa_dstaddr)))
2014                                 goto done;
2015                         continue;
2016                 }
2017                 if (ifp->if_flags & IFF_POINTOPOINT) {
2018                         if (sa_equal(addr, ifa->ifa_dstaddr))
2019                                 goto done;
2020                 } else {
2021                         cp = addr->sa_data;
2022                         cp2 = ifa->ifa_addr->sa_data;
2023                         cp3 = ifa->ifa_netmask->sa_data;
2024                         cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
2025                         for (; cp3 < cplim; cp3++)
2026                                 if ((*cp++ ^ *cp2++) & *cp3)
2027                                         break;
2028                         if (cp3 == cplim)
2029                                 goto done;
2030                 }
2031         }
2032         ifa = ifa_maybe;
2033 done:
2034         if (ifa != NULL)
2035                 ifa_ref(ifa);
2036         IF_ADDR_RUNLOCK(ifp);
2037         return (ifa);
2038 }
2039
2040 /*
2041  * See whether new ifa is better than current one:
2042  * 1) A non-virtual one is preferred over virtual.
2043  * 2) A virtual in master state preferred over any other state.
2044  *
2045  * Used in several address selecting functions.
2046  */
2047 int
2048 ifa_preferred(struct ifaddr *cur, struct ifaddr *next)
2049 {
2050
2051         return (cur->ifa_carp && (!next->ifa_carp ||
2052             ((*carp_master_p)(next) && !(*carp_master_p)(cur))));
2053 }
2054
2055 #include <net/if_llatbl.h>
2056
2057 /*
2058  * Default action when installing a route with a Link Level gateway.
2059  * Lookup an appropriate real ifa to point to.
2060  * This should be moved to /sys/net/link.c eventually.
2061  */
2062 static void
2063 link_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
2064 {
2065         struct ifaddr *ifa, *oifa;
2066         struct sockaddr *dst;
2067         struct ifnet *ifp;
2068
2069         if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == NULL) ||
2070             ((ifp = ifa->ifa_ifp) == NULL) || ((dst = rt_key(rt)) == NULL))
2071                 return;
2072         ifa = ifaof_ifpforaddr(dst, ifp);
2073         if (ifa) {
2074                 oifa = rt->rt_ifa;
2075                 rt->rt_ifa = ifa;
2076                 ifa_free(oifa);
2077                 if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
2078                         ifa->ifa_rtrequest(cmd, rt, info);
2079         }
2080 }
2081
2082 struct sockaddr_dl *
2083 link_alloc_sdl(size_t size, int flags)
2084 {
2085
2086         return (malloc(size, M_TEMP, flags));
2087 }
2088
2089 void
2090 link_free_sdl(struct sockaddr *sa)
2091 {
2092         free(sa, M_TEMP);
2093 }
2094
2095 /*
2096  * Fills in given sdl with interface basic info.
2097  * Returns pointer to filled sdl.
2098  */
2099 struct sockaddr_dl *
2100 link_init_sdl(struct ifnet *ifp, struct sockaddr *paddr, u_char iftype)
2101 {
2102         struct sockaddr_dl *sdl;
2103
2104         sdl = (struct sockaddr_dl *)paddr;
2105         memset(sdl, 0, sizeof(struct sockaddr_dl));
2106         sdl->sdl_len = sizeof(struct sockaddr_dl);
2107         sdl->sdl_family = AF_LINK;
2108         sdl->sdl_index = ifp->if_index;
2109         sdl->sdl_type = iftype;
2110
2111         return (sdl);
2112 }
2113
2114 /*
2115  * Mark an interface down and notify protocols of
2116  * the transition.
2117  */
2118 static void
2119 if_unroute(struct ifnet *ifp, int flag, int fam)
2120 {
2121         struct ifaddr *ifa;
2122
2123         KASSERT(flag == IFF_UP, ("if_unroute: flag != IFF_UP"));
2124
2125         ifp->if_flags &= ~flag;
2126         getmicrotime(&ifp->if_lastchange);
2127         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2128                 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2129                         pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
2130         ifp->if_qflush(ifp);
2131
2132         if (ifp->if_carp)
2133                 (*carp_linkstate_p)(ifp);
2134         rt_ifmsg(ifp);
2135 }
2136
2137 /*
2138  * Mark an interface up and notify protocols of
2139  * the transition.
2140  */
2141 static void
2142 if_route(struct ifnet *ifp, int flag, int fam)
2143 {
2144         struct ifaddr *ifa;
2145
2146         KASSERT(flag == IFF_UP, ("if_route: flag != IFF_UP"));
2147
2148         ifp->if_flags |= flag;
2149         getmicrotime(&ifp->if_lastchange);
2150         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2151                 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2152                         pfctlinput(PRC_IFUP, ifa->ifa_addr);
2153         if (ifp->if_carp)
2154                 (*carp_linkstate_p)(ifp);
2155         rt_ifmsg(ifp);
2156 #ifdef INET6
2157         in6_if_up(ifp);
2158 #endif
2159 }
2160
2161 void    (*vlan_link_state_p)(struct ifnet *);   /* XXX: private from if_vlan */
2162 void    (*vlan_trunk_cap_p)(struct ifnet *);            /* XXX: private from if_vlan */
2163 struct ifnet *(*vlan_trunkdev_p)(struct ifnet *);
2164 struct  ifnet *(*vlan_devat_p)(struct ifnet *, uint16_t);
2165 int     (*vlan_tag_p)(struct ifnet *, uint16_t *);
2166 int     (*vlan_setcookie_p)(struct ifnet *, void *);
2167 void    *(*vlan_cookie_p)(struct ifnet *);
2168
2169 /*
2170  * Handle a change in the interface link state. To avoid LORs
2171  * between driver lock and upper layer locks, as well as possible
2172  * recursions, we post event to taskqueue, and all job
2173  * is done in static do_link_state_change().
2174  */
2175 void
2176 if_link_state_change(struct ifnet *ifp, int link_state)
2177 {
2178         /* Return if state hasn't changed. */
2179         if (ifp->if_link_state == link_state)
2180                 return;
2181
2182         ifp->if_link_state = link_state;
2183
2184         taskqueue_enqueue(taskqueue_swi, &ifp->if_linktask);
2185 }
2186
2187 static void
2188 do_link_state_change(void *arg, int pending)
2189 {
2190         struct ifnet *ifp = (struct ifnet *)arg;
2191         int link_state = ifp->if_link_state;
2192         CURVNET_SET(ifp->if_vnet);
2193
2194         /* Notify that the link state has changed. */
2195         rt_ifmsg(ifp);
2196         if (ifp->if_vlantrunk != NULL)
2197                 (*vlan_link_state_p)(ifp);
2198
2199         if ((ifp->if_type == IFT_ETHER || ifp->if_type == IFT_L2VLAN) &&
2200             ifp->if_l2com != NULL)
2201                 (*ng_ether_link_state_p)(ifp, link_state);
2202         if (ifp->if_carp)
2203                 (*carp_linkstate_p)(ifp);
2204         if (ifp->if_bridge)
2205                 (*bridge_linkstate_p)(ifp);
2206         if (ifp->if_lagg)
2207                 (*lagg_linkstate_p)(ifp, link_state);
2208
2209         if (IS_DEFAULT_VNET(curvnet))
2210                 devctl_notify("IFNET", ifp->if_xname,
2211                     (link_state == LINK_STATE_UP) ? "LINK_UP" : "LINK_DOWN",
2212                     NULL);
2213         if (pending > 1)
2214                 if_printf(ifp, "%d link states coalesced\n", pending);
2215         if (log_link_state_change)
2216                 log(LOG_NOTICE, "%s: link state changed to %s\n", ifp->if_xname,
2217                     (link_state == LINK_STATE_UP) ? "UP" : "DOWN" );
2218         EVENTHANDLER_INVOKE(ifnet_link_event, ifp, link_state);
2219         CURVNET_RESTORE();
2220 }
2221
2222 /*
2223  * Mark an interface down and notify protocols of
2224  * the transition.
2225  */
2226 void
2227 if_down(struct ifnet *ifp)
2228 {
2229
2230         EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_DOWN);
2231         if_unroute(ifp, IFF_UP, AF_UNSPEC);
2232 }
2233
2234 /*
2235  * Mark an interface up and notify protocols of
2236  * the transition.
2237  */
2238 void
2239 if_up(struct ifnet *ifp)
2240 {
2241
2242         if_route(ifp, IFF_UP, AF_UNSPEC);
2243         EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_UP);
2244 }
2245
2246 /*
2247  * Flush an interface queue.
2248  */
2249 void
2250 if_qflush(struct ifnet *ifp)
2251 {
2252         struct mbuf *m, *n;
2253         struct ifaltq *ifq;
2254
2255         ifq = &ifp->if_snd;
2256         IFQ_LOCK(ifq);
2257 #ifdef ALTQ
2258         if (ALTQ_IS_ENABLED(ifq))
2259                 ALTQ_PURGE(ifq);
2260 #endif
2261         n = ifq->ifq_head;
2262         while ((m = n) != NULL) {
2263                 n = m->m_nextpkt;
2264                 m_freem(m);
2265         }
2266         ifq->ifq_head = 0;
2267         ifq->ifq_tail = 0;
2268         ifq->ifq_len = 0;
2269         IFQ_UNLOCK(ifq);
2270 }
2271
2272 /*
2273  * Map interface name to interface structure pointer, with or without
2274  * returning a reference.
2275  */
2276 struct ifnet *
2277 ifunit_ref(const char *name)
2278 {
2279         struct ifnet *ifp;
2280
2281         IFNET_RLOCK_NOSLEEP();
2282         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2283                 if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0 &&
2284                     !(ifp->if_flags & IFF_DYING))
2285                         break;
2286         }
2287         if (ifp != NULL)
2288                 if_ref(ifp);
2289         IFNET_RUNLOCK_NOSLEEP();
2290         return (ifp);
2291 }
2292
2293 struct ifnet *
2294 ifunit(const char *name)
2295 {
2296         struct ifnet *ifp;
2297
2298         IFNET_RLOCK_NOSLEEP();
2299         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2300                 if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0)
2301                         break;
2302         }
2303         IFNET_RUNLOCK_NOSLEEP();
2304         return (ifp);
2305 }
2306
2307 /*
2308  * Hardware specific interface ioctls.
2309  */
2310 static int
2311 ifhwioctl(u_long cmd, struct ifnet *ifp, caddr_t data, struct thread *td)
2312 {
2313         struct ifreq *ifr;
2314         int error = 0, do_ifup = 0;
2315         int new_flags, temp_flags;
2316         size_t namelen, onamelen;
2317         size_t descrlen;
2318         char *descrbuf, *odescrbuf;
2319         char new_name[IFNAMSIZ];
2320         struct ifaddr *ifa;
2321         struct sockaddr_dl *sdl;
2322
2323         ifr = (struct ifreq *)data;
2324         switch (cmd) {
2325         case SIOCGIFINDEX:
2326                 ifr->ifr_index = ifp->if_index;
2327                 break;
2328
2329         case SIOCGIFFLAGS:
2330                 temp_flags = ifp->if_flags | ifp->if_drv_flags;
2331                 ifr->ifr_flags = temp_flags & 0xffff;
2332                 ifr->ifr_flagshigh = temp_flags >> 16;
2333                 break;
2334
2335         case SIOCGIFCAP:
2336                 ifr->ifr_reqcap = ifp->if_capabilities;
2337                 ifr->ifr_curcap = ifp->if_capenable;
2338                 break;
2339
2340 #ifdef MAC
2341         case SIOCGIFMAC:
2342                 error = mac_ifnet_ioctl_get(td->td_ucred, ifr, ifp);
2343                 break;
2344 #endif
2345
2346         case SIOCGIFMETRIC:
2347                 ifr->ifr_metric = ifp->if_metric;
2348                 break;
2349
2350         case SIOCGIFMTU:
2351                 ifr->ifr_mtu = ifp->if_mtu;
2352                 break;
2353
2354         case SIOCGIFPHYS:
2355                 /* XXXGL: did this ever worked? */
2356                 ifr->ifr_phys = 0;
2357                 break;
2358
2359         case SIOCGIFDESCR:
2360                 error = 0;
2361                 sx_slock(&ifdescr_sx);
2362                 if (ifp->if_description == NULL)
2363                         error = ENOMSG;
2364                 else {
2365                         /* space for terminating nul */
2366                         descrlen = strlen(ifp->if_description) + 1;
2367                         if (ifr->ifr_buffer.length < descrlen)
2368                                 ifr->ifr_buffer.buffer = NULL;
2369                         else
2370                                 error = copyout(ifp->if_description,
2371                                     ifr->ifr_buffer.buffer, descrlen);
2372                         ifr->ifr_buffer.length = descrlen;
2373                 }
2374                 sx_sunlock(&ifdescr_sx);
2375                 break;
2376
2377         case SIOCSIFDESCR:
2378                 error = priv_check(td, PRIV_NET_SETIFDESCR);
2379                 if (error)
2380                         return (error);
2381
2382                 /*
2383                  * Copy only (length-1) bytes to make sure that
2384                  * if_description is always nul terminated.  The
2385                  * length parameter is supposed to count the
2386                  * terminating nul in.
2387                  */
2388                 if (ifr->ifr_buffer.length > ifdescr_maxlen)
2389                         return (ENAMETOOLONG);
2390                 else if (ifr->ifr_buffer.length == 0)
2391                         descrbuf = NULL;
2392                 else {
2393                         descrbuf = malloc(ifr->ifr_buffer.length, M_IFDESCR,
2394                             M_WAITOK | M_ZERO);
2395                         error = copyin(ifr->ifr_buffer.buffer, descrbuf,
2396                             ifr->ifr_buffer.length - 1);
2397                         if (error) {
2398                                 free(descrbuf, M_IFDESCR);
2399                                 break;
2400                         }
2401                 }
2402
2403                 sx_xlock(&ifdescr_sx);
2404                 odescrbuf = ifp->if_description;
2405                 ifp->if_description = descrbuf;
2406                 sx_xunlock(&ifdescr_sx);
2407
2408                 getmicrotime(&ifp->if_lastchange);
2409                 free(odescrbuf, M_IFDESCR);
2410                 break;
2411
2412         case SIOCGIFFIB:
2413                 ifr->ifr_fib = ifp->if_fib;
2414                 break;
2415
2416         case SIOCSIFFIB:
2417                 error = priv_check(td, PRIV_NET_SETIFFIB);
2418                 if (error)
2419                         return (error);
2420                 if (ifr->ifr_fib >= rt_numfibs)
2421                         return (EINVAL);
2422
2423                 ifp->if_fib = ifr->ifr_fib;
2424                 break;
2425
2426         case SIOCSIFFLAGS:
2427                 error = priv_check(td, PRIV_NET_SETIFFLAGS);
2428                 if (error)
2429                         return (error);
2430                 /*
2431                  * Currently, no driver owned flags pass the IFF_CANTCHANGE
2432                  * check, so we don't need special handling here yet.
2433                  */
2434                 new_flags = (ifr->ifr_flags & 0xffff) |
2435                     (ifr->ifr_flagshigh << 16);
2436                 if (ifp->if_flags & IFF_UP &&
2437                     (new_flags & IFF_UP) == 0) {
2438                         if_down(ifp);
2439                 } else if (new_flags & IFF_UP &&
2440                     (ifp->if_flags & IFF_UP) == 0) {
2441                         do_ifup = 1;
2442                 }
2443                 /* See if permanently promiscuous mode bit is about to flip */
2444                 if ((ifp->if_flags ^ new_flags) & IFF_PPROMISC) {
2445                         if (new_flags & IFF_PPROMISC)
2446                                 ifp->if_flags |= IFF_PROMISC;
2447                         else if (ifp->if_pcount == 0)
2448                                 ifp->if_flags &= ~IFF_PROMISC;
2449                         if (log_promisc_mode_change)
2450                                 log(LOG_INFO, "%s: permanently promiscuous mode %s\n",
2451                                     ifp->if_xname,
2452                                     ((new_flags & IFF_PPROMISC) ?
2453                                      "enabled" : "disabled"));
2454                 }
2455                 ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
2456                         (new_flags &~ IFF_CANTCHANGE);
2457                 if (ifp->if_ioctl) {
2458                         (void) (*ifp->if_ioctl)(ifp, cmd, data);
2459                 }
2460                 if (do_ifup)
2461                         if_up(ifp);
2462                 getmicrotime(&ifp->if_lastchange);
2463                 break;
2464
2465         case SIOCSIFCAP:
2466                 error = priv_check(td, PRIV_NET_SETIFCAP);
2467                 if (error)
2468                         return (error);
2469                 if (ifp->if_ioctl == NULL)
2470                         return (EOPNOTSUPP);
2471                 if (ifr->ifr_reqcap & ~ifp->if_capabilities)
2472                         return (EINVAL);
2473                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2474                 if (error == 0)
2475                         getmicrotime(&ifp->if_lastchange);
2476                 break;
2477
2478 #ifdef MAC
2479         case SIOCSIFMAC:
2480                 error = mac_ifnet_ioctl_set(td->td_ucred, ifr, ifp);
2481                 break;
2482 #endif
2483
2484         case SIOCSIFNAME:
2485                 error = priv_check(td, PRIV_NET_SETIFNAME);
2486                 if (error)
2487                         return (error);
2488                 error = copyinstr(ifr->ifr_data, new_name, IFNAMSIZ, NULL);
2489                 if (error != 0)
2490                         return (error);
2491                 if (new_name[0] == '\0')
2492                         return (EINVAL);
2493                 if (new_name[IFNAMSIZ-1] != '\0') {
2494                         new_name[IFNAMSIZ-1] = '\0';
2495                         if (strlen(new_name) == IFNAMSIZ-1)
2496                                 return (EINVAL);
2497                 }
2498                 if (ifunit(new_name) != NULL)
2499                         return (EEXIST);
2500
2501                 /*
2502                  * XXX: Locking.  Nothing else seems to lock if_flags,
2503                  * and there are numerous other races with the
2504                  * ifunit() checks not being atomic with namespace
2505                  * changes (renames, vmoves, if_attach, etc).
2506                  */
2507                 ifp->if_flags |= IFF_RENAMING;
2508
2509                 /* Announce the departure of the interface. */
2510                 rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
2511                 EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
2512
2513                 log(LOG_INFO, "%s: changing name to '%s'\n",
2514                     ifp->if_xname, new_name);
2515
2516                 IF_ADDR_WLOCK(ifp);
2517                 strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname));
2518                 ifa = ifp->if_addr;
2519                 sdl = (struct sockaddr_dl *)ifa->ifa_addr;
2520                 namelen = strlen(new_name);
2521                 onamelen = sdl->sdl_nlen;
2522                 /*
2523                  * Move the address if needed.  This is safe because we
2524                  * allocate space for a name of length IFNAMSIZ when we
2525                  * create this in if_attach().
2526                  */
2527                 if (namelen != onamelen) {
2528                         bcopy(sdl->sdl_data + onamelen,
2529                             sdl->sdl_data + namelen, sdl->sdl_alen);
2530                 }
2531                 bcopy(new_name, sdl->sdl_data, namelen);
2532                 sdl->sdl_nlen = namelen;
2533                 sdl = (struct sockaddr_dl *)ifa->ifa_netmask;
2534                 bzero(sdl->sdl_data, onamelen);
2535                 while (namelen != 0)
2536                         sdl->sdl_data[--namelen] = 0xff;
2537                 IF_ADDR_WUNLOCK(ifp);
2538
2539                 EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
2540                 /* Announce the return of the interface. */
2541                 rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
2542
2543                 ifp->if_flags &= ~IFF_RENAMING;
2544                 break;
2545
2546 #ifdef VIMAGE
2547         case SIOCSIFVNET:
2548                 error = priv_check(td, PRIV_NET_SETIFVNET);
2549                 if (error)
2550                         return (error);
2551                 error = if_vmove_loan(td, ifp, ifr->ifr_name, ifr->ifr_jid);
2552                 break;
2553 #endif
2554
2555         case SIOCSIFMETRIC:
2556                 error = priv_check(td, PRIV_NET_SETIFMETRIC);
2557                 if (error)
2558                         return (error);
2559                 ifp->if_metric = ifr->ifr_metric;
2560                 getmicrotime(&ifp->if_lastchange);
2561                 break;
2562
2563         case SIOCSIFPHYS:
2564                 error = priv_check(td, PRIV_NET_SETIFPHYS);
2565                 if (error)
2566                         return (error);
2567                 if (ifp->if_ioctl == NULL)
2568                         return (EOPNOTSUPP);
2569                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2570                 if (error == 0)
2571                         getmicrotime(&ifp->if_lastchange);
2572                 break;
2573
2574         case SIOCSIFMTU:
2575         {
2576                 u_long oldmtu = ifp->if_mtu;
2577
2578                 error = priv_check(td, PRIV_NET_SETIFMTU);
2579                 if (error)
2580                         return (error);
2581                 if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU)
2582                         return (EINVAL);
2583                 if (ifp->if_ioctl == NULL)
2584                         return (EOPNOTSUPP);
2585                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2586                 if (error == 0) {
2587                         getmicrotime(&ifp->if_lastchange);
2588                         rt_ifmsg(ifp);
2589                 }
2590                 /*
2591                  * If the link MTU changed, do network layer specific procedure.
2592                  */
2593                 if (ifp->if_mtu != oldmtu) {
2594 #ifdef INET6
2595                         nd6_setmtu(ifp);
2596 #endif
2597                         rt_updatemtu(ifp);
2598                 }
2599                 break;
2600         }
2601
2602         case SIOCADDMULTI:
2603         case SIOCDELMULTI:
2604                 if (cmd == SIOCADDMULTI)
2605                         error = priv_check(td, PRIV_NET_ADDMULTI);
2606                 else
2607                         error = priv_check(td, PRIV_NET_DELMULTI);
2608                 if (error)
2609                         return (error);
2610
2611                 /* Don't allow group membership on non-multicast interfaces. */
2612                 if ((ifp->if_flags & IFF_MULTICAST) == 0)
2613                         return (EOPNOTSUPP);
2614
2615                 /* Don't let users screw up protocols' entries. */
2616                 if (ifr->ifr_addr.sa_family != AF_LINK)
2617                         return (EINVAL);
2618
2619                 if (cmd == SIOCADDMULTI) {
2620                         struct ifmultiaddr *ifma;
2621
2622                         /*
2623                          * Userland is only permitted to join groups once
2624                          * via the if_addmulti() KPI, because it cannot hold
2625                          * struct ifmultiaddr * between calls. It may also
2626                          * lose a race while we check if the membership
2627                          * already exists.
2628                          */
2629                         IF_ADDR_RLOCK(ifp);
2630                         ifma = if_findmulti(ifp, &ifr->ifr_addr);
2631                         IF_ADDR_RUNLOCK(ifp);
2632                         if (ifma != NULL)
2633                                 error = EADDRINUSE;
2634                         else
2635                                 error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
2636                 } else {
2637                         error = if_delmulti(ifp, &ifr->ifr_addr);
2638                 }
2639                 if (error == 0)
2640                         getmicrotime(&ifp->if_lastchange);
2641                 break;
2642
2643         case SIOCSIFPHYADDR:
2644         case SIOCDIFPHYADDR:
2645 #ifdef INET6
2646         case SIOCSIFPHYADDR_IN6:
2647 #endif
2648         case SIOCSIFMEDIA:
2649         case SIOCSIFGENERIC:
2650                 error = priv_check(td, PRIV_NET_HWIOCTL);
2651                 if (error)
2652                         return (error);
2653                 if (ifp->if_ioctl == NULL)
2654                         return (EOPNOTSUPP);
2655                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2656                 if (error == 0)
2657                         getmicrotime(&ifp->if_lastchange);
2658                 break;
2659
2660         case SIOCGIFSTATUS:
2661         case SIOCGIFPSRCADDR:
2662         case SIOCGIFPDSTADDR:
2663         case SIOCGIFMEDIA:
2664         case SIOCGIFXMEDIA:
2665         case SIOCGIFGENERIC:
2666         case SIOCGIFRSSKEY:
2667         case SIOCGIFRSSHASH:
2668                 if (ifp->if_ioctl == NULL)
2669                         return (EOPNOTSUPP);
2670                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2671                 break;
2672
2673         case SIOCSIFLLADDR:
2674                 error = priv_check(td, PRIV_NET_SETLLADDR);
2675                 if (error)
2676                         return (error);
2677                 error = if_setlladdr(ifp,
2678                     ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len);
2679                 break;
2680
2681         case SIOCGHWADDR:
2682                 error = if_gethwaddr(ifp, ifr);
2683                 break;
2684
2685         case SIOCAIFGROUP:
2686         {
2687                 struct ifgroupreq *ifgr = (struct ifgroupreq *)ifr;
2688
2689                 error = priv_check(td, PRIV_NET_ADDIFGROUP);
2690                 if (error)
2691                         return (error);
2692                 if ((error = if_addgroup(ifp, ifgr->ifgr_group)))
2693                         return (error);
2694                 break;
2695         }
2696
2697         case SIOCGIFGROUP:
2698                 if ((error = if_getgroup((struct ifgroupreq *)ifr, ifp)))
2699                         return (error);
2700                 break;
2701
2702         case SIOCDIFGROUP:
2703         {
2704                 struct ifgroupreq *ifgr = (struct ifgroupreq *)ifr;
2705
2706                 error = priv_check(td, PRIV_NET_DELIFGROUP);
2707                 if (error)
2708                         return (error);
2709                 if ((error = if_delgroup(ifp, ifgr->ifgr_group)))
2710                         return (error);
2711                 break;
2712         }
2713
2714         default:
2715                 error = ENOIOCTL;
2716                 break;
2717         }
2718         return (error);
2719 }
2720
2721 #ifdef COMPAT_FREEBSD32
2722 struct ifconf32 {
2723         int32_t ifc_len;
2724         union {
2725                 uint32_t        ifcu_buf;
2726                 uint32_t        ifcu_req;
2727         } ifc_ifcu;
2728 };
2729 #define SIOCGIFCONF32   _IOWR('i', 36, struct ifconf32)
2730 #endif
2731
2732 /*
2733  * Interface ioctls.
2734  */
2735 int
2736 ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td)
2737 {
2738         struct ifnet *ifp;
2739         struct ifreq *ifr;
2740         int error;
2741         int oif_flags;
2742 #ifdef VIMAGE
2743         int shutdown;
2744 #endif
2745
2746         CURVNET_SET(so->so_vnet);
2747 #ifdef VIMAGE
2748         /* Make sure the VNET is stable. */
2749         shutdown = (so->so_vnet->vnet_state > SI_SUB_VNET &&
2750                  so->so_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
2751         if (shutdown) {
2752                 CURVNET_RESTORE();
2753                 return (EBUSY);
2754         }
2755 #endif
2756
2757
2758         switch (cmd) {
2759         case SIOCGIFCONF:
2760                 error = ifconf(cmd, data);
2761                 CURVNET_RESTORE();
2762                 return (error);
2763
2764 #ifdef COMPAT_FREEBSD32
2765         case SIOCGIFCONF32:
2766                 {
2767                         struct ifconf32 *ifc32;
2768                         struct ifconf ifc;
2769
2770                         ifc32 = (struct ifconf32 *)data;
2771                         ifc.ifc_len = ifc32->ifc_len;
2772                         ifc.ifc_buf = PTRIN(ifc32->ifc_buf);
2773
2774                         error = ifconf(SIOCGIFCONF, (void *)&ifc);
2775                         CURVNET_RESTORE();
2776                         if (error == 0)
2777                                 ifc32->ifc_len = ifc.ifc_len;
2778                         return (error);
2779                 }
2780 #endif
2781         }
2782         ifr = (struct ifreq *)data;
2783
2784         switch (cmd) {
2785 #ifdef VIMAGE
2786         case SIOCSIFRVNET:
2787                 error = priv_check(td, PRIV_NET_SETIFVNET);
2788                 if (error == 0)
2789                         error = if_vmove_reclaim(td, ifr->ifr_name,
2790                             ifr->ifr_jid);
2791                 CURVNET_RESTORE();
2792                 return (error);
2793 #endif
2794         case SIOCIFCREATE:
2795         case SIOCIFCREATE2:
2796                 error = priv_check(td, PRIV_NET_IFCREATE);
2797                 if (error == 0)
2798                         error = if_clone_create(ifr->ifr_name,
2799                             sizeof(ifr->ifr_name),
2800                             cmd == SIOCIFCREATE2 ? ifr->ifr_data : NULL);
2801                 CURVNET_RESTORE();
2802                 return (error);
2803         case SIOCIFDESTROY:
2804                 error = priv_check(td, PRIV_NET_IFDESTROY);
2805                 if (error == 0)
2806                         error = if_clone_destroy(ifr->ifr_name);
2807                 CURVNET_RESTORE();
2808                 return (error);
2809
2810         case SIOCIFGCLONERS:
2811                 error = if_clone_list((struct if_clonereq *)data);
2812                 CURVNET_RESTORE();
2813                 return (error);
2814         case SIOCGIFGMEMB:
2815                 error = if_getgroupmembers((struct ifgroupreq *)data);
2816                 CURVNET_RESTORE();
2817                 return (error);
2818 #if defined(INET) || defined(INET6)
2819         case SIOCSVH:
2820         case SIOCGVH:
2821                 if (carp_ioctl_p == NULL)
2822                         error = EPROTONOSUPPORT;
2823                 else
2824                         error = (*carp_ioctl_p)(ifr, cmd, td);
2825                 CURVNET_RESTORE();
2826                 return (error);
2827 #endif
2828         }
2829
2830         ifp = ifunit_ref(ifr->ifr_name);
2831         if (ifp == NULL) {
2832                 CURVNET_RESTORE();
2833                 return (ENXIO);
2834         }
2835
2836         error = ifhwioctl(cmd, ifp, data, td);
2837         if (error != ENOIOCTL) {
2838                 if_rele(ifp);
2839                 CURVNET_RESTORE();
2840                 return (error);
2841         }
2842
2843         oif_flags = ifp->if_flags;
2844         if (so->so_proto == NULL) {
2845                 if_rele(ifp);
2846                 CURVNET_RESTORE();
2847                 return (EOPNOTSUPP);
2848         }
2849
2850         /*
2851          * Pass the request on to the socket control method, and if the
2852          * latter returns EOPNOTSUPP, directly to the interface.
2853          *
2854          * Make an exception for the legacy SIOCSIF* requests.  Drivers
2855          * trust SIOCSIFADDR et al to come from an already privileged
2856          * layer, and do not perform any credentials checks or input
2857          * validation.
2858          */
2859         error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data,
2860             ifp, td));
2861         if (error == EOPNOTSUPP && ifp != NULL && ifp->if_ioctl != NULL &&
2862             cmd != SIOCSIFADDR && cmd != SIOCSIFBRDADDR &&
2863             cmd != SIOCSIFDSTADDR && cmd != SIOCSIFNETMASK)
2864                 error = (*ifp->if_ioctl)(ifp, cmd, data);
2865
2866         if ((oif_flags ^ ifp->if_flags) & IFF_UP) {
2867 #ifdef INET6
2868                 if (ifp->if_flags & IFF_UP)
2869                         in6_if_up(ifp);
2870 #endif
2871         }
2872         if_rele(ifp);
2873         CURVNET_RESTORE();
2874         return (error);
2875 }
2876
2877 /*
2878  * The code common to handling reference counted flags,
2879  * e.g., in ifpromisc() and if_allmulti().
2880  * The "pflag" argument can specify a permanent mode flag to check,
2881  * such as IFF_PPROMISC for promiscuous mode; should be 0 if none.
2882  *
2883  * Only to be used on stack-owned flags, not driver-owned flags.
2884  */
2885 static int
2886 if_setflag(struct ifnet *ifp, int flag, int pflag, int *refcount, int onswitch)
2887 {
2888         struct ifreq ifr;
2889         int error;
2890         int oldflags, oldcount;
2891
2892         /* Sanity checks to catch programming errors */
2893         KASSERT((flag & (IFF_DRV_OACTIVE|IFF_DRV_RUNNING)) == 0,
2894             ("%s: setting driver-owned flag %d", __func__, flag));
2895
2896         if (onswitch)
2897                 KASSERT(*refcount >= 0,
2898                     ("%s: increment negative refcount %d for flag %d",
2899                     __func__, *refcount, flag));
2900         else
2901                 KASSERT(*refcount > 0,
2902                     ("%s: decrement non-positive refcount %d for flag %d",
2903                     __func__, *refcount, flag));
2904
2905         /* In case this mode is permanent, just touch refcount */
2906         if (ifp->if_flags & pflag) {
2907                 *refcount += onswitch ? 1 : -1;
2908                 return (0);
2909         }
2910
2911         /* Save ifnet parameters for if_ioctl() may fail */
2912         oldcount = *refcount;
2913         oldflags = ifp->if_flags;
2914
2915         /*
2916          * See if we aren't the only and touching refcount is enough.
2917          * Actually toggle interface flag if we are the first or last.
2918          */
2919         if (onswitch) {
2920                 if ((*refcount)++)
2921                         return (0);
2922                 ifp->if_flags |= flag;
2923         } else {
2924                 if (--(*refcount))
2925                         return (0);
2926                 ifp->if_flags &= ~flag;
2927         }
2928
2929         /* Call down the driver since we've changed interface flags */
2930         if (ifp->if_ioctl == NULL) {
2931                 error = EOPNOTSUPP;
2932                 goto recover;
2933         }
2934         ifr.ifr_flags = ifp->if_flags & 0xffff;
2935         ifr.ifr_flagshigh = ifp->if_flags >> 16;
2936         error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
2937         if (error)
2938                 goto recover;
2939         /* Notify userland that interface flags have changed */
2940         rt_ifmsg(ifp);
2941         return (0);
2942
2943 recover:
2944         /* Recover after driver error */
2945         *refcount = oldcount;
2946         ifp->if_flags = oldflags;
2947         return (error);
2948 }
2949
2950 /*
2951  * Set/clear promiscuous mode on interface ifp based on the truth value
2952  * of pswitch.  The calls are reference counted so that only the first
2953  * "on" request actually has an effect, as does the final "off" request.
2954  * Results are undefined if the "off" and "on" requests are not matched.
2955  */
2956 int
2957 ifpromisc(struct ifnet *ifp, int pswitch)
2958 {
2959         int error;
2960         int oldflags = ifp->if_flags;
2961
2962         error = if_setflag(ifp, IFF_PROMISC, IFF_PPROMISC,
2963                            &ifp->if_pcount, pswitch);
2964         /* If promiscuous mode status has changed, log a message */
2965         if (error == 0 && ((ifp->if_flags ^ oldflags) & IFF_PROMISC) &&
2966             log_promisc_mode_change)
2967                 log(LOG_INFO, "%s: promiscuous mode %s\n",
2968                     ifp->if_xname,
2969                     (ifp->if_flags & IFF_PROMISC) ? "enabled" : "disabled");
2970         return (error);
2971 }
2972
2973 /*
2974  * Return interface configuration
2975  * of system.  List may be used
2976  * in later ioctl's (above) to get
2977  * other information.
2978  */
2979 /*ARGSUSED*/
2980 static int
2981 ifconf(u_long cmd, caddr_t data)
2982 {
2983         struct ifconf *ifc = (struct ifconf *)data;
2984         struct ifnet *ifp;
2985         struct ifaddr *ifa;
2986         struct ifreq ifr;
2987         struct sbuf *sb;
2988         int error, full = 0, valid_len, max_len;
2989
2990         /* Limit initial buffer size to MAXPHYS to avoid DoS from userspace. */
2991         max_len = MAXPHYS - 1;
2992
2993         /* Prevent hostile input from being able to crash the system */
2994         if (ifc->ifc_len <= 0)
2995                 return (EINVAL);
2996
2997 again:
2998         if (ifc->ifc_len <= max_len) {
2999                 max_len = ifc->ifc_len;
3000                 full = 1;
3001         }
3002         sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
3003         max_len = 0;
3004         valid_len = 0;
3005
3006         IFNET_RLOCK();
3007         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
3008                 int addrs;
3009
3010                 /*
3011                  * Zero the ifr_name buffer to make sure we don't
3012                  * disclose the contents of the stack.
3013                  */
3014                 memset(ifr.ifr_name, 0, sizeof(ifr.ifr_name));
3015
3016                 if (strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name))
3017                     >= sizeof(ifr.ifr_name)) {
3018                         sbuf_delete(sb);
3019                         IFNET_RUNLOCK();
3020                         return (ENAMETOOLONG);
3021                 }
3022
3023                 addrs = 0;
3024                 IF_ADDR_RLOCK(ifp);
3025                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
3026                         struct sockaddr *sa = ifa->ifa_addr;
3027
3028                         if (prison_if(curthread->td_ucred, sa) != 0)
3029                                 continue;
3030                         addrs++;
3031                         if (sa->sa_len <= sizeof(*sa)) {
3032                                 ifr.ifr_addr = *sa;
3033                                 sbuf_bcat(sb, &ifr, sizeof(ifr));
3034                                 max_len += sizeof(ifr);
3035                         } else {
3036                                 sbuf_bcat(sb, &ifr,
3037                                     offsetof(struct ifreq, ifr_addr));
3038                                 max_len += offsetof(struct ifreq, ifr_addr);
3039                                 sbuf_bcat(sb, sa, sa->sa_len);
3040                                 max_len += sa->sa_len;
3041                         }
3042
3043                         if (sbuf_error(sb) == 0)
3044                                 valid_len = sbuf_len(sb);
3045                 }
3046                 IF_ADDR_RUNLOCK(ifp);
3047                 if (addrs == 0) {
3048                         bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
3049                         sbuf_bcat(sb, &ifr, sizeof(ifr));
3050                         max_len += sizeof(ifr);
3051
3052                         if (sbuf_error(sb) == 0)
3053                                 valid_len = sbuf_len(sb);
3054                 }
3055         }
3056         IFNET_RUNLOCK();
3057
3058         /*
3059          * If we didn't allocate enough space (uncommon), try again.  If
3060          * we have already allocated as much space as we are allowed,
3061          * return what we've got.
3062          */
3063         if (valid_len != max_len && !full) {
3064                 sbuf_delete(sb);
3065                 goto again;
3066         }
3067
3068         ifc->ifc_len = valid_len;
3069         sbuf_finish(sb);
3070         error = copyout(sbuf_data(sb), ifc->ifc_req, ifc->ifc_len);
3071         sbuf_delete(sb);
3072         return (error);
3073 }
3074
3075 /*
3076  * Just like ifpromisc(), but for all-multicast-reception mode.
3077  */
3078 int
3079 if_allmulti(struct ifnet *ifp, int onswitch)
3080 {
3081
3082         return (if_setflag(ifp, IFF_ALLMULTI, 0, &ifp->if_amcount, onswitch));
3083 }
3084
3085 struct ifmultiaddr *
3086 if_findmulti(struct ifnet *ifp, const struct sockaddr *sa)
3087 {
3088         struct ifmultiaddr *ifma;
3089
3090         IF_ADDR_LOCK_ASSERT(ifp);
3091
3092         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
3093                 if (sa->sa_family == AF_LINK) {
3094                         if (sa_dl_equal(ifma->ifma_addr, sa))
3095                                 break;
3096                 } else {
3097                         if (sa_equal(ifma->ifma_addr, sa))
3098                                 break;
3099                 }
3100         }
3101
3102         return ifma;
3103 }
3104
3105 /*
3106  * Allocate a new ifmultiaddr and initialize based on passed arguments.  We
3107  * make copies of passed sockaddrs.  The ifmultiaddr will not be added to
3108  * the ifnet multicast address list here, so the caller must do that and
3109  * other setup work (such as notifying the device driver).  The reference
3110  * count is initialized to 1.
3111  */
3112 static struct ifmultiaddr *
3113 if_allocmulti(struct ifnet *ifp, struct sockaddr *sa, struct sockaddr *llsa,
3114     int mflags)
3115 {
3116         struct ifmultiaddr *ifma;
3117         struct sockaddr *dupsa;
3118
3119         ifma = malloc(sizeof *ifma, M_IFMADDR, mflags |
3120             M_ZERO);
3121         if (ifma == NULL)
3122                 return (NULL);
3123
3124         dupsa = malloc(sa->sa_len, M_IFMADDR, mflags);
3125         if (dupsa == NULL) {
3126                 free(ifma, M_IFMADDR);
3127                 return (NULL);
3128         }
3129         bcopy(sa, dupsa, sa->sa_len);
3130         ifma->ifma_addr = dupsa;
3131
3132         ifma->ifma_ifp = ifp;
3133         ifma->ifma_refcount = 1;
3134         ifma->ifma_protospec = NULL;
3135
3136         if (llsa == NULL) {
3137                 ifma->ifma_lladdr = NULL;
3138                 return (ifma);
3139         }
3140
3141         dupsa = malloc(llsa->sa_len, M_IFMADDR, mflags);
3142         if (dupsa == NULL) {
3143                 free(ifma->ifma_addr, M_IFMADDR);
3144                 free(ifma, M_IFMADDR);
3145                 return (NULL);
3146         }
3147         bcopy(llsa, dupsa, llsa->sa_len);
3148         ifma->ifma_lladdr = dupsa;
3149
3150         return (ifma);
3151 }
3152
3153 /*
3154  * if_freemulti: free ifmultiaddr structure and possibly attached related
3155  * addresses.  The caller is responsible for implementing reference
3156  * counting, notifying the driver, handling routing messages, and releasing
3157  * any dependent link layer state.
3158  */
3159 static void
3160 if_freemulti(struct ifmultiaddr *ifma)
3161 {
3162
3163         KASSERT(ifma->ifma_refcount == 0, ("if_freemulti: refcount %d",
3164             ifma->ifma_refcount));
3165
3166         if (ifma->ifma_lladdr != NULL)
3167                 free(ifma->ifma_lladdr, M_IFMADDR);
3168         free(ifma->ifma_addr, M_IFMADDR);
3169         free(ifma, M_IFMADDR);
3170 }
3171
3172 /*
3173  * Register an additional multicast address with a network interface.
3174  *
3175  * - If the address is already present, bump the reference count on the
3176  *   address and return.
3177  * - If the address is not link-layer, look up a link layer address.
3178  * - Allocate address structures for one or both addresses, and attach to the
3179  *   multicast address list on the interface.  If automatically adding a link
3180  *   layer address, the protocol address will own a reference to the link
3181  *   layer address, to be freed when it is freed.
3182  * - Notify the network device driver of an addition to the multicast address
3183  *   list.
3184  *
3185  * 'sa' points to caller-owned memory with the desired multicast address.
3186  *
3187  * 'retifma' will be used to return a pointer to the resulting multicast
3188  * address reference, if desired.
3189  */
3190 int
3191 if_addmulti(struct ifnet *ifp, struct sockaddr *sa,
3192     struct ifmultiaddr **retifma)
3193 {
3194         struct ifmultiaddr *ifma, *ll_ifma;
3195         struct sockaddr *llsa;
3196         struct sockaddr_dl sdl;
3197         int error;
3198
3199         /*
3200          * If the address is already present, return a new reference to it;
3201          * otherwise, allocate storage and set up a new address.
3202          */
3203         IF_ADDR_WLOCK(ifp);
3204         ifma = if_findmulti(ifp, sa);
3205         if (ifma != NULL) {
3206                 ifma->ifma_refcount++;
3207                 if (retifma != NULL)
3208                         *retifma = ifma;
3209                 IF_ADDR_WUNLOCK(ifp);
3210                 return (0);
3211         }
3212
3213         /*
3214          * The address isn't already present; resolve the protocol address
3215          * into a link layer address, and then look that up, bump its
3216          * refcount or allocate an ifma for that also.
3217          * Most link layer resolving functions returns address data which
3218          * fits inside default sockaddr_dl structure. However callback
3219          * can allocate another sockaddr structure, in that case we need to
3220          * free it later.
3221          */
3222         llsa = NULL;
3223         ll_ifma = NULL;
3224         if (ifp->if_resolvemulti != NULL) {
3225                 /* Provide called function with buffer size information */
3226                 sdl.sdl_len = sizeof(sdl);
3227                 llsa = (struct sockaddr *)&sdl;
3228                 error = ifp->if_resolvemulti(ifp, &llsa, sa);
3229                 if (error)
3230                         goto unlock_out;
3231         }
3232
3233         /*
3234          * Allocate the new address.  Don't hook it up yet, as we may also
3235          * need to allocate a link layer multicast address.
3236          */
3237         ifma = if_allocmulti(ifp, sa, llsa, M_NOWAIT);
3238         if (ifma == NULL) {
3239                 error = ENOMEM;
3240                 goto free_llsa_out;
3241         }
3242
3243         /*
3244          * If a link layer address is found, we'll need to see if it's
3245          * already present in the address list, or allocate is as well.
3246          * When this block finishes, the link layer address will be on the
3247          * list.
3248          */
3249         if (llsa != NULL) {
3250                 ll_ifma = if_findmulti(ifp, llsa);
3251                 if (ll_ifma == NULL) {
3252                         ll_ifma = if_allocmulti(ifp, llsa, NULL, M_NOWAIT);
3253                         if (ll_ifma == NULL) {
3254                                 --ifma->ifma_refcount;
3255                                 if_freemulti(ifma);
3256                                 error = ENOMEM;
3257                                 goto free_llsa_out;
3258                         }
3259                         TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ll_ifma,
3260                             ifma_link);
3261                 } else
3262                         ll_ifma->ifma_refcount++;
3263                 ifma->ifma_llifma = ll_ifma;
3264         }
3265
3266         /*
3267          * We now have a new multicast address, ifma, and possibly a new or
3268          * referenced link layer address.  Add the primary address to the
3269          * ifnet address list.
3270          */
3271         TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
3272
3273         if (retifma != NULL)
3274                 *retifma = ifma;
3275
3276         /*
3277          * Must generate the message while holding the lock so that 'ifma'
3278          * pointer is still valid.
3279          */
3280         rt_newmaddrmsg(RTM_NEWMADDR, ifma);
3281         IF_ADDR_WUNLOCK(ifp);
3282
3283         /*
3284          * We are certain we have added something, so call down to the
3285          * interface to let them know about it.
3286          */
3287         if (ifp->if_ioctl != NULL) {
3288                 (void) (*ifp->if_ioctl)(ifp, SIOCADDMULTI, 0);
3289         }
3290
3291         if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
3292                 link_free_sdl(llsa);
3293
3294         return (0);
3295
3296 free_llsa_out:
3297         if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
3298                 link_free_sdl(llsa);
3299
3300 unlock_out:
3301         IF_ADDR_WUNLOCK(ifp);
3302         return (error);
3303 }
3304
3305 /*
3306  * Delete a multicast group membership by network-layer group address.
3307  *
3308  * Returns ENOENT if the entry could not be found. If ifp no longer
3309  * exists, results are undefined. This entry point should only be used
3310  * from subsystems which do appropriate locking to hold ifp for the
3311  * duration of the call.
3312  * Network-layer protocol domains must use if_delmulti_ifma().
3313  */
3314 int
3315 if_delmulti(struct ifnet *ifp, struct sockaddr *sa)
3316 {
3317         struct ifmultiaddr *ifma;
3318         int lastref;
3319 #ifdef INVARIANTS
3320         struct ifnet *oifp;
3321
3322         IFNET_RLOCK_NOSLEEP();
3323         TAILQ_FOREACH(oifp, &V_ifnet, if_link)
3324                 if (ifp == oifp)
3325                         break;
3326         if (ifp != oifp)
3327                 ifp = NULL;
3328         IFNET_RUNLOCK_NOSLEEP();
3329
3330         KASSERT(ifp != NULL, ("%s: ifnet went away", __func__));
3331 #endif
3332         if (ifp == NULL)
3333                 return (ENOENT);
3334
3335         IF_ADDR_WLOCK(ifp);
3336         lastref = 0;
3337         ifma = if_findmulti(ifp, sa);
3338         if (ifma != NULL)
3339                 lastref = if_delmulti_locked(ifp, ifma, 0);
3340         IF_ADDR_WUNLOCK(ifp);
3341
3342         if (ifma == NULL)
3343                 return (ENOENT);
3344
3345         if (lastref && ifp->if_ioctl != NULL) {
3346                 (void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
3347         }
3348
3349         return (0);
3350 }
3351
3352 /*
3353  * Delete all multicast group membership for an interface.
3354  * Should be used to quickly flush all multicast filters.
3355  */
3356 void
3357 if_delallmulti(struct ifnet *ifp)
3358 {
3359         struct ifmultiaddr *ifma;
3360         struct ifmultiaddr *next;
3361
3362         IF_ADDR_WLOCK(ifp);
3363         TAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
3364                 if_delmulti_locked(ifp, ifma, 0);
3365         IF_ADDR_WUNLOCK(ifp);
3366 }
3367
3368 /*
3369  * Delete a multicast group membership by group membership pointer.
3370  * Network-layer protocol domains must use this routine.
3371  *
3372  * It is safe to call this routine if the ifp disappeared.
3373  */
3374 void
3375 if_delmulti_ifma(struct ifmultiaddr *ifma)
3376 {
3377         struct ifnet *ifp;
3378         int lastref;
3379
3380         ifp = ifma->ifma_ifp;
3381 #ifdef DIAGNOSTIC
3382         if (ifp == NULL) {
3383                 printf("%s: ifma_ifp seems to be detached\n", __func__);
3384         } else {
3385                 struct ifnet *oifp;
3386
3387                 IFNET_RLOCK_NOSLEEP();
3388                 TAILQ_FOREACH(oifp, &V_ifnet, if_link)
3389                         if (ifp == oifp)
3390                                 break;
3391                 if (ifp != oifp) {
3392                         printf("%s: ifnet %p disappeared\n", __func__, ifp);
3393                         ifp = NULL;
3394                 }
3395                 IFNET_RUNLOCK_NOSLEEP();
3396         }
3397 #endif
3398         /*
3399          * If and only if the ifnet instance exists: Acquire the address lock.
3400          */
3401         if (ifp != NULL)
3402                 IF_ADDR_WLOCK(ifp);
3403
3404         lastref = if_delmulti_locked(ifp, ifma, 0);
3405
3406         if (ifp != NULL) {
3407                 /*
3408                  * If and only if the ifnet instance exists:
3409                  *  Release the address lock.
3410                  *  If the group was left: update the hardware hash filter.
3411                  */
3412                 IF_ADDR_WUNLOCK(ifp);
3413                 if (lastref && ifp->if_ioctl != NULL) {
3414                         (void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
3415                 }
3416         }
3417 }
3418
3419 /*
3420  * Perform deletion of network-layer and/or link-layer multicast address.
3421  *
3422  * Return 0 if the reference count was decremented.
3423  * Return 1 if the final reference was released, indicating that the
3424  * hardware hash filter should be reprogrammed.
3425  */
3426 static int
3427 if_delmulti_locked(struct ifnet *ifp, struct ifmultiaddr *ifma, int detaching)
3428 {
3429         struct ifmultiaddr *ll_ifma;
3430
3431         if (ifp != NULL && ifma->ifma_ifp != NULL) {
3432                 KASSERT(ifma->ifma_ifp == ifp,
3433                     ("%s: inconsistent ifp %p", __func__, ifp));
3434                 IF_ADDR_WLOCK_ASSERT(ifp);
3435         }
3436
3437         ifp = ifma->ifma_ifp;
3438
3439         /*
3440          * If the ifnet is detaching, null out references to ifnet,
3441          * so that upper protocol layers will notice, and not attempt
3442          * to obtain locks for an ifnet which no longer exists. The
3443          * routing socket announcement must happen before the ifnet
3444          * instance is detached from the system.
3445          */
3446         if (detaching) {
3447 #ifdef DIAGNOSTIC
3448                 printf("%s: detaching ifnet instance %p\n", __func__, ifp);
3449 #endif
3450                 /*
3451                  * ifp may already be nulled out if we are being reentered
3452                  * to delete the ll_ifma.
3453                  */
3454                 if (ifp != NULL) {
3455                         rt_newmaddrmsg(RTM_DELMADDR, ifma);
3456                         ifma->ifma_ifp = NULL;
3457                 }
3458         }
3459
3460         if (--ifma->ifma_refcount > 0)
3461                 return 0;
3462
3463         /*
3464          * If this ifma is a network-layer ifma, a link-layer ifma may
3465          * have been associated with it. Release it first if so.
3466          */
3467         ll_ifma = ifma->ifma_llifma;
3468         if (ll_ifma != NULL) {
3469                 KASSERT(ifma->ifma_lladdr != NULL,
3470                     ("%s: llifma w/o lladdr", __func__));
3471                 if (detaching)
3472                         ll_ifma->ifma_ifp = NULL;       /* XXX */
3473                 if (--ll_ifma->ifma_refcount == 0) {
3474                         if (ifp != NULL) {
3475                                 TAILQ_REMOVE(&ifp->if_multiaddrs, ll_ifma,
3476                                     ifma_link);
3477                         }
3478                         if_freemulti(ll_ifma);
3479                 }
3480         }
3481
3482         if (ifp != NULL)
3483                 TAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifma_link);
3484
3485         if_freemulti(ifma);
3486
3487         /*
3488          * The last reference to this instance of struct ifmultiaddr
3489          * was released; the hardware should be notified of this change.
3490          */
3491         return 1;
3492 }
3493
3494 /*
3495  * Set the link layer address on an interface.
3496  *
3497  * At this time we only support certain types of interfaces,
3498  * and we don't allow the length of the address to change.
3499  *
3500  * Set noinline to be dtrace-friendly
3501  */
3502 __noinline int
3503 if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len)
3504 {
3505         struct sockaddr_dl *sdl;
3506         struct ifaddr *ifa;
3507         struct ifreq ifr;
3508
3509         IF_ADDR_RLOCK(ifp);
3510         ifa = ifp->if_addr;
3511         if (ifa == NULL) {
3512                 IF_ADDR_RUNLOCK(ifp);
3513                 return (EINVAL);
3514         }
3515         ifa_ref(ifa);
3516         IF_ADDR_RUNLOCK(ifp);
3517         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
3518         if (sdl == NULL) {
3519                 ifa_free(ifa);
3520                 return (EINVAL);
3521         }
3522         if (len != sdl->sdl_alen) {     /* don't allow length to change */
3523                 ifa_free(ifa);
3524                 return (EINVAL);
3525         }
3526         switch (ifp->if_type) {
3527         case IFT_ETHER:
3528         case IFT_FDDI:
3529         case IFT_XETHER:
3530         case IFT_ISO88025:
3531         case IFT_L2VLAN:
3532         case IFT_BRIDGE:
3533         case IFT_ARCNET:
3534         case IFT_IEEE8023ADLAG:
3535                 bcopy(lladdr, LLADDR(sdl), len);
3536                 ifa_free(ifa);
3537                 break;
3538         default:
3539                 ifa_free(ifa);
3540                 return (ENODEV);
3541         }
3542
3543         /*
3544          * If the interface is already up, we need
3545          * to re-init it in order to reprogram its
3546          * address filter.
3547          */
3548         if ((ifp->if_flags & IFF_UP) != 0) {
3549                 if (ifp->if_ioctl) {
3550                         ifp->if_flags &= ~IFF_UP;
3551                         ifr.ifr_flags = ifp->if_flags & 0xffff;
3552                         ifr.ifr_flagshigh = ifp->if_flags >> 16;
3553                         (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
3554                         ifp->if_flags |= IFF_UP;
3555                         ifr.ifr_flags = ifp->if_flags & 0xffff;
3556                         ifr.ifr_flagshigh = ifp->if_flags >> 16;
3557                         (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
3558                 }
3559         }
3560         EVENTHANDLER_INVOKE(iflladdr_event, ifp);
3561         return (0);
3562 }
3563
3564 /*
3565  * Compat function for handling basic encapsulation requests.
3566  * Not converted stacks (FDDI, IB, ..) supports traditional
3567  * output model: ARP (and other similar L2 protocols) are handled
3568  * inside output routine, arpresolve/nd6_resolve() returns MAC
3569  * address instead of full prepend.
3570  *
3571  * This function creates calculated header==MAC for IPv4/IPv6 and
3572  * returns EAFNOSUPPORT (which is then handled in ARP code) for other
3573  * address families.
3574  */
3575 static int
3576 if_requestencap_default(struct ifnet *ifp, struct if_encap_req *req)
3577 {
3578
3579         if (req->rtype != IFENCAP_LL)
3580                 return (EOPNOTSUPP);
3581
3582         if (req->bufsize < req->lladdr_len)
3583                 return (ENOMEM);
3584
3585         switch (req->family) {
3586         case AF_INET:
3587         case AF_INET6:
3588                 break;
3589         default:
3590                 return (EAFNOSUPPORT);
3591         }
3592
3593         /* Copy lladdr to storage as is */
3594         memmove(req->buf, req->lladdr, req->lladdr_len);
3595         req->bufsize = req->lladdr_len;
3596         req->lladdr_off = 0;
3597
3598         return (0);
3599 }
3600
3601 /*
3602  * Get the link layer address that was read from the hardware at attach.
3603  *
3604  * This is only set by Ethernet NICs (IFT_ETHER), but laggX interfaces re-type
3605  * their component interfaces as IFT_IEEE8023ADLAG.
3606  */
3607 int
3608 if_gethwaddr(struct ifnet *ifp, struct ifreq *ifr)
3609 {
3610
3611         if (ifp->if_hw_addr == NULL)
3612                 return (ENODEV);
3613
3614         switch (ifp->if_type) {
3615         case IFT_ETHER:
3616         case IFT_IEEE8023ADLAG:
3617                 bcopy(ifp->if_hw_addr, ifr->ifr_addr.sa_data, ifp->if_addrlen);
3618                 return (0);
3619         default:
3620                 return (ENODEV);
3621         }
3622 }
3623
3624 /*
3625  * The name argument must be a pointer to storage which will last as
3626  * long as the interface does.  For physical devices, the result of
3627  * device_get_name(dev) is a good choice and for pseudo-devices a
3628  * static string works well.
3629  */
3630 void
3631 if_initname(struct ifnet *ifp, const char *name, int unit)
3632 {
3633         ifp->if_dname = name;
3634         ifp->if_dunit = unit;
3635         if (unit != IF_DUNIT_NONE)
3636                 snprintf(ifp->if_xname, IFNAMSIZ, "%s%d", name, unit);
3637         else
3638                 strlcpy(ifp->if_xname, name, IFNAMSIZ);
3639 }
3640
3641 int
3642 if_printf(struct ifnet *ifp, const char * fmt, ...)
3643 {
3644         va_list ap;
3645         int retval;
3646
3647         retval = printf("%s: ", ifp->if_xname);
3648         va_start(ap, fmt);
3649         retval += vprintf(fmt, ap);
3650         va_end(ap);
3651         return (retval);
3652 }
3653
3654 void
3655 if_start(struct ifnet *ifp)
3656 {
3657
3658         (*(ifp)->if_start)(ifp);
3659 }
3660
3661 /*
3662  * Backwards compatibility interface for drivers
3663  * that have not implemented it
3664  */
3665 static int
3666 if_transmit(struct ifnet *ifp, struct mbuf *m)
3667 {
3668         int error;
3669
3670         IFQ_HANDOFF(ifp, m, error);
3671         return (error);
3672 }
3673
3674 static void
3675 if_input_default(struct ifnet *ifp __unused, struct mbuf *m)
3676 {
3677
3678         m_freem(m);
3679 }
3680
3681 int
3682 if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp, int adjust)
3683 {
3684         int active = 0;
3685
3686         IF_LOCK(ifq);
3687         if (_IF_QFULL(ifq)) {
3688                 IF_UNLOCK(ifq);
3689                 if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
3690                 m_freem(m);
3691                 return (0);
3692         }
3693         if (ifp != NULL) {
3694                 if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len + adjust);
3695                 if (m->m_flags & (M_BCAST|M_MCAST))
3696                         if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
3697                 active = ifp->if_drv_flags & IFF_DRV_OACTIVE;
3698         }
3699         _IF_ENQUEUE(ifq, m);
3700         IF_UNLOCK(ifq);
3701         if (ifp != NULL && !active)
3702                 (*(ifp)->if_start)(ifp);
3703         return (1);
3704 }
3705
3706 void
3707 if_register_com_alloc(u_char type,
3708     if_com_alloc_t *a, if_com_free_t *f)
3709 {
3710
3711         KASSERT(if_com_alloc[type] == NULL,
3712             ("if_register_com_alloc: %d already registered", type));
3713         KASSERT(if_com_free[type] == NULL,
3714             ("if_register_com_alloc: %d free already registered", type));
3715
3716         if_com_alloc[type] = a;
3717         if_com_free[type] = f;
3718 }
3719
3720 void
3721 if_deregister_com_alloc(u_char type)
3722 {
3723
3724         KASSERT(if_com_alloc[type] != NULL,
3725             ("if_deregister_com_alloc: %d not registered", type));
3726         KASSERT(if_com_free[type] != NULL,
3727             ("if_deregister_com_alloc: %d free not registered", type));
3728         if_com_alloc[type] = NULL;
3729         if_com_free[type] = NULL;
3730 }
3731
3732 /* API for driver access to network stack owned ifnet.*/
3733 uint64_t
3734 if_setbaudrate(struct ifnet *ifp, uint64_t baudrate)
3735 {
3736         uint64_t oldbrate;
3737
3738         oldbrate = ifp->if_baudrate;
3739         ifp->if_baudrate = baudrate;
3740         return (oldbrate);
3741 }
3742
3743 uint64_t
3744 if_getbaudrate(if_t ifp)
3745 {
3746
3747         return (((struct ifnet *)ifp)->if_baudrate);
3748 }
3749
3750 int
3751 if_setcapabilities(if_t ifp, int capabilities)
3752 {
3753         ((struct ifnet *)ifp)->if_capabilities = capabilities;
3754         return (0);
3755 }
3756
3757 int
3758 if_setcapabilitiesbit(if_t ifp, int setbit, int clearbit)
3759 {
3760         ((struct ifnet *)ifp)->if_capabilities |= setbit;
3761         ((struct ifnet *)ifp)->if_capabilities &= ~clearbit;
3762
3763         return (0);
3764 }
3765
3766 int
3767 if_getcapabilities(if_t ifp)
3768 {
3769         return ((struct ifnet *)ifp)->if_capabilities;
3770 }
3771
3772 int
3773 if_setcapenable(if_t ifp, int capabilities)
3774 {
3775         ((struct ifnet *)ifp)->if_capenable = capabilities;
3776         return (0);
3777 }
3778
3779 int
3780 if_setcapenablebit(if_t ifp, int setcap, int clearcap)
3781 {
3782         if(setcap)
3783                 ((struct ifnet *)ifp)->if_capenable |= setcap;
3784         if(clearcap)
3785                 ((struct ifnet *)ifp)->if_capenable &= ~clearcap;
3786
3787         return (0);
3788 }
3789
3790 const char *
3791 if_getdname(if_t ifp)
3792 {
3793         return ((struct ifnet *)ifp)->if_dname;
3794 }
3795
3796 int
3797 if_togglecapenable(if_t ifp, int togglecap)
3798 {
3799         ((struct ifnet *)ifp)->if_capenable ^= togglecap;
3800         return (0);
3801 }
3802
3803 int
3804 if_getcapenable(if_t ifp)
3805 {
3806         return ((struct ifnet *)ifp)->if_capenable;
3807 }
3808
3809 /*
3810  * This is largely undesirable because it ties ifnet to a device, but does
3811  * provide flexiblity for an embedded product vendor. Should be used with
3812  * the understanding that it violates the interface boundaries, and should be
3813  * a last resort only.
3814  */
3815 int
3816 if_setdev(if_t ifp, void *dev)
3817 {
3818         return (0);
3819 }
3820
3821 int
3822 if_setdrvflagbits(if_t ifp, int set_flags, int clear_flags)
3823 {
3824         ((struct ifnet *)ifp)->if_drv_flags |= set_flags;
3825         ((struct ifnet *)ifp)->if_drv_flags &= ~clear_flags;
3826
3827         return (0);
3828 }
3829
3830 int
3831 if_getdrvflags(if_t ifp)
3832 {
3833         return ((struct ifnet *)ifp)->if_drv_flags;
3834 }
3835
3836 int
3837 if_setdrvflags(if_t ifp, int flags)
3838 {
3839         ((struct ifnet *)ifp)->if_drv_flags = flags;
3840         return (0);
3841 }
3842
3843
3844 int
3845 if_setflags(if_t ifp, int flags)
3846 {
3847         ((struct ifnet *)ifp)->if_flags = flags;
3848         return (0);
3849 }
3850
3851 int
3852 if_setflagbits(if_t ifp, int set, int clear)
3853 {
3854         ((struct ifnet *)ifp)->if_flags |= set;
3855         ((struct ifnet *)ifp)->if_flags &= ~clear;
3856
3857         return (0);
3858 }
3859
3860 int
3861 if_getflags(if_t ifp)
3862 {
3863         return ((struct ifnet *)ifp)->if_flags;
3864 }
3865
3866 int
3867 if_clearhwassist(if_t ifp)
3868 {
3869         ((struct ifnet *)ifp)->if_hwassist = 0;
3870         return (0);
3871 }
3872
3873 int
3874 if_sethwassistbits(if_t ifp, int toset, int toclear)
3875 {
3876         ((struct ifnet *)ifp)->if_hwassist |= toset;
3877         ((struct ifnet *)ifp)->if_hwassist &= ~toclear;
3878
3879         return (0);
3880 }
3881
3882 int
3883 if_sethwassist(if_t ifp, int hwassist_bit)
3884 {
3885         ((struct ifnet *)ifp)->if_hwassist = hwassist_bit;
3886         return (0);
3887 }
3888
3889 int
3890 if_gethwassist(if_t ifp)
3891 {
3892         return ((struct ifnet *)ifp)->if_hwassist;
3893 }
3894
3895 int
3896 if_setmtu(if_t ifp, int mtu)
3897 {
3898         ((struct ifnet *)ifp)->if_mtu = mtu;
3899         return (0);
3900 }
3901
3902 int
3903 if_getmtu(if_t ifp)
3904 {
3905         return ((struct ifnet *)ifp)->if_mtu;
3906 }
3907
3908 int
3909 if_getmtu_family(if_t ifp, int family)
3910 {
3911         struct domain *dp;
3912
3913         for (dp = domains; dp; dp = dp->dom_next) {
3914                 if (dp->dom_family == family && dp->dom_ifmtu != NULL)
3915                         return (dp->dom_ifmtu((struct ifnet *)ifp));
3916         }
3917
3918         return (((struct ifnet *)ifp)->if_mtu);
3919 }
3920
3921 int
3922 if_setsoftc(if_t ifp, void *softc)
3923 {
3924         ((struct ifnet *)ifp)->if_softc = softc;
3925         return (0);
3926 }
3927
3928 void *
3929 if_getsoftc(if_t ifp)
3930 {
3931         return ((struct ifnet *)ifp)->if_softc;
3932 }
3933
3934 void
3935 if_setrcvif(struct mbuf *m, if_t ifp)
3936 {
3937         m->m_pkthdr.rcvif = (struct ifnet *)ifp;
3938 }
3939
3940 void
3941 if_setvtag(struct mbuf *m, uint16_t tag)
3942 {
3943         m->m_pkthdr.ether_vtag = tag;
3944 }
3945
3946 uint16_t
3947 if_getvtag(struct mbuf *m)
3948 {
3949
3950         return (m->m_pkthdr.ether_vtag);
3951 }
3952
3953 int
3954 if_sendq_empty(if_t ifp)
3955 {
3956         return IFQ_DRV_IS_EMPTY(&((struct ifnet *)ifp)->if_snd);
3957 }
3958
3959 struct ifaddr *
3960 if_getifaddr(if_t ifp)
3961 {
3962         return ((struct ifnet *)ifp)->if_addr;
3963 }
3964
3965 int
3966 if_getamcount(if_t ifp)
3967 {
3968         return ((struct ifnet *)ifp)->if_amcount;
3969 }
3970
3971
3972 int
3973 if_setsendqready(if_t ifp)
3974 {
3975         IFQ_SET_READY(&((struct ifnet *)ifp)->if_snd);
3976         return (0);
3977 }
3978
3979 int
3980 if_setsendqlen(if_t ifp, int tx_desc_count)
3981 {
3982         IFQ_SET_MAXLEN(&((struct ifnet *)ifp)->if_snd, tx_desc_count);
3983         ((struct ifnet *)ifp)->if_snd.ifq_drv_maxlen = tx_desc_count;
3984
3985         return (0);
3986 }
3987
3988 int
3989 if_vlantrunkinuse(if_t ifp)
3990 {
3991         return ((struct ifnet *)ifp)->if_vlantrunk != NULL?1:0;
3992 }
3993
3994 int
3995 if_input(if_t ifp, struct mbuf* sendmp)
3996 {
3997         (*((struct ifnet *)ifp)->if_input)((struct ifnet *)ifp, sendmp);
3998         return (0);
3999
4000 }
4001
4002 /* XXX */
4003 #ifndef ETH_ADDR_LEN
4004 #define ETH_ADDR_LEN 6
4005 #endif
4006
4007 int
4008 if_setupmultiaddr(if_t ifp, void *mta, int *cnt, int max)
4009 {
4010         struct ifmultiaddr *ifma;
4011         uint8_t *lmta = (uint8_t *)mta;
4012         int mcnt = 0;
4013
4014         TAILQ_FOREACH(ifma, &((struct ifnet *)ifp)->if_multiaddrs, ifma_link) {
4015                 if (ifma->ifma_addr->sa_family != AF_LINK)
4016                         continue;
4017
4018                 if (mcnt == max)
4019                         break;
4020
4021                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
4022                     &lmta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
4023                 mcnt++;
4024         }
4025         *cnt = mcnt;
4026
4027         return (0);
4028 }
4029
4030 int
4031 if_multiaddr_array(if_t ifp, void *mta, int *cnt, int max)
4032 {
4033         int error;
4034
4035         if_maddr_rlock(ifp);
4036         error = if_setupmultiaddr(ifp, mta, cnt, max);
4037         if_maddr_runlock(ifp);
4038         return (error);
4039 }
4040
4041 int
4042 if_multiaddr_count(if_t ifp, int max)
4043 {
4044         struct ifmultiaddr *ifma;
4045         int count;
4046
4047         count = 0;
4048         if_maddr_rlock(ifp);
4049         TAILQ_FOREACH(ifma, &((struct ifnet *)ifp)->if_multiaddrs, ifma_link) {
4050                 if (ifma->ifma_addr->sa_family != AF_LINK)
4051                         continue;
4052                 count++;
4053                 if (count == max)
4054                         break;
4055         }
4056         if_maddr_runlock(ifp);
4057         return (count);
4058 }
4059
4060 int
4061 if_multi_apply(struct ifnet *ifp, int (*filter)(void *, struct ifmultiaddr *, int), void *arg)
4062 {
4063         struct ifmultiaddr *ifma;
4064         int cnt = 0;
4065
4066         if_maddr_rlock(ifp);
4067         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
4068                 cnt += filter(arg, ifma, cnt);
4069         if_maddr_runlock(ifp);
4070         return (cnt);
4071 }
4072
4073 struct mbuf *
4074 if_dequeue(if_t ifp)
4075 {
4076         struct mbuf *m;
4077         IFQ_DRV_DEQUEUE(&((struct ifnet *)ifp)->if_snd, m);
4078
4079         return (m);
4080 }
4081
4082 int
4083 if_sendq_prepend(if_t ifp, struct mbuf *m)
4084 {
4085         IFQ_DRV_PREPEND(&((struct ifnet *)ifp)->if_snd, m);
4086         return (0);
4087 }
4088
4089 int
4090 if_setifheaderlen(if_t ifp, int len)
4091 {
4092         ((struct ifnet *)ifp)->if_hdrlen = len;
4093         return (0);
4094 }
4095
4096 caddr_t
4097 if_getlladdr(if_t ifp)
4098 {
4099         return (IF_LLADDR((struct ifnet *)ifp));
4100 }
4101
4102 void *
4103 if_gethandle(u_char type)
4104 {
4105         return (if_alloc(type));
4106 }
4107
4108 void
4109 if_bpfmtap(if_t ifh, struct mbuf *m)
4110 {
4111         struct ifnet *ifp = (struct ifnet *)ifh;
4112
4113         BPF_MTAP(ifp, m);
4114 }
4115
4116 void
4117 if_etherbpfmtap(if_t ifh, struct mbuf *m)
4118 {
4119         struct ifnet *ifp = (struct ifnet *)ifh;
4120
4121         ETHER_BPF_MTAP(ifp, m);
4122 }
4123
4124 void
4125 if_vlancap(if_t ifh)
4126 {
4127         struct ifnet *ifp = (struct ifnet *)ifh;
4128         VLAN_CAPABILITIES(ifp);
4129 }
4130
4131 int
4132 if_sethwtsomax(if_t ifp, u_int if_hw_tsomax)
4133 {
4134
4135         ((struct ifnet *)ifp)->if_hw_tsomax = if_hw_tsomax;
4136         return (0);
4137 }
4138
4139 int
4140 if_sethwtsomaxsegcount(if_t ifp, u_int if_hw_tsomaxsegcount)
4141 {
4142
4143         ((struct ifnet *)ifp)->if_hw_tsomaxsegcount = if_hw_tsomaxsegcount;
4144         return (0);
4145 }
4146
4147 int
4148 if_sethwtsomaxsegsize(if_t ifp, u_int if_hw_tsomaxsegsize)
4149 {
4150
4151         ((struct ifnet *)ifp)->if_hw_tsomaxsegsize = if_hw_tsomaxsegsize;
4152         return (0);
4153 }
4154
4155 u_int
4156 if_gethwtsomax(if_t ifp)
4157 {
4158
4159         return (((struct ifnet *)ifp)->if_hw_tsomax);
4160 }
4161
4162 u_int
4163 if_gethwtsomaxsegcount(if_t ifp)
4164 {
4165
4166         return (((struct ifnet *)ifp)->if_hw_tsomaxsegcount);
4167 }
4168
4169 u_int
4170 if_gethwtsomaxsegsize(if_t ifp)
4171 {
4172
4173         return (((struct ifnet *)ifp)->if_hw_tsomaxsegsize);
4174 }
4175
4176 void
4177 if_setinitfn(if_t ifp, void (*init_fn)(void *))
4178 {
4179         ((struct ifnet *)ifp)->if_init = init_fn;
4180 }
4181
4182 void
4183 if_setioctlfn(if_t ifp, int (*ioctl_fn)(if_t, u_long, caddr_t))
4184 {
4185         ((struct ifnet *)ifp)->if_ioctl = (void *)ioctl_fn;
4186 }
4187
4188 void
4189 if_setstartfn(if_t ifp, void (*start_fn)(if_t))
4190 {
4191         ((struct ifnet *)ifp)->if_start = (void *)start_fn;
4192 }
4193
4194 void
4195 if_settransmitfn(if_t ifp, if_transmit_fn_t start_fn)
4196 {
4197         ((struct ifnet *)ifp)->if_transmit = start_fn;
4198 }
4199
4200 void if_setqflushfn(if_t ifp, if_qflush_fn_t flush_fn)
4201 {
4202         ((struct ifnet *)ifp)->if_qflush = flush_fn;
4203
4204 }
4205
4206 void
4207 if_setgetcounterfn(if_t ifp, if_get_counter_t fn)
4208 {
4209
4210         ifp->if_get_counter = fn;
4211 }
4212
4213 /* Revisit these - These are inline functions originally. */
4214 int
4215 drbr_inuse_drv(if_t ifh, struct buf_ring *br)
4216 {
4217         return drbr_inuse(ifh, br);
4218 }
4219
4220 struct mbuf*
4221 drbr_dequeue_drv(if_t ifh, struct buf_ring *br)
4222 {
4223         return drbr_dequeue(ifh, br);
4224 }
4225
4226 int
4227 drbr_needs_enqueue_drv(if_t ifh, struct buf_ring *br)
4228 {
4229         return drbr_needs_enqueue(ifh, br);
4230 }
4231
4232 int
4233 drbr_enqueue_drv(if_t ifh, struct buf_ring *br, struct mbuf *m)
4234 {
4235         return drbr_enqueue(ifh, br, m);
4236
4237 }