root/net/if.c

DEFINITIONS

1. ifinit
2. if_attachsetup
3. if_alloc_sadl
4. if_free_sadl
5. if_attachdomain
6. if_attachdomain1
7. if_attachhead
8. if_attach
9. if_detach
10. if_detach_queues
11. if_clone_create
12. if_clone_destroy
13. if_clone_lookup
14. if_clone_attach
15. if_clone_detach
16. if_clone_list
17. if_congestion
18. if_congestion_clear
19. ifa_ifwithaddr
20. ifa_ifwithdstaddr
21. ifa_ifwithnet
22. ifa_ifwithaf
23. ifaof_ifpforaddr
24. link_rtrequest
25. if_down
26. if_up
27. if_link_state_change
28. if_qflush
29. if_slowtimo
30. ifunit
31. ifioctl
32. ifconf
33. if_detached_start
34. if_detached_ioctl
35. if_detached_init
36. if_detached_watchdog
37. if_creategroup
38. if_addgroup
39. if_delgroup
40. if_getgroup
41. if_getgroupmembers
42. if_getgroupattribs
43. if_setgroupattribs
44. if_group_routechange
45. if_group_egress_build
46. ifpromisc
47. sysctl_ifq
48. netrndintr

    1 /*      $OpenBSD: if.c,v 1.165 2007/07/06 14:00:59 naddy Exp $  */
    2 /*      $NetBSD: if.c,v 1.35 1996/05/07 05:26:04 thorpej Exp $  */
    4 /*
    5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    6  * All rights reserved.
    7  * 
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the project nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  * 
   20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   33 /*
   34  * Copyright (c) 1980, 1986, 1993
   35  *      The Regents of the University of California.  All rights reserved.
   36  *
   37  * Redistribution and use in source and binary forms, with or without
   38  * modification, are permitted provided that the following conditions
   39  * are met:
   40  * 1. Redistributions of source code must retain the above copyright
   41  *    notice, this list of conditions and the following disclaimer.
   42  * 2. Redistributions in binary form must reproduce the above copyright
   43  *    notice, this list of conditions and the following disclaimer in the
   44  *    documentation and/or other materials provided with the distribution.
   45  * 3. Neither the name of the University nor the names of its contributors
   46  *    may be used to endorse or promote products derived from this software
   47  *    without specific prior written permission.
   48  *
   49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   59  * SUCH DAMAGE.
   60  *
   61  *      @(#)if.c        8.3 (Berkeley) 1/4/94
   62  */
   64 #include "bluetooth.h"
   65 #include "bpfilter.h"
   66 #include "bridge.h"
   67 #include "carp.h"
   68 #include "pf.h"
   69 #include "trunk.h"
   71 #include <sys/param.h>
   72 #include <sys/systm.h>
   73 #include <sys/mbuf.h>
   74 #include <sys/proc.h>
   75 #include <sys/socket.h>
   76 #include <sys/socketvar.h>
   77 #include <sys/protosw.h>
   78 #include <sys/kernel.h>
   79 #include <sys/ioctl.h>
   80 #include <sys/domain.h>
   81 #include <sys/sysctl.h>
   83 #include <net/if.h>
   84 #include <net/if_dl.h>
   85 #include <net/if_media.h>
   86 #include <net/if_types.h>
   87 #include <net/route.h>
   88 #include <net/netisr.h>
   90 #include <dev/rndvar.h>
   92 #ifdef INET
   93 #include <netinet/in.h>
   94 #include <netinet/in_var.h>
   95 #include <netinet/if_ether.h>
   96 #include <netinet/igmp.h>
   97 #ifdef MROUTING
   98 #include <netinet/ip_mroute.h>
   99 #endif
  100 #endif
  102 #ifdef INET6
  103 #ifndef INET
  104 #include <netinet/in.h>
  105 #endif
  106 #include <netinet6/in6_ifattach.h>
  107 #include <netinet6/nd6.h>
  108 #endif
  110 #if NBPFILTER > 0
  111 #include <net/bpf.h>
  112 #endif
  114 #if NTRUNK > 0
  115 #include <net/if_trunk.h>
  116 #endif
  118 #if NBRIDGE > 0
  119 #include <net/if_bridge.h>
  120 #endif
  122 #if NCARP > 0
  123 #include <netinet/ip_carp.h>
  124 #endif
  126 #if NPF > 0
  127 #include <net/pfvar.h>
  128 #endif
  130 void    if_attachsetup(struct ifnet *);
  131 void    if_attachdomain1(struct ifnet *);
  133 int     ifqmaxlen = IFQ_MAXLEN;
  135 void    if_detach_queues(struct ifnet *, struct ifqueue *);
  136 void    if_detached_start(struct ifnet *);
  137 int     if_detached_ioctl(struct ifnet *, u_long, caddr_t);
  138 int     if_detached_init(struct ifnet *);
  139 void    if_detached_watchdog(struct ifnet *);
  141 int     if_getgroup(caddr_t, struct ifnet *);
  142 int     if_getgroupmembers(caddr_t);
  143 int     if_getgroupattribs(caddr_t);
  144 int     if_setgroupattribs(caddr_t);
  146 int     if_clone_list(struct if_clonereq *);
  147 struct if_clone *if_clone_lookup(const char *, int *);
  149 void    if_congestion_clear(void *);
  150 int     if_group_egress_build(void);
TAILQ_HEAD(, ifg_group) ifg_head;
LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
  154 int if_cloners_count;
  156 /*
  157  * Network interface utility routines.
  158  *
  159  * Routines with ifa_ifwith* names take sockaddr *'s as
  160  * parameters.
  161  */
  162 void
ifinit()
  164 {
  165         static struct timeout if_slowtim;
timeout_set(&if_slowtim, if_slowtimo, &if_slowtim);
if_slowtimo(&if_slowtim);
  170 }
  172 static int if_index = 0;
  173 int if_indexlim = 0;
  174 struct ifaddr **ifnet_addrs = NULL;
  175 struct ifnet **ifindex2ifnet = NULL;
  176 struct ifnet_head ifnet;
  177 struct ifnet *lo0ifp;
  179 /*
  180  * Attach an interface to the
  181  * list of "active" interfaces.
  182  */
  183 void
if_attachsetup(struct ifnet *ifp)
  185 {
  186         struct ifaddr *ifa;
  187         int wrapped = 0;
  189         if (ifindex2ifnet == 0)
if_index = 1;
  191         else {
  192                 while (if_index < if_indexlim &&
ifindex2ifnet[if_index] != NULL) {
if_index++;
  195                         /*
  196                          * If we hit USHRT_MAX, we skip back to 1 since
  197                          * there are a number of places where the value
  198                          * of ifp->if_index or if_index itself is compared
  199                          * to or stored in an unsigned short.  By
  200                          * jumping back, we won't botch those assignments
  201                          * or comparisons.
  202                          */
  203                         if (if_index == USHRT_MAX) {
if_index = 1;
  205                                 /*
  206                                  * However, if we have to jump back to 1
  207                                  * *twice* without finding an empty
  208                                  * slot in ifindex2ifnet[], then there
  209                                  * there are too many (>65535) interfaces.
  210                                  */
  211                                 if (wrapped++)
panic("too many interfaces");
  213                         }
  214                 }
  215         }
ifp->if_index = if_index;
  218         /*
  219          * We have some arrays that should be indexed by if_index.
  220          * since if_index will grow dynamically, they should grow too.
  221          *      struct ifaddr **ifnet_addrs
  222          *      struct ifnet **ifindex2ifnet
  223          */
  224         if (ifnet_addrs == 0 || ifindex2ifnet == 0 || if_index >= if_indexlim) {
size_t m, n, oldlim;
caddr_t q;
oldlim = if_indexlim;
  229                 if (if_indexlim == 0)
if_indexlim = 8;
  231                 while (if_index >= if_indexlim)
if_indexlim <<= 1;
  234                 /* grow ifnet_addrs */
m = oldlim * sizeof(ifa);
n = if_indexlim * sizeof(ifa);
q = (caddr_t)malloc(n, M_IFADDR, M_WAITOK);
bzero(q, n);
  239                 if (ifnet_addrs) {
bcopy((caddr_t)ifnet_addrs, q, m);
free((caddr_t)ifnet_addrs, M_IFADDR);
  242                 }
ifnet_addrs = (struct ifaddr **)q;
  245                 /* grow ifindex2ifnet */
m = oldlim * sizeof(struct ifnet *);
n = if_indexlim * sizeof(struct ifnet *);
q = (caddr_t)malloc(n, M_IFADDR, M_WAITOK);
bzero(q, n);
  250                 if (ifindex2ifnet) {
bcopy((caddr_t)ifindex2ifnet, q, m);
free((caddr_t)ifindex2ifnet, M_IFADDR);
  253                 }
ifindex2ifnet = (struct ifnet **)q;
  255         }
TAILQ_INIT(&ifp->if_groups);
if_addgroup(ifp, IFG_ALL);
ifindex2ifnet[if_index] = ifp;
  263         if (ifp->if_snd.ifq_maxlen == 0)
ifp->if_snd.ifq_maxlen = ifqmaxlen;
  265 #ifdef ALTQ
ifp->if_snd.altq_type = 0;
ifp->if_snd.altq_disc = NULL;
ifp->if_snd.altq_flags &= ALTQF_CANTCHANGE;
ifp->if_snd.altq_tbr  = NULL;
ifp->if_snd.altq_ifp  = ifp;
  271 #endif
  273         if (domains)
if_attachdomain1(ifp);
  275 #if NPF > 0
pfi_attach_ifnet(ifp);
  277 #endif
  279         /* Announce the interface. */
rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
  281 }
  283 /*
  284  * Allocate the link level name for the specified interface.  This
  285  * is an attachment helper.  It must be called after ifp->if_addrlen
  286  * is initialized, which may not be the case when if_attach() is
  287  * called.
  288  */
  289 void
if_alloc_sadl(struct ifnet *ifp)
  291 {
  292         unsigned socksize, ifasize;
  293         int namelen, masklen;
  294         struct sockaddr_dl *sdl;
  295         struct ifaddr *ifa;
  297         /*
  298          * If the interface already has a link name, release it
  299          * now.  This is useful for interfaces that can change
  300          * link types, and thus switch link names often.
  301          */
  302         if (ifp->if_sadl != NULL)
if_free_sadl(ifp);
namelen = strlen(ifp->if_xname);
  306 #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m))
masklen = _offsetof(struct sockaddr_dl, sdl_data[0]) + namelen;
socksize = masklen + ifp->if_addrlen;
  309 #define ROUNDUP(a) (1 + (((a) - 1) | (sizeof(long) - 1)))
  310         if (socksize < sizeof(*sdl))
socksize = sizeof(*sdl);
socksize = ROUNDUP(socksize);
ifasize = sizeof(*ifa) + 2 * socksize;
ifa = (struct ifaddr *)malloc(ifasize, M_IFADDR, M_WAITOK);
bzero((caddr_t)ifa, ifasize);
sdl = (struct sockaddr_dl *)(ifa + 1);
sdl->sdl_len = socksize;
sdl->sdl_family = AF_LINK;
bcopy(ifp->if_xname, sdl->sdl_data, namelen);
sdl->sdl_nlen = namelen;
sdl->sdl_alen = ifp->if_addrlen;
sdl->sdl_index = ifp->if_index;
sdl->sdl_type = ifp->if_type;
ifnet_addrs[ifp->if_index] = ifa;
ifa->ifa_ifp = ifp;
ifa->ifa_rtrequest = link_rtrequest;
TAILQ_INSERT_HEAD(&ifp->if_addrlist, ifa, ifa_list);
ifa->ifa_addr = (struct sockaddr *)sdl;
ifp->if_sadl = sdl;
sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
ifa->ifa_netmask = (struct sockaddr *)sdl;
sdl->sdl_len = masklen;
  333         while (namelen != 0)
sdl->sdl_data[--namelen] = 0xff;
  335 }
  337 /*
  338  * Free the link level name for the specified interface.  This is
  339  * a detach helper.  This is called from if_detach() or from
  340  * link layer type specific detach functions.
  341  */
  342 void
if_free_sadl(struct ifnet *ifp)
  344 {
  345         struct ifaddr *ifa;
  346         int s;
ifa = ifnet_addrs[ifp->if_index];
  349         if (ifa == NULL)
  350                 return;
s = splnet();
rtinit(ifa, RTM_DELETE, 0);
  354 #if 0
TAILQ_REMOVE(&ifp->if_addrlist, ifa, ifa_list);
ifnet_addrs[ifp->if_index] = NULL;
  357 #endif
ifp->if_sadl = NULL;
splx(s);
  361 }
  363 void
if_attachdomain()
  365 {
  366         struct ifnet *ifp;
  367         int s;
s = splnet();
  370         for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list))
if_attachdomain1(ifp);
splx(s);
  373 }
  375 void
if_attachdomain1(struct ifnet *ifp)
  377 {
  378         struct domain *dp;
  379         int s;
s = splnet();
  383         /* address family dependent data region */
bzero(ifp->if_afdata, sizeof(ifp->if_afdata));
  385         for (dp = domains; dp; dp = dp->dom_next) {
  386                 if (dp->dom_ifattach)
ifp->if_afdata[dp->dom_family] =
  388                             (*dp->dom_ifattach)(ifp);
  389         }
splx(s);
  392 }
  394 void
if_attachhead(struct ifnet *ifp)
  396 {
  397         if (if_index == 0) {
TAILQ_INIT(&ifnet);
TAILQ_INIT(&ifg_head);
  400         }
TAILQ_INIT(&ifp->if_addrlist);
ifp->if_addrhooks = malloc(sizeof(*ifp->if_addrhooks),
M_TEMP, M_NOWAIT);
  404         if (ifp->if_addrhooks == NULL)
panic("if_attachhead: malloc");
TAILQ_INIT(ifp->if_addrhooks);
ifp->if_linkstatehooks = malloc(sizeof(*ifp->if_linkstatehooks),
M_TEMP, M_NOWAIT);
  409         if (ifp->if_linkstatehooks == NULL)
panic("if_attachhead: malloc");
TAILQ_INIT(ifp->if_linkstatehooks);
ifp->if_detachhooks = malloc(sizeof(*ifp->if_detachhooks),
M_TEMP, M_NOWAIT);
  414         if (ifp->if_detachhooks == NULL)
panic("if_attachhead: malloc");
TAILQ_INIT(ifp->if_detachhooks);
TAILQ_INSERT_HEAD(&ifnet, ifp, if_list);
if_attachsetup(ifp);
  419 }
  421 void
if_attach(struct ifnet *ifp)
  423 {
  424 #if NCARP > 0
  425         struct ifnet *before = NULL;
  426 #endif
  428         if (if_index == 0) {
TAILQ_INIT(&ifnet);
TAILQ_INIT(&ifg_head);
  431         }
TAILQ_INIT(&ifp->if_addrlist);
ifp->if_addrhooks = malloc(sizeof(*ifp->if_addrhooks),
M_TEMP, M_NOWAIT);
  435         if (ifp->if_addrhooks == NULL)
panic("if_attach: malloc");
TAILQ_INIT(ifp->if_addrhooks);
ifp->if_linkstatehooks = malloc(sizeof(*ifp->if_linkstatehooks),
M_TEMP, M_NOWAIT);
  440         if (ifp->if_linkstatehooks == NULL)
panic("if_attach: malloc");
TAILQ_INIT(ifp->if_linkstatehooks);
ifp->if_detachhooks = malloc(sizeof(*ifp->if_detachhooks),
M_TEMP, M_NOWAIT);
  445         if (ifp->if_detachhooks == NULL)
panic("if_attach: malloc");
TAILQ_INIT(ifp->if_detachhooks);
  449 #if NCARP > 0
  450         if (ifp->if_type != IFT_CARP)
TAILQ_FOREACH(before, &ifnet, if_list)
  452                         if (before->if_type == IFT_CARP)
  453                                 break;
  454         if (before == NULL)
TAILQ_INSERT_TAIL(&ifnet, ifp, if_list);
  456         else
TAILQ_INSERT_BEFORE(before, ifp, if_list);
  458 #else
TAILQ_INSERT_TAIL(&ifnet, ifp, if_list);
  460 #endif
if_attachsetup(ifp);
  463 }
  465 /*
  466  * Detach an interface from everything in the kernel.  Also deallocate
  467  * private resources.
  468  * XXX So far only the INET protocol family has been looked over
  469  * wrt resource usage that needs to be decoupled.
  470  */
  471 void
if_detach(struct ifnet *ifp)
  473 {
  474         struct ifaddr *ifa;
  475         struct ifg_list *ifg;
  476         int s = splnet();
  477         struct domain *dp;
ifp->if_flags &= ~IFF_OACTIVE;
ifp->if_start = if_detached_start;
ifp->if_ioctl = if_detached_ioctl;
ifp->if_init = if_detached_init;
ifp->if_watchdog = if_detached_watchdog;
  485         /* Call detach hooks, ie. to remove vlan interfaces */
dohooks(ifp->if_detachhooks, HOOK_REMOVE | HOOK_FREE);
  488 #if NTRUNK > 0
  489         if (ifp->if_type == IFT_IEEE8023ADLAG)
trunk_port_ifdetach(ifp);
  491 #endif
  493 #if NBRIDGE > 0
  494         /* Remove the interface from any bridge it is part of.  */
  495         if (ifp->if_bridge)
bridge_ifdetach(ifp);
  497 #endif
  499 #if NCARP > 0
  500         /* Remove the interface from any carp group it is a part of.  */
  501         if (ifp->if_carp && ifp->if_type != IFT_CARP)
carp_ifdetach(ifp);
  503 #endif
  505 #if NBPFILTER > 0
bpfdetach(ifp);
  507 #endif
  508 #ifdef ALTQ
  509         if (ALTQ_IS_ENABLED(&ifp->if_snd))
altq_disable(&ifp->if_snd);
  511         if (ALTQ_IS_ATTACHED(&ifp->if_snd))
altq_detach(&ifp->if_snd);
  513 #endif
rt_if_remove(ifp);
  515 #ifdef INET
rti_delete(ifp);
  517 #if NETHER > 0
myip_ifp = NULL;
  519 #endif
  520 #ifdef MROUTING
vif_delete(ifp);
  522 #endif
  523 #endif
  524 #ifdef INET6
in6_ifdetach(ifp);
  526 #endif
  528 #if NPF > 0
pfi_detach_ifnet(ifp);
  530 #endif
  532         /*
  533          * remove packets came from ifp, from software interrupt queues.
  534          * net/netisr_dispatch.h is not usable, as some of them use
  535          * strange queue names.
  536          */
  537 #define IF_DETACH_QUEUES(x) \
  538 do { \
  539         extern struct ifqueue x; \
if_detach_queues(ifp, & x); \
  541 } while (0)
  542 #ifdef INET
IF_DETACH_QUEUES(arpintrq);
IF_DETACH_QUEUES(ipintrq);
  545 #endif
  546 #ifdef INET6
IF_DETACH_QUEUES(ip6intrq);
  548 #endif
  549 #ifdef NETATALK
IF_DETACH_QUEUES(atintrq1);
IF_DETACH_QUEUES(atintrq2);
  552 #endif
  553 #ifdef NATM
IF_DETACH_QUEUES(natmintrq);
  555 #endif
  556 #undef IF_DETACH_QUEUES
  558         /*
  559          * XXX transient ifp refs?  inpcb.ip_moptions.imo_multicast_ifp?
  560          * Other network stacks than INET?
  561          */
  563         /* Remove the interface from the list of all interfaces.  */
TAILQ_REMOVE(&ifnet, ifp, if_list);
  566         /*
  567          * Deallocate private resources.
  568          */
  569         while ((ifa = TAILQ_FIRST(&ifp->if_addrlist)) != NULL) {
TAILQ_REMOVE(&ifp->if_addrlist, ifa, ifa_list);
  571 #ifdef INET
  572                 if (ifa->ifa_addr->sa_family == AF_INET)
TAILQ_REMOVE(&in_ifaddr, (struct in_ifaddr *)ifa,
ia_list);
  575 #endif
  576                 /* XXX if_free_sadl needs this */
  577                 if (ifa == ifnet_addrs[ifp->if_index])
  578                         continue;
ifa->ifa_ifp = NULL;
IFAFREE(ifa);
  582         }
  584         for (ifg = TAILQ_FIRST(&ifp->if_groups); ifg;
ifg = TAILQ_FIRST(&ifp->if_groups))
if_delgroup(ifp, ifg->ifgl_group->ifg_group);
if_free_sadl(ifp);
ifnet_addrs[ifp->if_index]->ifa_ifp = NULL;
IFAFREE(ifnet_addrs[ifp->if_index]);
ifnet_addrs[ifp->if_index] = NULL;
free(ifp->if_addrhooks, M_TEMP);
free(ifp->if_linkstatehooks, M_TEMP);
free(ifp->if_detachhooks, M_TEMP);
  598         for (dp = domains; dp; dp = dp->dom_next) {
  599                 if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family])
  600                         (*dp->dom_ifdetach)(ifp,
ifp->if_afdata[dp->dom_family]);
  602         }
  604         /* Announce that the interface is gone. */
rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
splx(s);
  608 }
  610 void
if_detach_queues(struct ifnet *ifp, struct ifqueue *q)
  612 {
  613         struct mbuf *m, *prev, *next;
prev = NULL;
  616         for (m = q->ifq_head; m; m = next) {
next = m->m_nextpkt;
  618 #ifdef DIAGNOSTIC
  619                 if ((m->m_flags & M_PKTHDR) == 0) {
prev = m;
  621                         continue;
  622                 }
  623 #endif
  624                 if (m->m_pkthdr.rcvif != ifp) {
prev = m;
  626                         continue;
  627                 }
  629                 if (prev)
prev->m_nextpkt = m->m_nextpkt;
  631                 else
q->ifq_head = m->m_nextpkt;
  633                 if (q->ifq_tail == m)
q->ifq_tail = prev;
q->ifq_len--;
m->m_nextpkt = NULL;
m_freem(m);
IF_DROP(q);
  640         }
  641 }
  643 /*
  644  * Create a clone network interface.
  645  */
  646 int
if_clone_create(const char *name)
  648 {
  649         struct if_clone *ifc;
  650         struct ifnet *ifp;
  651         int unit, ret;
ifc = if_clone_lookup(name, &unit);
  654         if (ifc == NULL)
  655                 return (EINVAL);
  657         if (ifunit(name) != NULL)
  658                 return (EEXIST);
  660         if ((ret = (*ifc->ifc_create)(ifc, unit)) == 0 &&
  661             (ifp = ifunit(name)) != NULL)
if_addgroup(ifp, ifc->ifc_name);
  664         return (ret);
  665 }
  667 /*
  668  * Destroy a clone network interface.
  669  */
  670 int
if_clone_destroy(const char *name)
  672 {
  673         struct if_clone *ifc;
  674         struct ifnet *ifp;
  675         int s, ret;
ifc = if_clone_lookup(name, NULL);
  678         if (ifc == NULL)
  679                 return (EINVAL);
ifp = ifunit(name);
  682         if (ifp == NULL)
  683                 return (ENXIO);
  685         if (ifc->ifc_destroy == NULL)
  686                 return (EOPNOTSUPP);
  688         if (ifp->if_flags & IFF_UP) {
s = splnet();
if_down(ifp);
splx(s);
  692         }
if_delgroup(ifp, ifc->ifc_name);
  696         if ((ret = (*ifc->ifc_destroy)(ifp)) != 0)
if_addgroup(ifp, ifc->ifc_name);
  699         return (ret);
  700 }
  702 /*
  703  * Look up a network interface cloner.
  704  */
  705 struct if_clone *
if_clone_lookup(const char *name, int *unitp)
  707 {
  708         struct if_clone *ifc;
  709         const char *cp;
  710         int unit;
  712         /* separate interface name from unit */
  713         for (cp = name;
cp - name < IFNAMSIZ && *cp && (*cp < '0' || *cp > '9');
cp++)
  716                 continue;
  718         if (cp == name || cp - name == IFNAMSIZ || !*cp)
  719                 return (NULL);  /* No name or unit number */
  721         if (cp - name < IFNAMSIZ-1 && *cp == '0' && cp[1] != '\0')
  722                 return (NULL);  /* unit number 0 padded */
LIST_FOREACH(ifc, &if_cloners, ifc_list) {
  725                 if (strlen(ifc->ifc_name) == cp - name &&
  726                     !strncmp(name, ifc->ifc_name, cp - name))
  727                         break;
  728         }
  730         if (ifc == NULL)
  731                 return (NULL);
unit = 0;
  734         while (cp - name < IFNAMSIZ && *cp) {
  735                 if (*cp < '0' || *cp > '9' ||
unit > (INT_MAX - (*cp - '0')) / 10) {
  737                         /* Bogus unit number. */
  738                         return (NULL);
  739                 }
unit = (unit * 10) + (*cp++ - '0');
  741         }
  743         if (unitp != NULL)
  744                 *unitp = unit;
  745         return (ifc);
  746 }
  748 /*
  749  * Register a network interface cloner.
  750  */
  751 void
if_clone_attach(struct if_clone *ifc)
  753 {
LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
if_cloners_count++;
  756 }
  758 /*
  759  * Unregister a network interface cloner.
  760  */
  761 void
if_clone_detach(struct if_clone *ifc)
  763 {
LIST_REMOVE(ifc, ifc_list);
if_cloners_count--;
  767 }
  769 /*
  770  * Provide list of interface cloners to userspace.
  771  */
  772 int
if_clone_list(struct if_clonereq *ifcr)
  774 {
  775         char outbuf[IFNAMSIZ], *dst;
  776         struct if_clone *ifc;
  777         int count, error = 0;
ifcr->ifcr_total = if_cloners_count;
  780         if ((dst = ifcr->ifcr_buffer) == NULL) {
  781                 /* Just asking how many there are. */
  782                 return (0);
  783         }
  785         if (ifcr->ifcr_count < 0)
  786                 return (EINVAL);
count = (if_cloners_count < ifcr->ifcr_count) ?
if_cloners_count : ifcr->ifcr_count;
  791         for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0;
ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) {
bzero(outbuf, sizeof outbuf);
strlcpy(outbuf, ifc->ifc_name, IFNAMSIZ);
error = copyout(outbuf, dst, IFNAMSIZ);
  796                 if (error)
  797                         break;
  798         }
  800         return (error);
  801 }
  803 /*
  804  * set queue congestion marker and register timeout to clear it
  805  */
  806 void
if_congestion(struct ifqueue *ifq)
  808 {
  809         /* Not currently needed, all callers check this */
  810         if (ifq->ifq_congestion)
  811                 return;
ifq->ifq_congestion = malloc(sizeof(struct timeout), M_TEMP, M_NOWAIT);
  814         if (ifq->ifq_congestion == NULL)
  815                 return;
timeout_set(ifq->ifq_congestion, if_congestion_clear, ifq);
timeout_add(ifq->ifq_congestion, hz / 100);
  818 }
  820 /*
  821  * clear the congestion flag
  822  */
  823 void
if_congestion_clear(void *arg)
  825 {
  826         struct ifqueue *ifq = arg;
  827         struct timeout *to = ifq->ifq_congestion;
ifq->ifq_congestion = NULL;
free(to, M_TEMP);
  831 }
  833 /*
  834  * Locate an interface based on a complete address.
  835  */
  836 /*ARGSUSED*/
  837 struct ifaddr *
ifa_ifwithaddr(struct sockaddr *addr)
  839 {
  840         struct ifnet *ifp;
  841         struct ifaddr *ifa;
  843 #define equal(a1, a2)   \
  844         (bcmp((caddr_t)(a1), (caddr_t)(a2),     \
  845         ((struct sockaddr *)(a1))->sa_len) == 0)
TAILQ_FOREACH(ifp, &ifnet, if_list) {
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  848                 if (ifa->ifa_addr->sa_family != addr->sa_family)
  849                         continue;
  850                 if (equal(addr, ifa->ifa_addr))
  851                         return (ifa);
  852                 if ((ifp->if_flags & IFF_BROADCAST) && ifa->ifa_broadaddr &&
  853                     /* IP6 doesn't have broadcast */
ifa->ifa_broadaddr->sa_len != 0 &&
equal(ifa->ifa_broadaddr, addr))
  856                         return (ifa);
  857             }
  858         }
  859         return (NULL);
  860 }
  861 /*
  862  * Locate the point to point interface with a given destination address.
  863  */
  864 /*ARGSUSED*/
  865 struct ifaddr *
ifa_ifwithdstaddr(struct sockaddr *addr)
  867 {
  868         struct ifnet *ifp;
  869         struct ifaddr *ifa;
TAILQ_FOREACH(ifp, &ifnet, if_list) {
  872             if (ifp->if_flags & IFF_POINTOPOINT)
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  874                         if (ifa->ifa_addr->sa_family != addr->sa_family ||
ifa->ifa_dstaddr == NULL)
  876                                 continue;
  877                         if (equal(addr, ifa->ifa_dstaddr))
  878                                 return (ifa);
  879                 }
  880         }
  881         return (NULL);
  882 }
  884 /*
  885  * Find an interface on a specific network.  If many, choice
  886  * is most specific found.
  887  */
  888 struct ifaddr *
ifa_ifwithnet(struct sockaddr *addr)
  890 {
  891         struct ifnet *ifp;
  892         struct ifaddr *ifa;
  893         struct ifaddr *ifa_maybe = 0;
u_int af = addr->sa_family;
  895         char *addr_data = addr->sa_data, *cplim;
  897         if (af == AF_LINK) {
  898                 struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
  899                 if (sdl->sdl_index && sdl->sdl_index < if_indexlim &&
ifindex2ifnet[sdl->sdl_index])
  901                         return (ifnet_addrs[sdl->sdl_index]);
  902         }
TAILQ_FOREACH(ifp, &ifnet, if_list) {
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  905                         char *cp, *cp2, *cp3;
  907                         if (ifa->ifa_addr->sa_family != af ||
ifa->ifa_netmask == 0)
next: continue;
cp = addr_data;
cp2 = ifa->ifa_addr->sa_data;
cp3 = ifa->ifa_netmask->sa_data;
cplim = (char *)ifa->ifa_netmask +
ifa->ifa_netmask->sa_len;
  915                         while (cp3 < cplim)
  916                                 if ((*cp++ ^ *cp2++) & *cp3++)
  917                                     /* want to continue for() loop */
  918                                         goto next;
  919                         if (ifa_maybe == 0 ||
rn_refines((caddr_t)ifa->ifa_netmask,
  921                             (caddr_t)ifa_maybe->ifa_netmask))
ifa_maybe = ifa;
  923                 }
  924         }
  925         return (ifa_maybe);
  926 }
  928 /*
  929  * Find an interface using a specific address family
  930  */
  931 struct ifaddr *
ifa_ifwithaf(int af)
  933 {
  934         struct ifnet *ifp;
  935         struct ifaddr *ifa;
TAILQ_FOREACH(ifp, &ifnet, if_list) {
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  939                         if (ifa->ifa_addr->sa_family == af)
  940                                 return (ifa);
  941                 }
  942         }
  943         return (NULL);
  944 }
  946 /*
  947  * Find an interface address specific to an interface best matching
  948  * a given address.
  949  */
  950 struct ifaddr *
ifaof_ifpforaddr(struct sockaddr *addr, struct ifnet *ifp)
  952 {
  953         struct ifaddr *ifa;
  954         char *cp, *cp2, *cp3;
  955         char *cplim;
  956         struct ifaddr *ifa_maybe = NULL;
u_int af = addr->sa_family;
  959         if (af >= AF_MAX)
  960                 return (NULL);
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  962                 if (ifa->ifa_addr->sa_family != af)
  963                         continue;
  964                 if (ifa_maybe == NULL)
ifa_maybe = ifa;
  966                 if (ifa->ifa_netmask == 0 || ifp->if_flags & IFF_POINTOPOINT) {
  967                         if (equal(addr, ifa->ifa_addr) ||
  968                             (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr)))
  969                                 return (ifa);
  970                         continue;
  971                 }
cp = addr->sa_data;
cp2 = ifa->ifa_addr->sa_data;
cp3 = ifa->ifa_netmask->sa_data;
cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
  976                 for (; cp3 < cplim; cp3++)
  977                         if ((*cp++ ^ *cp2++) & *cp3)
  978                                 break;
  979                 if (cp3 == cplim)
  980                         return (ifa);
  981         }
  982         return (ifa_maybe);
  983 }
  985 /*
  986  * Default action when installing a route with a Link Level gateway.
  987  * Lookup an appropriate real ifa to point to.
  988  * This should be moved to /sys/net/link.c eventually.
  989  */
  990 void
link_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
  992 {
  993         struct ifaddr *ifa;
  994         struct sockaddr *dst;
  995         struct ifnet *ifp;
  997         if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) ||
  998             ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0))
  999                 return;
 1000         if ((ifa = ifaof_ifpforaddr(dst, ifp)) != NULL) {
ifa->ifa_refcnt++;
IFAFREE(rt->rt_ifa);
rt->rt_ifa = ifa;
 1004                 if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
ifa->ifa_rtrequest(cmd, rt, info);
 1006         }
 1007 }
 1009 /*
 1010  * Mark an interface down and notify protocols of
 1011  * the transition.
 1012  * NOTE: must be called at splsoftnet or equivalent.
 1013  */
 1014 void
if_down(struct ifnet *ifp)
 1016 {
 1017         struct ifaddr *ifa;
splassert(IPL_SOFTNET);
ifp->if_flags &= ~IFF_UP;
microtime(&ifp->if_lastchange);
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
 1025         }
IFQ_PURGE(&ifp->if_snd);
 1027 #if NCARP > 0
 1028         if (ifp->if_carp)
carp_carpdev_state(ifp);
 1030 #endif
 1031 #if NBRIDGE > 0
 1032         if (ifp->if_bridge)
bstp_ifstate(ifp);
 1034 #endif
rt_ifmsg(ifp);
 1036 }
 1038 /*
 1039  * Mark an interface up and notify protocols of
 1040  * the transition.
 1041  * NOTE: must be called at splsoftnet or equivalent.
 1042  */
 1043 void
if_up(struct ifnet *ifp)
 1045 {
 1046 #ifdef notyet
 1047         struct ifaddr *ifa;
 1048 #endif
splassert(IPL_SOFTNET);
ifp->if_flags |= IFF_UP;
microtime(&ifp->if_lastchange);
 1054 #ifdef notyet
 1055         /* this has no effect on IP, and will kill all ISO connections XXX */
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
pfctlinput(PRC_IFUP, ifa->ifa_addr);
 1058         }
 1059 #endif
 1060 #if NCARP > 0
 1061         if (ifp->if_carp)
carp_carpdev_state(ifp);
 1063 #endif
 1064 #if NBRIDGE > 0
 1065         if (ifp->if_bridge)
bstp_ifstate(ifp);
 1067 #endif
rt_ifmsg(ifp);
 1069 #ifdef INET6
in6_if_up(ifp);
 1071 #endif
 1072 }
 1074 /*
 1075  * Process a link state change.
 1076  * NOTE: must be called at splsoftnet or equivalent.
 1077  */
 1078 void
if_link_state_change(struct ifnet *ifp)
 1080 {
rt_ifmsg(ifp);
dohooks(ifp->if_linkstatehooks, 0);
 1083 }
 1085 /*
 1086  * Flush an interface queue.
 1087  */
 1088 void
if_qflush(struct ifqueue *ifq)
 1090 {
 1091         struct mbuf *m, *n;
n = ifq->ifq_head;
 1094         while ((m = n) != NULL) {
n = m->m_act;
m_freem(m);
 1097         }
ifq->ifq_head = 0;
ifq->ifq_tail = 0;
ifq->ifq_len = 0;
 1101 }
 1103 /*
 1104  * Handle interface watchdog timer routines.  Called
 1105  * from softclock, we decrement timers (if set) and
 1106  * call the appropriate interface routine on expiration.
 1107  */
 1108 void
if_slowtimo(void *arg)
 1110 {
 1111         struct timeout *to = (struct timeout *)arg;
 1112         struct ifnet *ifp;
 1113         int s = splnet();
TAILQ_FOREACH(ifp, &ifnet, if_list) {
 1116                 if (ifp->if_timer == 0 || --ifp->if_timer)
 1117                         continue;
 1118                 if (ifp->if_watchdog)
 1119                         (*ifp->if_watchdog)(ifp);
 1120         }
splx(s);
timeout_add(to, hz / IFNET_SLOWHZ);
 1123 }
 1125 /*
 1126  * Map interface name to
 1127  * interface structure pointer.
 1128  */
 1129 struct ifnet *
ifunit(const char *name)
 1131 {
 1132         struct ifnet *ifp;
TAILQ_FOREACH(ifp, &ifnet, if_list) {
 1135                 if (strcmp(ifp->if_xname, name) == 0)
 1136                         return (ifp);
 1137         }
 1138         return (NULL);
 1139 }
 1141 /*
 1142  * Interface ioctls.
 1143  */
 1144 int
ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p)
 1146 {
 1147         struct ifnet *ifp;
 1148         struct ifreq *ifr;
 1149         struct ifaddr *ifa;
 1150         struct sockaddr_dl *sdl;
 1151         struct ifgroupreq *ifgr;
 1152         char ifdescrbuf[IFDESCRSIZE];
 1153         char ifrtlabelbuf[RTLABEL_LEN];
 1154         int error = 0;
size_t bytesdone;
 1156         short oif_flags;
 1157         const char *label;
 1159         switch (cmd) {
 1161         case SIOCGIFCONF:
 1162         case OSIOCGIFCONF:
 1163                 return (ifconf(cmd, data));
 1164         }
ifr = (struct ifreq *)data;
 1167         switch (cmd) {
 1168         case SIOCIFCREATE:
 1169         case SIOCIFDESTROY:
 1170                 if ((error = suser(p, 0)) != 0)
 1171                         return (error);
 1172                 return ((cmd == SIOCIFCREATE) ?
if_clone_create(ifr->ifr_name) :
if_clone_destroy(ifr->ifr_name));
 1175         case SIOCIFGCLONERS:
 1176                 return (if_clone_list((struct if_clonereq *)data));
 1177         case SIOCGIFGMEMB:
 1178                 return (if_getgroupmembers(data));
 1179         case SIOCGIFGATTR:
 1180                 return (if_getgroupattribs(data));
 1181         case SIOCSIFGATTR:
 1182                 if ((error = suser(p, 0)) != 0)
 1183                         return (error);
 1184                 return (if_setgroupattribs(data));
 1185         }
ifp = ifunit(ifr->ifr_name);
 1188         if (ifp == 0)
 1189                 return (ENXIO);
oif_flags = ifp->if_flags;
 1191         switch (cmd) {
 1193         case SIOCGIFFLAGS:
ifr->ifr_flags = ifp->if_flags;
 1195                 break;
 1197         case SIOCGIFMETRIC:
ifr->ifr_metric = ifp->if_metric;
 1199                 break;
 1201         case SIOCGIFMTU:
ifr->ifr_mtu = ifp->if_mtu;
 1203                 break;
 1205         case SIOCGIFDATA:
error = copyout((caddr_t)&ifp->if_data, ifr->ifr_data,
 1207                     sizeof(ifp->if_data));
 1208                 break;
 1210         case SIOCSIFFLAGS:
 1211                 if ((error = suser(p, 0)) != 0)
 1212                         return (error);
 1213                 if (ifp->if_flags & IFF_UP && (ifr->ifr_flags & IFF_UP) == 0) {
 1214                         int s = splnet();
if_down(ifp);
splx(s);
 1217                 }
 1218                 if (ifr->ifr_flags & IFF_UP && (ifp->if_flags & IFF_UP) == 0) {
 1219                         int s = splnet();
if_up(ifp);
splx(s);
 1222                 }
ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
 1224                         (ifr->ifr_flags &~ IFF_CANTCHANGE);
 1225                 if (ifp->if_ioctl)
 1226                         (void) (*ifp->if_ioctl)(ifp, cmd, data);
 1227                 break;
 1229         case SIOCSIFMETRIC:
 1230                 if ((error = suser(p, 0)) != 0)
 1231                         return (error);
ifp->if_metric = ifr->ifr_metric;
 1233                 break;
 1235         case SIOCSIFMTU:
 1236         {
 1237 #ifdef INET6
 1238                 int oldmtu = ifp->if_mtu;
 1239 #endif
 1241                 if ((error = suser(p, 0)) != 0)
 1242                         return (error);
 1243                 if (ifp->if_ioctl == NULL)
 1244                         return (EOPNOTSUPP);
error = (*ifp->if_ioctl)(ifp, cmd, data);
 1247                 /*
 1248                  * If the link MTU changed, do network layer specific procedure.
 1249                  */
 1250 #ifdef INET6
 1251                 if (ifp->if_mtu != oldmtu)
nd6_setmtu(ifp);
 1253 #endif
 1254                 break;
 1255         }
 1257         case SIOCSIFPHYADDR:
 1258         case SIOCDIFPHYADDR:
 1259 #ifdef INET6
 1260         case SIOCSIFPHYADDR_IN6:
 1261 #endif
 1262         case SIOCSLIFPHYADDR:
 1263         case SIOCADDMULTI:
 1264         case SIOCDELMULTI:
 1265         case SIOCSIFMEDIA:
 1266                 if ((error = suser(p, 0)) != 0)
 1267                         return (error);
 1268                 /* FALLTHROUGH */
 1269         case SIOCGIFPSRCADDR:
 1270         case SIOCGIFPDSTADDR:
 1271         case SIOCGLIFPHYADDR:
 1272         case SIOCGIFMEDIA:
 1273                 if (ifp->if_ioctl == 0)
 1274                         return (EOPNOTSUPP);
error = (*ifp->if_ioctl)(ifp, cmd, data);
 1276                 break;
 1278         case SIOCGIFDESCR:
strlcpy(ifdescrbuf, ifp->if_description, IFDESCRSIZE);
error = copyoutstr(ifdescrbuf, ifr->ifr_data, IFDESCRSIZE,
 1281                     &bytesdone);
 1282                 break;
 1284         case SIOCSIFDESCR:
 1285                 if ((error = suser(p, 0)) != 0)
 1286                         return (error);
error = copyinstr(ifr->ifr_data, ifdescrbuf,
IFDESCRSIZE, &bytesdone);
 1289                 if (error == 0) {
 1290                         (void)memset(ifp->if_description, 0, IFDESCRSIZE);
strlcpy(ifp->if_description, ifdescrbuf, IFDESCRSIZE);
 1292                 }
 1293                 break;
 1295         case SIOCGIFRTLABEL:
label = rtlabel_id2name(ifp->if_rtlabelid);
strlcpy(ifrtlabelbuf, label, RTLABEL_LEN);
error = copyoutstr(ifrtlabelbuf, ifr->ifr_data, RTLABEL_LEN,
 1299                     &bytesdone);
 1300                 break;
 1302         case SIOCSIFRTLABEL:
 1303                 if ((error = suser(p, 0)) != 0)
 1304                         return (error);
error = copyinstr(ifr->ifr_data, ifrtlabelbuf,
RTLABEL_LEN, &bytesdone);
 1307                 if (error == 0) {
rtlabel_unref(ifp->if_rtlabelid);
ifp->if_rtlabelid = rtlabel_name2id(ifrtlabelbuf);
 1310                 }
 1311                 break;
 1313         case SIOCAIFGROUP:
 1314                 if ((error = suser(p, 0)))
 1315                         return (error);
 1316                 (*ifp->if_ioctl)(ifp, cmd, data); /* XXX error check */
ifgr = (struct ifgroupreq *)data;
 1318                 if ((error = if_addgroup(ifp, ifgr->ifgr_group)))
 1319                         return (error);
 1320                 break;
 1322         case SIOCGIFGROUP:
 1323                 if ((error = if_getgroup(data, ifp)))
 1324                         return (error);
 1325                 break;
 1327         case SIOCDIFGROUP:
 1328                 if ((error = suser(p, 0)))
 1329                         return (error);
 1330                 (*ifp->if_ioctl)(ifp, cmd, data); /* XXX error check */
ifgr = (struct ifgroupreq *)data;
 1332                 if ((error = if_delgroup(ifp, ifgr->ifgr_group)))
 1333                         return (error);
 1334                 break;
 1336         case SIOCSIFLLADDR:
 1337                 if ((error = suser(p, 0)))
 1338                         return (error);
ifa = ifnet_addrs[ifp->if_index];
 1340                 if (ifa == NULL)
 1341                         return (EINVAL);
sdl = (struct sockaddr_dl *)ifa->ifa_addr;
 1343                 if (sdl == NULL)
 1344                         return (EINVAL);
 1345                 if (ifr->ifr_addr.sa_len != ETHER_ADDR_LEN)
 1346                         return (EINVAL);
 1347                 if (ETHER_IS_MULTICAST(ifr->ifr_addr.sa_data))
 1348                         return (EINVAL);
 1349                 switch (ifp->if_type) {
 1350                 case IFT_ETHER:
 1351                 case IFT_CARP:
 1352                 case IFT_FDDI:
 1353                 case IFT_XETHER:
 1354                 case IFT_ISO88025:
 1355                 case IFT_L2VLAN:
bcopy((caddr_t)ifr->ifr_addr.sa_data,
 1357                             (caddr_t)((struct arpcom *)ifp)->ac_enaddr,
ETHER_ADDR_LEN);
bcopy((caddr_t)ifr->ifr_addr.sa_data,
LLADDR(sdl), ETHER_ADDR_LEN);
 1361                         break;
 1362                 default:
 1363                         return (ENODEV);
 1364                 }
 1365                 if (ifp->if_flags & IFF_UP) {
 1366                         struct ifreq ifrq;
 1367                         int s = splnet();
ifp->if_flags &= ~IFF_UP;
ifrq.ifr_flags = ifp->if_flags;
 1370                         (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifrq);
ifp->if_flags |= IFF_UP;
ifrq.ifr_flags = ifp->if_flags;
 1373                         (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifrq);
splx(s);
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
 1376                                 if (ifa->ifa_addr != NULL &&
ifa->ifa_addr->sa_family == AF_INET)
arp_ifinit((struct arpcom *)ifp, ifa);
 1379                         }
 1380                 }
 1381                 break;
 1383         default:
 1384                 if (so->so_proto == 0)
 1385                         return (EOPNOTSUPP);
 1386 #if !defined(COMPAT_43) && !defined(COMPAT_LINUX) && !defined(COMPAT_SVR4)
error = ((*so->so_proto->pr_usrreq)(so, PRU_CONTROL,
 1388                         (struct mbuf *) cmd, (struct mbuf *) data,
 1389                         (struct mbuf *) ifp));
 1390 #else
 1391             {
u_long ocmd = cmd;
 1394                 switch (cmd) {
 1396                 case SIOCSIFADDR:
 1397                 case SIOCSIFDSTADDR:
 1398                 case SIOCSIFBRDADDR:
 1399                 case SIOCSIFNETMASK:
 1400 #if BYTE_ORDER != BIG_ENDIAN
 1401                         if (ifr->ifr_addr.sa_family == 0 &&
ifr->ifr_addr.sa_len < 16) {
ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len;
ifr->ifr_addr.sa_len = 16;
 1405                         }
 1406 #else
 1407                         if (ifr->ifr_addr.sa_len == 0)
ifr->ifr_addr.sa_len = 16;
 1409 #endif
 1410                         break;
 1412                 case OSIOCGIFADDR:
cmd = SIOCGIFADDR;
 1414                         break;
 1416                 case OSIOCGIFDSTADDR:
cmd = SIOCGIFDSTADDR;
 1418                         break;
 1420                 case OSIOCGIFBRDADDR:
cmd = SIOCGIFBRDADDR;
 1422                         break;
 1424                 case OSIOCGIFNETMASK:
cmd = SIOCGIFNETMASK;
 1426                 }
error = ((*so->so_proto->pr_usrreq)(so, PRU_CONTROL,
 1428                     (struct mbuf *) cmd, (struct mbuf *) data,
 1429                     (struct mbuf *) ifp));
 1430                 switch (ocmd) {
 1432                 case OSIOCGIFADDR:
 1433                 case OSIOCGIFDSTADDR:
 1434                 case OSIOCGIFBRDADDR:
 1435                 case OSIOCGIFNETMASK:
 1436                         *(u_int16_t *)&ifr->ifr_addr = ifr->ifr_addr.sa_family;
 1437                 }
 1439             }
 1440 #endif
 1441                 break;
 1442         }
 1444         if (((oif_flags ^ ifp->if_flags) & IFF_UP) != 0) {
microtime(&ifp->if_lastchange);
 1446 #ifdef INET6
 1447                 if ((ifp->if_flags & IFF_UP) != 0) {
 1448                         int s = splnet();
in6_if_up(ifp);
splx(s);
 1451                 }
 1452 #endif
 1453         }
 1454         return (error);
 1455 }
 1457 /*
 1458  * Return interface configuration
 1459  * of system.  List may be used
 1460  * in later ioctl's (above) to get
 1461  * other information.
 1462  */
 1463 /*ARGSUSED*/
 1464 int
ifconf(u_long cmd, caddr_t data)
 1466 {
 1467         struct ifconf *ifc = (struct ifconf *)data;
 1468         struct ifnet *ifp;
 1469         struct ifaddr *ifa;
 1470         struct ifreq ifr, *ifrp;
 1471         int space = ifc->ifc_len, error = 0;
 1473         /* If ifc->ifc_len is 0, fill it in with the needed size and return. */
 1474         if (space == 0) {
TAILQ_FOREACH(ifp, &ifnet, if_list) {
 1476                         struct sockaddr *sa;
 1478                         if (TAILQ_EMPTY(&ifp->if_addrlist))
space += sizeof (ifr);
 1480                         else
TAILQ_FOREACH(ifa,
 1482                                     &ifp->if_addrlist, ifa_list) {
sa = ifa->ifa_addr;
 1484 #if defined(COMPAT_43) || defined(COMPAT_LINUX) || defined(COMPAT_SVR4)
 1485                                         if (cmd != OSIOCGIFCONF)
 1486 #endif
 1487                                         if (sa->sa_len > sizeof(*sa))
space += sa->sa_len -
 1489                                                     sizeof(*sa);
space += sizeof(ifr);
 1491                                 }
 1492                 }
ifc->ifc_len = space;
 1494                 return (0);
 1495         }
ifrp = ifc->ifc_req;
 1498         for (ifp = TAILQ_FIRST(&ifnet); space >= sizeof(ifr) &&
ifp != TAILQ_END(&ifnet); ifp = TAILQ_NEXT(ifp, if_list)) {
bcopy(ifp->if_xname, ifr.ifr_name, IFNAMSIZ);
 1501                 if (TAILQ_EMPTY(&ifp->if_addrlist)) {
bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
 1504                             sizeof(ifr));
 1505                         if (error)
 1506                                 break;
space -= sizeof (ifr), ifrp++;
 1508                 } else
 1509                         for (ifa = TAILQ_FIRST(&ifp->if_addrlist);
space >= sizeof (ifr) &&
ifa != TAILQ_END(&ifp->if_addrlist);
ifa = TAILQ_NEXT(ifa, ifa_list)) {
 1513                                 struct sockaddr *sa = ifa->ifa_addr;
 1514 #if defined(COMPAT_43) || defined(COMPAT_LINUX) || defined(COMPAT_SVR4)
 1515                                 if (cmd == OSIOCGIFCONF) {
 1516                                         struct osockaddr *osa =
 1517                                             (struct osockaddr *)&ifr.ifr_addr;
ifr.ifr_addr = *sa;
osa->sa_family = sa->sa_family;
error = copyout((caddr_t)&ifr,
 1521                                             (caddr_t)ifrp, sizeof (ifr));
ifrp++;
 1523                                 } else
 1524 #endif
 1525                                 if (sa->sa_len <= sizeof(*sa)) {
ifr.ifr_addr = *sa;
error = copyout((caddr_t)&ifr,
 1528                                             (caddr_t)ifrp, sizeof (ifr));
ifrp++;
 1530                                 } else {
space -= sa->sa_len - sizeof(*sa);
 1532                                         if (space < sizeof (ifr))
 1533                                                 break;
error = copyout((caddr_t)&ifr,
 1535                                             (caddr_t)ifrp,
 1536                                             sizeof(ifr.ifr_name));
 1537                                         if (error == 0)
error = copyout((caddr_t)sa,
 1539                                                     (caddr_t)&ifrp->ifr_addr,
sa->sa_len);
ifrp = (struct ifreq *)(sa->sa_len +
 1542                                             (caddr_t)&ifrp->ifr_addr);
 1543                                 }
 1544                                 if (error)
 1545                                         break;
space -= sizeof (ifr);
 1547                         }
 1548         }
ifc->ifc_len -= space;
 1550         return (error);
 1551 }
 1553 /*
 1554  * Dummy functions replaced in ifnet during detach (if protocols decide to
 1555  * fiddle with the if during detach.
 1556  */
 1557 void
if_detached_start(struct ifnet *ifp)
 1559 {
 1560         struct mbuf *m;
 1562         while (1) {
IF_DEQUEUE(&ifp->if_snd, m);
 1565                 if (m == NULL)
 1566                         return;
m_freem(m);
 1568         }
 1569 }
 1571 int
if_detached_ioctl(struct ifnet *ifp, u_long a, caddr_t b)
 1573 {
 1574         return ENODEV;
 1575 }
 1577 int
if_detached_init(struct ifnet *ifp)
 1579 {
 1580         return (ENXIO);
 1581 }
 1583 void
if_detached_watchdog(struct ifnet *ifp)
 1585 {
 1586         /* nothing */
 1587 }
 1589 /*
 1590  * Create interface group without members
 1591  */
 1592 struct ifg_group *
if_creategroup(const char *groupname)
 1594 {
 1595         struct ifg_group        *ifg = NULL;
 1597         if ((ifg = (struct ifg_group *)malloc(sizeof(struct ifg_group),
M_TEMP, M_NOWAIT)) == NULL)
 1599                 return (NULL);
strlcpy(ifg->ifg_group, groupname, sizeof(ifg->ifg_group));
ifg->ifg_refcnt = 0;
ifg->ifg_carp_demoted = 0;
TAILQ_INIT(&ifg->ifg_members);
 1605 #if NPF > 0
pfi_attach_ifgroup(ifg);
 1607 #endif
TAILQ_INSERT_TAIL(&ifg_head, ifg, ifg_next);
 1610         return (ifg);
 1611 }
 1613 /*
 1614  * Add a group to an interface
 1615  */
 1616 int
if_addgroup(struct ifnet *ifp, const char *groupname)
 1618 {
 1619         struct ifg_list         *ifgl;
 1620         struct ifg_group        *ifg = NULL;
 1621         struct ifg_member       *ifgm;
 1623         if (groupname[0] && groupname[strlen(groupname) - 1] >= '0' &&
groupname[strlen(groupname) - 1] <= '9')
 1625                 return (EINVAL);
TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
 1628                 if (!strcmp(ifgl->ifgl_group->ifg_group, groupname))
 1629                         return (EEXIST);
 1631         if ((ifgl = (struct ifg_list *)malloc(sizeof(struct ifg_list), M_TEMP,
M_NOWAIT)) == NULL)
 1633                 return (ENOMEM);
 1635         if ((ifgm = (struct ifg_member *)malloc(sizeof(struct ifg_member),
M_TEMP, M_NOWAIT)) == NULL) {
free(ifgl, M_TEMP);
 1638                 return (ENOMEM);
 1639         }
TAILQ_FOREACH(ifg, &ifg_head, ifg_next)
 1642                 if (!strcmp(ifg->ifg_group, groupname))
 1643                         break;
 1645         if (ifg == NULL && (ifg = if_creategroup(groupname)) == NULL) {
free(ifgl, M_TEMP);
free(ifgm, M_TEMP);
 1648                 return (ENOMEM);
 1649         }
ifg->ifg_refcnt++;
ifgl->ifgl_group = ifg;
ifgm->ifgm_ifp = ifp;
TAILQ_INSERT_TAIL(&ifg->ifg_members, ifgm, ifgm_next);
TAILQ_INSERT_TAIL(&ifp->if_groups, ifgl, ifgl_next);
 1658 #if NPF > 0
pfi_group_change(groupname);
 1660 #endif
 1662         return (0);
 1663 }
 1665 /*
 1666  * Remove a group from an interface
 1667  */
 1668 int
if_delgroup(struct ifnet *ifp, const char *groupname)
 1670 {
 1671         struct ifg_list         *ifgl;
 1672         struct ifg_member       *ifgm;
TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
 1675                 if (!strcmp(ifgl->ifgl_group->ifg_group, groupname))
 1676                         break;
 1677         if (ifgl == NULL)
 1678                 return (ENOENT);
TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
 1683                 if (ifgm->ifgm_ifp == ifp)
 1684                         break;
 1686         if (ifgm != NULL) {
TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm, ifgm_next);
free(ifgm, M_TEMP);
 1689         }
 1691         if (--ifgl->ifgl_group->ifg_refcnt == 0) {
TAILQ_REMOVE(&ifg_head, ifgl->ifgl_group, ifg_next);
 1693 #if NPF > 0
pfi_detach_ifgroup(ifgl->ifgl_group);
 1695 #endif
free(ifgl->ifgl_group, M_TEMP);
 1697         }
free(ifgl, M_TEMP);
 1701 #if NPF > 0
pfi_group_change(groupname);
 1703 #endif
 1705         return (0);
 1706 }
 1708 /*
 1709  * Stores all groups from an interface in memory pointed
 1710  * to by data
 1711  */
 1712 int
if_getgroup(caddr_t data, struct ifnet *ifp)
 1714 {
 1715         int                      len, error;
 1716         struct ifg_list         *ifgl;
 1717         struct ifg_req           ifgrq, *ifgp;
 1718         struct ifgroupreq       *ifgr = (struct ifgroupreq *)data;
 1720         if (ifgr->ifgr_len == 0) {
TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
ifgr->ifgr_len += sizeof(struct ifg_req);
 1723                 return (0);
 1724         }
len = ifgr->ifgr_len;
ifgp = ifgr->ifgr_groups;
TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
 1729                 if (len < sizeof(ifgrq))
 1730                         return (EINVAL);
bzero(&ifgrq, sizeof ifgrq);
strlcpy(ifgrq.ifgrq_group, ifgl->ifgl_group->ifg_group,
 1733                     sizeof(ifgrq.ifgrq_group));
 1734                 if ((error = copyout((caddr_t)&ifgrq, (caddr_t)ifgp,
 1735                     sizeof(struct ifg_req))))
 1736                         return (error);
len -= sizeof(ifgrq);
ifgp++;
 1739         }
 1741         return (0);
 1742 }
 1744 /*
 1745  * Stores all members of a group in memory pointed to by data
 1746  */
 1747 int
if_getgroupmembers(caddr_t data)
 1749 {
 1750         struct ifgroupreq       *ifgr = (struct ifgroupreq *)data;
 1751         struct ifg_group        *ifg;
 1752         struct ifg_member       *ifgm;
 1753         struct ifg_req           ifgrq, *ifgp;
 1754         int                      len, error;
TAILQ_FOREACH(ifg, &ifg_head, ifg_next)
 1757                 if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
 1758                         break;
 1759         if (ifg == NULL)
 1760                 return (ENOENT);
 1762         if (ifgr->ifgr_len == 0) {
TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
ifgr->ifgr_len += sizeof(ifgrq);
 1765                 return (0);
 1766         }
len = ifgr->ifgr_len;
ifgp = ifgr->ifgr_groups;
TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next) {
 1771                 if (len < sizeof(ifgrq))
 1772                         return (EINVAL);
bzero(&ifgrq, sizeof ifgrq);
strlcpy(ifgrq.ifgrq_member, ifgm->ifgm_ifp->if_xname,
 1775                     sizeof(ifgrq.ifgrq_member));
 1776                 if ((error = copyout((caddr_t)&ifgrq, (caddr_t)ifgp,
 1777                     sizeof(struct ifg_req))))
 1778                         return (error);
len -= sizeof(ifgrq);
ifgp++;
 1781         }
 1783         return (0);
 1784 }
 1786 int
if_getgroupattribs(caddr_t data)
 1788 {
 1789         struct ifgroupreq       *ifgr = (struct ifgroupreq *)data;
 1790         struct ifg_group        *ifg;
TAILQ_FOREACH(ifg, &ifg_head, ifg_next)
 1793                 if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
 1794                         break;
 1795         if (ifg == NULL)
 1796                 return (ENOENT);
ifgr->ifgr_attrib.ifg_carp_demoted = ifg->ifg_carp_demoted;
 1800         return (0);
 1801 }
 1803 int
if_setgroupattribs(caddr_t data)
 1805 {
 1806         struct ifgroupreq       *ifgr = (struct ifgroupreq *)data;
 1807         struct ifg_group        *ifg;
 1808         struct ifg_member       *ifgm;
 1809         int                      demote;
TAILQ_FOREACH(ifg, &ifg_head, ifg_next)
 1812                 if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
 1813                         break;
 1814         if (ifg == NULL)
 1815                 return (ENOENT);
demote = ifgr->ifgr_attrib.ifg_carp_demoted;
 1818         if (demote + ifg->ifg_carp_demoted > 0xff ||
demote + ifg->ifg_carp_demoted < 0)
 1820                 return (ERANGE);
ifg->ifg_carp_demoted += demote;
TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
 1825                 if (ifgm->ifgm_ifp->if_ioctl)
ifgm->ifgm_ifp->if_ioctl(ifgm->ifgm_ifp,
SIOCSIFGATTR, data);
 1828         return (0);
 1829 }
 1831 void
if_group_routechange(struct sockaddr *dst, struct sockaddr *mask)
 1833 {
 1834         switch (dst->sa_family) {
 1835         case AF_INET:
 1836                 if (satosin(dst)->sin_addr.s_addr == INADDR_ANY)
if_group_egress_build();
 1838                 break;
 1839 #ifdef INET6
 1840         case AF_INET6:
 1841                 if (IN6_ARE_ADDR_EQUAL(&(satosin6(dst))->sin6_addr,
 1842                     &in6addr_any) &&
mask && IN6_ARE_ADDR_EQUAL(&(satosin6(mask))->sin6_addr,
 1844                     &in6addr_any))
if_group_egress_build();
 1846                 break;
 1847 #endif
 1848         }
 1849 }
 1851 int
if_group_egress_build(void)
 1853 {
 1854         struct ifg_group        *ifg;
 1855         struct ifg_member       *ifgm, *next;
 1856         struct sockaddr_in       sa_in;
 1857 #ifdef INET6
 1858         struct sockaddr_in6      sa_in6;
 1859 #endif
 1860         struct radix_node       *rn;
 1861         struct rtentry          *rt;
TAILQ_FOREACH(ifg, &ifg_head, ifg_next)
 1864                 if (!strcmp(ifg->ifg_group, IFG_EGRESS))
 1865                         break;
 1867         if (ifg != NULL)
 1868                 for (ifgm = TAILQ_FIRST(&ifg->ifg_members); ifgm; ifgm = next) {
next = TAILQ_NEXT(ifgm, ifgm_next);
if_delgroup(ifgm->ifgm_ifp, IFG_EGRESS);
 1871                 }
bzero(&sa_in, sizeof(sa_in));
sa_in.sin_len = sizeof(sa_in);
sa_in.sin_family = AF_INET;
 1876         if ((rn = rt_lookup(sintosa(&sa_in), sintosa(&sa_in), 0)) != NULL) {
 1877                 do {
rt = (struct rtentry *)rn;
 1879                         if (rt->rt_ifp)
if_addgroup(rt->rt_ifp, IFG_EGRESS);
 1881 #ifndef SMALL_KERNEL
rn = rn_mpath_next(rn);
 1883 #else
rn = NULL;
 1885 #endif
 1886                 } while (rn != NULL);
 1887         }
 1889 #ifdef INET6
bcopy(&sa6_any, &sa_in6, sizeof(sa_in6));
 1891         if ((rn = rt_lookup(sin6tosa(&sa_in6), sin6tosa(&sa_in6), 0)) != NULL) {
 1892                 do {
rt = (struct rtentry *)rn;
 1894                         if (rt->rt_ifp)
if_addgroup(rt->rt_ifp, IFG_EGRESS);
 1896 #ifndef SMALL_KERNEL
rn = rn_mpath_next(rn);
 1898 #else
rn = NULL;
 1900 #endif
 1901                 } while (rn != NULL);
 1902         }
 1903 #endif
 1905         return (0);
 1906 }
 1908 /*
 1909  * Set/clear promiscuous mode on interface ifp based on the truth value
 1910  * of pswitch.  The calls are reference counted so that only the first
 1911  * "on" request actually has an effect, as does the final "off" request.
 1912  * Results are undefined if the "off" and "on" requests are not matched.
 1913  */
 1914 int
ifpromisc(struct ifnet *ifp, int pswitch)
 1916 {
 1917         struct ifreq ifr;
 1919         if (pswitch) {
 1920                 /*
 1921                  * If the device is not configured up, we cannot put it in
 1922                  * promiscuous mode.
 1923                  */
 1924                 if ((ifp->if_flags & IFF_UP) == 0)
 1925                         return (ENETDOWN);
 1926                 if (ifp->if_pcount++ != 0)
 1927                         return (0);
ifp->if_flags |= IFF_PROMISC;
 1929         } else {
 1930                 if (--ifp->if_pcount > 0)
 1931                         return (0);
ifp->if_flags &= ~IFF_PROMISC;
 1933                 /*
 1934                  * If the device is not configured up, we should not need to
 1935                  * turn off promiscuous mode (device should have turned it
 1936                  * off when interface went down; and will look at IFF_PROMISC
 1937                  * again next time interface comes up).
 1938                  */
 1939                 if ((ifp->if_flags & IFF_UP) == 0)
 1940                         return (0);
 1941         }
ifr.ifr_flags = ifp->if_flags;
 1943         return ((*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr));
 1944 }
 1946 int
sysctl_ifq(int *name, u_int namelen, void *oldp, size_t *oldlenp,
 1948     void *newp, size_t newlen, struct ifqueue *ifq)
 1949 {
 1950         /* All sysctl names at this level are terminal. */
 1951         if (namelen != 1)
 1952                 return (ENOTDIR);
 1954         switch (name[0]) {
 1955         case IFQCTL_LEN:
 1956                 return (sysctl_rdint(oldp, oldlenp, newp, ifq->ifq_len));
 1957         case IFQCTL_MAXLEN:
 1958                 return (sysctl_int(oldp, oldlenp, newp, newlen,
 1959                     &ifq->ifq_maxlen));
 1960         case IFQCTL_DROPS:
 1961                 return (sysctl_rdint(oldp, oldlenp, newp, ifq->ifq_drops));
 1962         default:
 1963                 return (EOPNOTSUPP);
 1964         }
 1965         /* NOTREACHED */
 1966 }
 1968 void
netrndintr(void)
 1970 {
add_net_randomness(0);
 1972 }