xref: /freebsd/sys/net/if.c (revision 6e6b3f7cbc89cf29eafdfa6d1613c6b1a37c364b)
1c398230bSWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1980, 1986, 1993
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
6df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
7df8bae1dSRodney W. Grimes  * are met:
8df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
9df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
10df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
12df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
13df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
14df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
15df8bae1dSRodney W. Grimes  *    without specific prior written permission.
16df8bae1dSRodney W. Grimes  *
17df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
28df8bae1dSRodney W. Grimes  *
2966afbd68SRuslan Ermilov  *	@(#)if.c	8.5 (Berkeley) 1/9/95
30c3aac50fSPeter Wemm  * $FreeBSD$
31df8bae1dSRodney W. Grimes  */
32df8bae1dSRodney W. Grimes 
335591b823SEivind Eklund #include "opt_compat.h"
34cfa1ca9dSYoshinobu Inoue #include "opt_inet6.h"
350d0f9d1eSYoshinobu Inoue #include "opt_inet.h"
36e70cd263SRobert Watson #include "opt_mac.h"
37a9771948SGleb Smirnoff #include "opt_carp.h"
385591b823SEivind Eklund 
39df8bae1dSRodney W. Grimes #include <sys/param.h>
404dcf2bbbSBrooks Davis #include <sys/types.h>
41f13ad206SJonathan Lemon #include <sys/conf.h>
424d1d4912SBruce Evans #include <sys/malloc.h>
434dcf2bbbSBrooks Davis #include <sys/sbuf.h>
44d2b4566aSJonathan Lemon #include <sys/bus.h>
45df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
46df8bae1dSRodney W. Grimes #include <sys/systm.h>
47acd3428bSRobert Watson #include <sys/priv.h>
48df8bae1dSRodney W. Grimes #include <sys/proc.h>
49df8bae1dSRodney W. Grimes #include <sys/socket.h>
50df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
51df8bae1dSRodney W. Grimes #include <sys/protosw.h>
52df8bae1dSRodney W. Grimes #include <sys/kernel.h>
53653735c4SBjoern A. Zeeb #include <sys/lock.h>
54653735c4SBjoern A. Zeeb #include <sys/rwlock.h>
5551a53488SBruce Evans #include <sys/sockio.h>
56963e4c2aSGarrett Wollman #include <sys/syslog.h>
57602d513cSGarrett Wollman #include <sys/sysctl.h>
58af5e59bfSRobert Watson #include <sys/taskqueue.h>
5931b1bfe1SHajimu UMEMOTO #include <sys/domain.h>
6091421ba2SRobert Watson #include <sys/jail.h>
61603724d3SBjoern A. Zeeb #include <sys/vimage.h>
62fa882e87SBrooks Davis #include <machine/stdarg.h>
636e6b3f7cSQing Li #include <vm/uma.h>
64df8bae1dSRodney W. Grimes 
65df8bae1dSRodney W. Grimes #include <net/if.h>
665a97c9d4SBjoern A. Zeeb #include <net/if_arp.h>
67f889d2efSBrooks Davis #include <net/if_clone.h>
68df8bae1dSRodney W. Grimes #include <net/if_dl.h>
6966ce51ceSArchie Cobbs #include <net/if_types.h>
7030aad87dSBrooks Davis #include <net/if_var.h>
719448326fSPoul-Henning Kamp #include <net/radix.h>
725500d3beSWarner Losh #include <net/route.h>
734b79449eSBjoern A. Zeeb #include <net/vnet.h>
74df8bae1dSRodney W. Grimes 
750d0f9d1eSYoshinobu Inoue #if defined(INET) || defined(INET6)
7682cd038dSYoshinobu Inoue /*XXX*/
7782cd038dSYoshinobu Inoue #include <netinet/in.h>
780d0f9d1eSYoshinobu Inoue #include <netinet/in_var.h>
793411310dSYoshinobu Inoue #ifdef INET6
80978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_var.h>
81978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_ifattach.h>
823411310dSYoshinobu Inoue #endif
8382cd038dSYoshinobu Inoue #endif
84c0933269SPeter Wemm #ifdef INET
85c0933269SPeter Wemm #include <netinet/if_ether.h>
864b79449eSBjoern A. Zeeb #include <netinet/vinet.h>
87c0933269SPeter Wemm #endif
88a9771948SGleb Smirnoff #ifdef DEV_CARP
89a9771948SGleb Smirnoff #include <netinet/ip_carp.h>
90a9771948SGleb Smirnoff #endif
9182cd038dSYoshinobu Inoue 
92aed55708SRobert Watson #include <security/mac/mac_framework.h>
93aed55708SRobert Watson 
94385195c0SMarko Zec #ifndef VIMAGE
95385195c0SMarko Zec #ifndef VIMAGE_GLOBALS
96385195c0SMarko Zec struct vnet_net vnet_net_0;
97385195c0SMarko Zec #endif
98385195c0SMarko Zec #endif
99385195c0SMarko Zec 
1005515c2e7SGleb Smirnoff SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers");
1015515c2e7SGleb Smirnoff SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management");
1025515c2e7SGleb Smirnoff 
1035515c2e7SGleb Smirnoff /* Log link state change events */
1045515c2e7SGleb Smirnoff static int log_link_state_change = 1;
1055515c2e7SGleb Smirnoff 
1065515c2e7SGleb Smirnoff SYSCTL_INT(_net_link, OID_AUTO, log_link_state_change, CTLFLAG_RW,
1075515c2e7SGleb Smirnoff 	&log_link_state_change, 0,
1085515c2e7SGleb Smirnoff 	"log interface link state change events");
1095515c2e7SGleb Smirnoff 
1108f867517SAndrew Thompson void	(*bstp_linkstate_p)(struct ifnet *ifp, int state);
1111c7899c7SGleb Smirnoff void	(*ng_ether_link_state_p)(struct ifnet *ifp, int state);
11218242d3bSAndrew Thompson void	(*lagg_linkstate_p)(struct ifnet *ifp, int state);
1131c7899c7SGleb Smirnoff 
1144cb655c0SMax Laier struct mbuf *(*tbr_dequeue_ptr)(struct ifaltq *, int) = NULL;
1154cb655c0SMax Laier 
116ec002feeSBruce M Simpson /*
117ec002feeSBruce M Simpson  * XXX: Style; these should be sorted alphabetically, and unprototyped
118ec002feeSBruce M Simpson  * static functions should be prototyped. Currently they are sorted by
119ec002feeSBruce M Simpson  * declaration order.
120ec002feeSBruce M Simpson  */
12131b1bfe1SHajimu UMEMOTO static void	if_attachdomain(void *);
12231b1bfe1SHajimu UMEMOTO static void	if_attachdomain1(struct ifnet *);
1230b59d917SJonathan Lemon static int	ifconf(u_long, caddr_t);
124ec002feeSBruce M Simpson static void	if_freemulti(struct ifmultiaddr *);
125f9132cebSJonathan Lemon static void	if_grow(void);
126f9132cebSJonathan Lemon static void	if_init(void *);
127db7f0b97SKip Macy static void	if_qflush(struct ifnet *);
1288614fb12SMax Laier static void	if_route(struct ifnet *, int flag, int fam);
1291a3b6859SYaroslav Tykhiy static int	if_setflag(struct ifnet *, int, int, int *, int);
1300b59d917SJonathan Lemon static void	if_slowtimo(void *);
131db7f0b97SKip Macy static int	if_transmit(struct ifnet *ifp, struct mbuf *m);
1328614fb12SMax Laier static void	if_unroute(struct ifnet *, int flag, int fam);
1338071913dSRuslan Ermilov static void	link_rtrequest(int, struct rtentry *, struct rt_addrinfo *);
1340b59d917SJonathan Lemon static int	if_rtdel(struct radix_node *, void *);
135f13ad206SJonathan Lemon static int	ifhwioctl(u_long, struct ifnet *, caddr_t, struct thread *);
136ec002feeSBruce M Simpson static int	if_delmulti_locked(struct ifnet *, struct ifmultiaddr *, int);
137af5e59bfSRobert Watson static void	if_start_deferred(void *context, int pending);
13868a3482fSGleb Smirnoff static void	do_link_state_change(void *, int);
1390dad3f0eSMax Laier static int	if_getgroup(struct ifgroupreq *, struct ifnet *);
1400dad3f0eSMax Laier static int	if_getgroupmembers(struct ifgroupreq *);
141db7f0b97SKip Macy 
14282cd038dSYoshinobu Inoue #ifdef INET6
14382cd038dSYoshinobu Inoue /*
14482cd038dSYoshinobu Inoue  * XXX: declare here to avoid to include many inet6 related files..
14582cd038dSYoshinobu Inoue  * should be more generalized?
14682cd038dSYoshinobu Inoue  */
147929ddbbbSAlfred Perlstein extern void	nd6_setmtu(struct ifnet *);
14882cd038dSYoshinobu Inoue #endif
14982cd038dSYoshinobu Inoue 
15044e33a07SMarko Zec #ifdef VIMAGE_GLOBALS
1510b59d917SJonathan Lemon struct	ifnethead ifnet;	/* depend on static init XXX */
1520dad3f0eSMax Laier struct	ifgrouphead ifg_head;
15344e33a07SMarko Zec int	if_index;
15444e33a07SMarko Zec static	int if_indexlim;
15544e33a07SMarko Zec /* Table of ifnet/cdev by index.  Locked with ifnet_lock. */
15644e33a07SMarko Zec static struct ifindex_entry *ifindex_table;
15744e33a07SMarko Zec static struct	knlist ifklist;
15844e33a07SMarko Zec #endif
15944e33a07SMarko Zec 
16044e33a07SMarko Zec int	ifqmaxlen = IFQ_MAXLEN;
161b30a244cSJeffrey Hsu struct	mtx ifnet_lock;
162fc74a9f9SBrooks Davis static	if_com_alloc_t *if_com_alloc[256];
163fc74a9f9SBrooks Davis static	if_com_free_t *if_com_free[256];
1640b59d917SJonathan Lemon 
1659a2a57a1SJonathan Lemon static void	filt_netdetach(struct knote *kn);
1669a2a57a1SJonathan Lemon static int	filt_netdev(struct knote *kn, long hint);
1679a2a57a1SJonathan Lemon 
1689a2a57a1SJonathan Lemon static struct filterops netdev_filtops =
1699a2a57a1SJonathan Lemon     { 1, NULL, filt_netdetach, filt_netdev };
1709a2a57a1SJonathan Lemon 
171385195c0SMarko Zec #ifndef VIMAGE_GLOBALS
172385195c0SMarko Zec static struct vnet_symmap vnet_net_symmap[] = {
173385195c0SMarko Zec 	VNET_SYMMAP(net, ifnet),
174385195c0SMarko Zec 	VNET_SYMMAP(net, rt_tables),
175385195c0SMarko Zec 	VNET_SYMMAP(net, rtstat),
176385195c0SMarko Zec 	VNET_SYMMAP(net, rttrash),
177385195c0SMarko Zec 	VNET_SYMMAP_END
178385195c0SMarko Zec };
179385195c0SMarko Zec 
180385195c0SMarko Zec VNET_MOD_DECLARE(NET, net, vnet_net_iattach, vnet_net_idetach,
181385195c0SMarko Zec     NONE, vnet_net_symmap)
182385195c0SMarko Zec #endif
183385195c0SMarko Zec 
1840b59d917SJonathan Lemon /*
1850b59d917SJonathan Lemon  * System initialization
1860b59d917SJonathan Lemon  */
187237fdd78SRobert Watson SYSINIT(interfaces, SI_SUB_INIT_IF, SI_ORDER_FIRST, if_init, NULL);
188d94ccb09SBrooks Davis SYSINIT(interface_check, SI_SUB_PROTO_IF, SI_ORDER_FIRST, if_slowtimo, NULL);
1890b59d917SJonathan Lemon 
190fc74a9f9SBrooks Davis MALLOC_DEFINE(M_IFNET, "ifnet", "interface internals");
1910b59d917SJonathan Lemon MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
1920b59d917SJonathan Lemon MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
19330aad87dSBrooks Davis 
19402f4879dSRobert Watson struct ifnet *
19502f4879dSRobert Watson ifnet_byindex(u_short idx)
19602f4879dSRobert Watson {
1978b615593SMarko Zec 	INIT_VNET_NET(curvnet);
19802f4879dSRobert Watson 	struct ifnet *ifp;
19902f4879dSRobert Watson 
20002f4879dSRobert Watson 	IFNET_RLOCK();
201603724d3SBjoern A. Zeeb 	ifp = V_ifindex_table[idx].ife_ifnet;
20202f4879dSRobert Watson 	IFNET_RUNLOCK();
20302f4879dSRobert Watson 	return (ifp);
20402f4879dSRobert Watson }
20502f4879dSRobert Watson 
206516993d4SAndrew Thompson static void
20702f4879dSRobert Watson ifnet_setbyindex(u_short idx, struct ifnet *ifp)
20802f4879dSRobert Watson {
2098b615593SMarko Zec 	INIT_VNET_NET(curvnet);
21002f4879dSRobert Watson 
21102f4879dSRobert Watson 	IFNET_WLOCK_ASSERT();
21202f4879dSRobert Watson 
213603724d3SBjoern A. Zeeb 	V_ifindex_table[idx].ife_ifnet = ifp;
21402f4879dSRobert Watson }
21502f4879dSRobert Watson 
21602f4879dSRobert Watson struct ifaddr *
21702f4879dSRobert Watson ifaddr_byindex(u_short idx)
21802f4879dSRobert Watson {
21902f4879dSRobert Watson 	struct ifaddr *ifa;
22002f4879dSRobert Watson 
22102f4879dSRobert Watson 	IFNET_RLOCK();
22202f4879dSRobert Watson 	ifa = ifnet_byindex(idx)->if_addr;
22302f4879dSRobert Watson 	IFNET_RUNLOCK();
22402f4879dSRobert Watson 	return (ifa);
22502f4879dSRobert Watson }
22602f4879dSRobert Watson 
22702f4879dSRobert Watson struct cdev *
22802f4879dSRobert Watson ifdev_byindex(u_short idx)
22902f4879dSRobert Watson {
2308b615593SMarko Zec 	INIT_VNET_NET(curvnet);
23102f4879dSRobert Watson 	struct cdev *cdev;
23202f4879dSRobert Watson 
23302f4879dSRobert Watson 	IFNET_RLOCK();
234603724d3SBjoern A. Zeeb 	cdev = V_ifindex_table[idx].ife_dev;
23502f4879dSRobert Watson 	IFNET_RUNLOCK();
23602f4879dSRobert Watson 	return (cdev);
23702f4879dSRobert Watson }
23802f4879dSRobert Watson 
23902f4879dSRobert Watson static void
24002f4879dSRobert Watson ifdev_setbyindex(u_short idx, struct cdev *cdev)
24102f4879dSRobert Watson {
2428b615593SMarko Zec 	INIT_VNET_NET(curvnet);
24302f4879dSRobert Watson 
24402f4879dSRobert Watson 	IFNET_WLOCK();
245603724d3SBjoern A. Zeeb 	V_ifindex_table[idx].ife_dev = cdev;
24602f4879dSRobert Watson 	IFNET_WUNLOCK();
24702f4879dSRobert Watson }
24802f4879dSRobert Watson 
249f13ad206SJonathan Lemon static d_open_t		netopen;
250f13ad206SJonathan Lemon static d_close_t	netclose;
251f13ad206SJonathan Lemon static d_ioctl_t	netioctl;
2529a2a57a1SJonathan Lemon static d_kqfilter_t	netkqfilter;
253f13ad206SJonathan Lemon 
254f13ad206SJonathan Lemon static struct cdevsw net_cdevsw = {
255dc08ffecSPoul-Henning Kamp 	.d_version =	D_VERSION,
256dc08ffecSPoul-Henning Kamp 	.d_flags =	D_NEEDGIANT,
2577ac40f5fSPoul-Henning Kamp 	.d_open =	netopen,
2587ac40f5fSPoul-Henning Kamp 	.d_close =	netclose,
2597ac40f5fSPoul-Henning Kamp 	.d_ioctl =	netioctl,
2607ac40f5fSPoul-Henning Kamp 	.d_name =	"net",
2617ac40f5fSPoul-Henning Kamp 	.d_kqfilter =	netkqfilter,
262f13ad206SJonathan Lemon };
263f13ad206SJonathan Lemon 
264f13ad206SJonathan Lemon static int
26589c9c53dSPoul-Henning Kamp netopen(struct cdev *dev, int flag, int mode, struct thread *td)
266f13ad206SJonathan Lemon {
267f13ad206SJonathan Lemon 	return (0);
268f13ad206SJonathan Lemon }
269f13ad206SJonathan Lemon 
270f13ad206SJonathan Lemon static int
27189c9c53dSPoul-Henning Kamp netclose(struct cdev *dev, int flags, int fmt, struct thread *td)
272f13ad206SJonathan Lemon {
273f13ad206SJonathan Lemon 	return (0);
274f13ad206SJonathan Lemon }
275f13ad206SJonathan Lemon 
276f13ad206SJonathan Lemon static int
27789c9c53dSPoul-Henning Kamp netioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
278f13ad206SJonathan Lemon {
279f13ad206SJonathan Lemon 	struct ifnet *ifp;
280f13ad206SJonathan Lemon 	int error, idx;
281f13ad206SJonathan Lemon 
282f13ad206SJonathan Lemon 	/* only support interface specific ioctls */
283f13ad206SJonathan Lemon 	if (IOCGROUP(cmd) != 'i')
284f13ad206SJonathan Lemon 		return (EOPNOTSUPP);
2856bfa9a2dSEd Schouten 	idx = dev2unit(dev);
286f13ad206SJonathan Lemon 	if (idx == 0) {
287f13ad206SJonathan Lemon 		/*
288f13ad206SJonathan Lemon 		 * special network device, not interface.
289f13ad206SJonathan Lemon 		 */
290f13ad206SJonathan Lemon 		if (cmd == SIOCGIFCONF)
291f13ad206SJonathan Lemon 			return (ifconf(cmd, data));	/* XXX remove cmd */
29219cf0498SPaul Saab #ifdef __amd64__
29319cf0498SPaul Saab 		if (cmd == SIOCGIFCONF32)
29419cf0498SPaul Saab 			return (ifconf(cmd, data));	/* XXX remove cmd */
29519cf0498SPaul Saab #endif
296f13ad206SJonathan Lemon 		return (EOPNOTSUPP);
297f13ad206SJonathan Lemon 	}
298f13ad206SJonathan Lemon 
299f13ad206SJonathan Lemon 	ifp = ifnet_byindex(idx);
300f13ad206SJonathan Lemon 	if (ifp == NULL)
301f13ad206SJonathan Lemon 		return (ENXIO);
302f13ad206SJonathan Lemon 
303f13ad206SJonathan Lemon 	error = ifhwioctl(cmd, ifp, data, td);
304f13ad206SJonathan Lemon 	if (error == ENOIOCTL)
305f13ad206SJonathan Lemon 		error = EOPNOTSUPP;
306f13ad206SJonathan Lemon 	return (error);
307f13ad206SJonathan Lemon }
308f13ad206SJonathan Lemon 
3099a2a57a1SJonathan Lemon static int
31089c9c53dSPoul-Henning Kamp netkqfilter(struct cdev *dev, struct knote *kn)
3119a2a57a1SJonathan Lemon {
3128b615593SMarko Zec 	INIT_VNET_NET(curvnet);
313ad3b9257SJohn-Mark Gurney 	struct knlist *klist;
3149a2a57a1SJonathan Lemon 	struct ifnet *ifp;
3159a2a57a1SJonathan Lemon 	int idx;
3169a2a57a1SJonathan Lemon 
317ad3b9257SJohn-Mark Gurney 	switch (kn->kn_filter) {
318ad3b9257SJohn-Mark Gurney 	case EVFILT_NETDEV:
319ad3b9257SJohn-Mark Gurney 		kn->kn_fop = &netdev_filtops;
320ad3b9257SJohn-Mark Gurney 		break;
321ad3b9257SJohn-Mark Gurney 	default:
3220a53be46SRobert Watson 		return (EINVAL);
323ad3b9257SJohn-Mark Gurney 	}
324ad3b9257SJohn-Mark Gurney 
3256bfa9a2dSEd Schouten 	idx = dev2unit(dev);
3269a2a57a1SJonathan Lemon 	if (idx == 0) {
327603724d3SBjoern A. Zeeb 		klist = &V_ifklist;
3289a2a57a1SJonathan Lemon 	} else {
3299a2a57a1SJonathan Lemon 		ifp = ifnet_byindex(idx);
3309a2a57a1SJonathan Lemon 		if (ifp == NULL)
3319a2a57a1SJonathan Lemon 			return (1);
3329a2a57a1SJonathan Lemon 		klist = &ifp->if_klist;
3339a2a57a1SJonathan Lemon 	}
3349a2a57a1SJonathan Lemon 
3359a2a57a1SJonathan Lemon 	kn->kn_hook = (caddr_t)klist;
3369a2a57a1SJonathan Lemon 
337ad3b9257SJohn-Mark Gurney 	knlist_add(klist, kn, 0);
3389a2a57a1SJonathan Lemon 
3399a2a57a1SJonathan Lemon 	return (0);
3409a2a57a1SJonathan Lemon }
3419a2a57a1SJonathan Lemon 
3429a2a57a1SJonathan Lemon static void
3439a2a57a1SJonathan Lemon filt_netdetach(struct knote *kn)
3449a2a57a1SJonathan Lemon {
345ad3b9257SJohn-Mark Gurney 	struct knlist *klist = (struct knlist *)kn->kn_hook;
3469a2a57a1SJonathan Lemon 
347ad3b9257SJohn-Mark Gurney 	knlist_remove(klist, kn, 0);
3489a2a57a1SJonathan Lemon }
3499a2a57a1SJonathan Lemon 
3509a2a57a1SJonathan Lemon static int
3519a2a57a1SJonathan Lemon filt_netdev(struct knote *kn, long hint)
3529a2a57a1SJonathan Lemon {
353ad3b9257SJohn-Mark Gurney 	struct knlist *klist = (struct knlist *)kn->kn_hook;
3549a2a57a1SJonathan Lemon 
3559a2a57a1SJonathan Lemon 	/*
3569a2a57a1SJonathan Lemon 	 * Currently NOTE_EXIT is abused to indicate device detach.
3579a2a57a1SJonathan Lemon 	 */
3589a2a57a1SJonathan Lemon 	if (hint == NOTE_EXIT) {
3599a2a57a1SJonathan Lemon 		kn->kn_data = NOTE_LINKINV;
3609a2a57a1SJonathan Lemon 		kn->kn_flags |= (EV_EOF | EV_ONESHOT);
361ad3b9257SJohn-Mark Gurney 		knlist_remove_inevent(klist, kn);
3629a2a57a1SJonathan Lemon 		return (1);
3639a2a57a1SJonathan Lemon 	}
364ad3b9257SJohn-Mark Gurney 	if (hint != 0)
3659a2a57a1SJonathan Lemon 		kn->kn_data = hint;			/* current status */
3669a2a57a1SJonathan Lemon 	if (kn->kn_sfflags & hint)
3679a2a57a1SJonathan Lemon 		kn->kn_fflags |= hint;
3689a2a57a1SJonathan Lemon 	return (kn->kn_fflags != 0);
3699a2a57a1SJonathan Lemon }
3709a2a57a1SJonathan Lemon 
371df8bae1dSRodney W. Grimes /*
372df8bae1dSRodney W. Grimes  * Network interface utility routines.
373df8bae1dSRodney W. Grimes  *
374df8bae1dSRodney W. Grimes  * Routines with ifa_ifwith* names take sockaddr *'s as
375df8bae1dSRodney W. Grimes  * parameters.
376df8bae1dSRodney W. Grimes  */
377a45cbf12SBrooks Davis 
3782b14f991SJulian Elischer /* ARGSUSED*/
379f9132cebSJonathan Lemon static void
38072fd1b6aSDag-Erling Smørgrav if_init(void *dummy __unused)
381f9132cebSJonathan Lemon {
3828b615593SMarko Zec 	INIT_VNET_NET(curvnet);
383f9132cebSJonathan Lemon 
384385195c0SMarko Zec #ifndef VIMAGE_GLOBALS
385385195c0SMarko Zec 	vnet_mod_register(&vnet_net_modinfo);
386385195c0SMarko Zec #endif
387385195c0SMarko Zec 
38844e33a07SMarko Zec 	V_if_index = 0;
38944e33a07SMarko Zec 	V_ifindex_table = NULL;
39044e33a07SMarko Zec 	V_if_indexlim = 8;
39144e33a07SMarko Zec 
392b30a244cSJeffrey Hsu 	IFNET_LOCK_INIT();
393603724d3SBjoern A. Zeeb 	TAILQ_INIT(&V_ifnet);
394603724d3SBjoern A. Zeeb 	TAILQ_INIT(&V_ifg_head);
395603724d3SBjoern A. Zeeb 	knlist_init(&V_ifklist, NULL, NULL, NULL, NULL);
396f9132cebSJonathan Lemon 	if_grow();				/* create initial table */
39702f4879dSRobert Watson 	ifdev_setbyindex(0, make_dev(&net_cdevsw, 0, UID_ROOT, GID_WHEEL,
39802f4879dSRobert Watson 	    0600, "network"));
399f889d2efSBrooks Davis 	if_clone_init();
400f9132cebSJonathan Lemon }
401f9132cebSJonathan Lemon 
402f9132cebSJonathan Lemon static void
403f9132cebSJonathan Lemon if_grow(void)
404f9132cebSJonathan Lemon {
4058b615593SMarko Zec 	INIT_VNET_NET(curvnet);
406f9132cebSJonathan Lemon 	u_int n;
407f9132cebSJonathan Lemon 	struct ifindex_entry *e;
408f9132cebSJonathan Lemon 
409603724d3SBjoern A. Zeeb 	V_if_indexlim <<= 1;
410603724d3SBjoern A. Zeeb 	n = V_if_indexlim * sizeof(*e);
411fc74a9f9SBrooks Davis 	e = malloc(n, M_IFNET, M_WAITOK | M_ZERO);
412603724d3SBjoern A. Zeeb 	if (V_ifindex_table != NULL) {
413603724d3SBjoern A. Zeeb 		memcpy((caddr_t)e, (caddr_t)V_ifindex_table, n/2);
414603724d3SBjoern A. Zeeb 		free((caddr_t)V_ifindex_table, M_IFNET);
415f9132cebSJonathan Lemon 	}
416603724d3SBjoern A. Zeeb 	V_ifindex_table = e;
417f9132cebSJonathan Lemon }
418f9132cebSJonathan Lemon 
419df8bae1dSRodney W. Grimes /*
420a45cbf12SBrooks Davis  * Allocate a struct ifnet and an index for an interface.  A layer 2
421a45cbf12SBrooks Davis  * common structure will also be allocated if an allocation routine is
422a45cbf12SBrooks Davis  * registered for the passed type.
423fc74a9f9SBrooks Davis  */
424fc74a9f9SBrooks Davis struct ifnet*
425fc74a9f9SBrooks Davis if_alloc(u_char type)
426fc74a9f9SBrooks Davis {
4278b615593SMarko Zec 	INIT_VNET_NET(curvnet);
428fc74a9f9SBrooks Davis 	struct ifnet *ifp;
429fc74a9f9SBrooks Davis 
430fc74a9f9SBrooks Davis 	ifp = malloc(sizeof(struct ifnet), M_IFNET, M_WAITOK|M_ZERO);
431fc74a9f9SBrooks Davis 
432dc7c539eSBrooks Davis 	/*
433dc7c539eSBrooks Davis 	 * Try to find an empty slot below if_index.  If we fail, take
434dc7c539eSBrooks Davis 	 * the next slot.
435dc7c539eSBrooks Davis 	 *
436dc7c539eSBrooks Davis 	 * XXX: should be locked!
437dc7c539eSBrooks Davis 	 */
438603724d3SBjoern A. Zeeb 	for (ifp->if_index = 1; ifp->if_index <= V_if_index; ifp->if_index++) {
439dc7c539eSBrooks Davis 		if (ifnet_byindex(ifp->if_index) == NULL)
440dc7c539eSBrooks Davis 			break;
441dc7c539eSBrooks Davis 	}
442dc7c539eSBrooks Davis 	/* Catch if_index overflow. */
443dc7c539eSBrooks Davis 	if (ifp->if_index < 1) {
444dc7c539eSBrooks Davis 		free(ifp, M_IFNET);
445dc7c539eSBrooks Davis 		return (NULL);
446dc7c539eSBrooks Davis 	}
447603724d3SBjoern A. Zeeb 	if (ifp->if_index > V_if_index)
448603724d3SBjoern A. Zeeb 		V_if_index = ifp->if_index;
449603724d3SBjoern A. Zeeb 	if (V_if_index >= V_if_indexlim)
450fc74a9f9SBrooks Davis 		if_grow();
451fc74a9f9SBrooks Davis 
452fc74a9f9SBrooks Davis 	ifp->if_type = type;
453fc74a9f9SBrooks Davis 
454fc74a9f9SBrooks Davis 	if (if_com_alloc[type] != NULL) {
455fc74a9f9SBrooks Davis 		ifp->if_l2com = if_com_alloc[type](type, ifp);
45628ef2db4SBrooks Davis 		if (ifp->if_l2com == NULL) {
457fc74a9f9SBrooks Davis 			free(ifp, M_IFNET);
45828ef2db4SBrooks Davis 			return (NULL);
45928ef2db4SBrooks Davis 		}
460fc74a9f9SBrooks Davis 	}
46102f4879dSRobert Watson 	IFNET_WLOCK();
46202f4879dSRobert Watson 	ifnet_setbyindex(ifp->if_index, ifp);
46302f4879dSRobert Watson 	IFNET_WUNLOCK();
4646da3131aSJohn Baldwin 	IF_ADDR_LOCK_INIT(ifp);
465fc74a9f9SBrooks Davis 
466fc74a9f9SBrooks Davis 	return (ifp);
467fc74a9f9SBrooks Davis }
468fc74a9f9SBrooks Davis 
469a45cbf12SBrooks Davis /*
470a45cbf12SBrooks Davis  * Free the struct ifnet, the associated index, and the layer 2 common
471a45cbf12SBrooks Davis  * structure if needed.  All the work is done in if_free_type().
472a45cbf12SBrooks Davis  *
473a45cbf12SBrooks Davis  * Do not add code to this function!  Add it to if_free_type().
474a45cbf12SBrooks Davis  */
475fc74a9f9SBrooks Davis void
476fc74a9f9SBrooks Davis if_free(struct ifnet *ifp)
477fc74a9f9SBrooks Davis {
478fc74a9f9SBrooks Davis 
479456d182dSSam Leffler 	if_free_type(ifp, ifp->if_type);
480fc74a9f9SBrooks Davis }
481fc74a9f9SBrooks Davis 
482a45cbf12SBrooks Davis /*
483a45cbf12SBrooks Davis  * Do the actual work of freeing a struct ifnet, associated index, and
484a45cbf12SBrooks Davis  * layer 2 common structure.  This version should only be called by
485a45cbf12SBrooks Davis  * intefaces that switch their type after calling if_alloc().
486a45cbf12SBrooks Davis  */
487fc74a9f9SBrooks Davis void
488fc74a9f9SBrooks Davis if_free_type(struct ifnet *ifp, u_char type)
489fc74a9f9SBrooks Davis {
4908b615593SMarko Zec 	INIT_VNET_NET(curvnet); /* ifp->if_vnet can be NULL here ! */
491fc74a9f9SBrooks Davis 
492fc74a9f9SBrooks Davis 	if (ifp != ifnet_byindex(ifp->if_index)) {
493fc74a9f9SBrooks Davis 		if_printf(ifp, "%s: value was not if_alloced, skipping\n",
494fc74a9f9SBrooks Davis 		    __func__);
495fc74a9f9SBrooks Davis 		return;
496fc74a9f9SBrooks Davis 	}
497fc74a9f9SBrooks Davis 
49802f4879dSRobert Watson 	IFNET_WLOCK();
49902f4879dSRobert Watson 	ifnet_setbyindex(ifp->if_index, NULL);
50028ef2db4SBrooks Davis 
50128ef2db4SBrooks Davis 	/* XXX: should be locked with if_findindex() */
502603724d3SBjoern A. Zeeb 	while (V_if_index > 0 && ifnet_byindex(V_if_index) == NULL)
503603724d3SBjoern A. Zeeb 		V_if_index--;
50402f4879dSRobert Watson 	IFNET_WUNLOCK();
50528ef2db4SBrooks Davis 
506fc74a9f9SBrooks Davis 	if (if_com_free[type] != NULL)
507fc74a9f9SBrooks Davis 		if_com_free[type](ifp->if_l2com, type);
508fc74a9f9SBrooks Davis 
50902f4879dSRobert Watson 	IF_ADDR_LOCK_DESTROY(ifp);
510fc74a9f9SBrooks Davis 	free(ifp, M_IFNET);
511fc74a9f9SBrooks Davis };
512fc74a9f9SBrooks Davis 
513db7f0b97SKip Macy void
514db7f0b97SKip Macy ifq_attach(struct ifaltq *ifq, struct ifnet *ifp)
515db7f0b97SKip Macy {
516db7f0b97SKip Macy 
517db7f0b97SKip Macy 	mtx_init(&ifq->ifq_mtx, ifp->if_xname, "if send queue", MTX_DEF);
518db7f0b97SKip Macy 
519db7f0b97SKip Macy 	if (ifq->ifq_maxlen == 0)
520db7f0b97SKip Macy 		ifq->ifq_maxlen = ifqmaxlen;
521db7f0b97SKip Macy 
522db7f0b97SKip Macy 	ifq->altq_type = 0;
523db7f0b97SKip Macy 	ifq->altq_disc = NULL;
524db7f0b97SKip Macy 	ifq->altq_flags &= ALTQF_CANTCHANGE;
525db7f0b97SKip Macy 	ifq->altq_tbr  = NULL;
526db7f0b97SKip Macy 	ifq->altq_ifp  = ifp;
527db7f0b97SKip Macy }
528db7f0b97SKip Macy 
529db7f0b97SKip Macy void
530db7f0b97SKip Macy ifq_detach(struct ifaltq *ifq)
531db7f0b97SKip Macy {
532db7f0b97SKip Macy 	mtx_destroy(&ifq->ifq_mtx);
533db7f0b97SKip Macy }
534db7f0b97SKip Macy 
535fc74a9f9SBrooks Davis /*
536a45cbf12SBrooks Davis  * Perform generic interface initalization tasks and attach the interface
537a45cbf12SBrooks Davis  * to the list of "active" interfaces.
538a45cbf12SBrooks Davis  *
539a45cbf12SBrooks Davis  * XXX:
540a45cbf12SBrooks Davis  *  - The decision to return void and thus require this function to
541a45cbf12SBrooks Davis  *    succeed is questionable.
542a45cbf12SBrooks Davis  *  - We do more initialization here then is probably a good idea.
543a45cbf12SBrooks Davis  *    Some of this should probably move to if_alloc().
544a45cbf12SBrooks Davis  *  - We should probably do more sanity checking.  For instance we don't
545a45cbf12SBrooks Davis  *    do anything to insure if_xname is unique or non-empty.
546df8bae1dSRodney W. Grimes  */
547df8bae1dSRodney W. Grimes void
54872fd1b6aSDag-Erling Smørgrav if_attach(struct ifnet *ifp)
549df8bae1dSRodney W. Grimes {
5508b615593SMarko Zec 	INIT_VNET_NET(curvnet);
551df8bae1dSRodney W. Grimes 	unsigned socksize, ifasize;
5521ce9bf88SPoul-Henning Kamp 	int namelen, masklen;
55372fd1b6aSDag-Erling Smørgrav 	struct sockaddr_dl *sdl;
55472fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
555df8bae1dSRodney W. Grimes 
556fc74a9f9SBrooks Davis 	if (ifp->if_index == 0 || ifp != ifnet_byindex(ifp->if_index))
557fc74a9f9SBrooks Davis 		panic ("%s: BUG: if_attach called without if_alloc'd input()\n",
558fc74a9f9SBrooks Davis 		    ifp->if_xname);
559fc74a9f9SBrooks Davis 
560af5e59bfSRobert Watson 	TASK_INIT(&ifp->if_starttask, 0, if_start_deferred, ifp);
56168a3482fSGleb Smirnoff 	TASK_INIT(&ifp->if_linktask, 0, do_link_state_change, ifp);
562234a35c7SHajimu UMEMOTO 	IF_AFDATA_LOCK_INIT(ifp);
563234a35c7SHajimu UMEMOTO 	ifp->if_afdata_initialized = 0;
564a45cbf12SBrooks Davis 
56559562606SGarrett Wollman 	TAILQ_INIT(&ifp->if_addrhead);
56682cd038dSYoshinobu Inoue 	TAILQ_INIT(&ifp->if_prefixhead);
5676817526dSPoul-Henning Kamp 	TAILQ_INIT(&ifp->if_multiaddrs);
5680dad3f0eSMax Laier 	TAILQ_INIT(&ifp->if_groups);
5690dad3f0eSMax Laier 
5700dad3f0eSMax Laier 	if_addgroup(ifp, IFG_ALL);
5710dad3f0eSMax Laier 
572571dcd15SSuleiman Souhlal 	knlist_init(&ifp->if_klist, NULL, NULL, NULL, NULL);
57398b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
574bc9d2991SBrooks Davis 	ifp->if_data.ifi_epoch = time_uptime;
575fc74a9f9SBrooks Davis 	ifp->if_data.ifi_datalen = sizeof(struct if_data);
576db7f0b97SKip Macy 	ifp->if_transmit = if_transmit;
577db7f0b97SKip Macy 	ifp->if_qflush = if_qflush;
578e70cd263SRobert Watson #ifdef MAC
57930d239bcSRobert Watson 	mac_ifnet_init(ifp);
58030d239bcSRobert Watson 	mac_ifnet_create(ifp);
581e70cd263SRobert Watson #endif
582e70cd263SRobert Watson 
58302f4879dSRobert Watson 	ifdev_setbyindex(ifp->if_index, make_dev(&net_cdevsw,
584d3ce8327SEd Schouten 	    ifp->if_index, UID_ROOT, GID_WHEEL, 0600, "%s/%s",
58502f4879dSRobert Watson 	    net_cdevsw.d_name, ifp->if_xname));
586ffb5a104SJonathan Lemon 	make_dev_alias(ifdev_byindex(ifp->if_index), "%s%d",
587ffb5a104SJonathan Lemon 	    net_cdevsw.d_name, ifp->if_index);
588f13ad206SJonathan Lemon 
589db7f0b97SKip Macy 	ifq_attach(&ifp->if_snd, ifp);
590df5e1987SJonathan Lemon 
591df8bae1dSRodney W. Grimes 	/*
592df8bae1dSRodney W. Grimes 	 * create a Link Level name for this device
593df8bae1dSRodney W. Grimes 	 */
5949bf40edeSBrooks Davis 	namelen = strlen(ifp->if_xname);
59536c19a57SBrooks Davis 	/*
59636c19a57SBrooks Davis 	 * Always save enough space for any possiable name so we can do
59736c19a57SBrooks Davis 	 * a rename in place later.
59836c19a57SBrooks Davis 	 */
59936c19a57SBrooks Davis 	masklen = offsetof(struct sockaddr_dl, sdl_data[0]) + IFNAMSIZ;
600df8bae1dSRodney W. Grimes 	socksize = masklen + ifp->if_addrlen;
601df8bae1dSRodney W. Grimes 	if (socksize < sizeof(*sdl))
602df8bae1dSRodney W. Grimes 		socksize = sizeof(*sdl);
603ccb82468SBrooks Davis 	socksize = roundup2(socksize, sizeof(long));
604df8bae1dSRodney W. Grimes 	ifasize = sizeof(*ifa) + 2 * socksize;
605a8773564SBrooks Davis 	ifa = malloc(ifasize, M_IFADDR, M_WAITOK | M_ZERO);
60619fc74fbSJeffrey Hsu 	IFA_LOCK_INIT(ifa);
607df8bae1dSRodney W. Grimes 	sdl = (struct sockaddr_dl *)(ifa + 1);
608df8bae1dSRodney W. Grimes 	sdl->sdl_len = socksize;
609df8bae1dSRodney W. Grimes 	sdl->sdl_family = AF_LINK;
6109bf40edeSBrooks Davis 	bcopy(ifp->if_xname, sdl->sdl_data, namelen);
6111ce9bf88SPoul-Henning Kamp 	sdl->sdl_nlen = namelen;
612df8bae1dSRodney W. Grimes 	sdl->sdl_index = ifp->if_index;
613df8bae1dSRodney W. Grimes 	sdl->sdl_type = ifp->if_type;
6144a0d6638SRuslan Ermilov 	ifp->if_addr = ifa;
615df8bae1dSRodney W. Grimes 	ifa->ifa_ifp = ifp;
616df8bae1dSRodney W. Grimes 	ifa->ifa_rtrequest = link_rtrequest;
617df8bae1dSRodney W. Grimes 	ifa->ifa_addr = (struct sockaddr *)sdl;
618df8bae1dSRodney W. Grimes 	sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
619df8bae1dSRodney W. Grimes 	ifa->ifa_netmask = (struct sockaddr *)sdl;
620df8bae1dSRodney W. Grimes 	sdl->sdl_len = masklen;
621df8bae1dSRodney W. Grimes 	while (namelen != 0)
622df8bae1dSRodney W. Grimes 		sdl->sdl_data[--namelen] = 0xff;
62319fc74fbSJeffrey Hsu 	ifa->ifa_refcnt = 1;
62459562606SGarrett Wollman 	TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
6256237419dSRobert Watson 	ifp->if_broadcastaddr = NULL; /* reliably crash if used uninitialized */
626d94ccb09SBrooks Davis 
6277b6edd04SRuslan Ermilov 
628457f48e6SGleb Smirnoff 	IFNET_WLOCK();
629603724d3SBjoern A. Zeeb 	TAILQ_INSERT_TAIL(&V_ifnet, ifp, if_link);
630457f48e6SGleb Smirnoff 	IFNET_WUNLOCK();
631457f48e6SGleb Smirnoff 
63269fb23b7SMax Laier 	if (domain_init_status >= 2)
63331b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
63431b1bfe1SHajimu UMEMOTO 
63525a4adceSMax Laier 	EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
636f3b90d48SAndrew Thompson 	devctl_notify("IFNET", ifp->if_xname, "ATTACH", NULL);
63725a4adceSMax Laier 
6387b6edd04SRuslan Ermilov 	/* Announce the interface. */
6397b6edd04SRuslan Ermilov 	rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
640c18ffdc8SGleb Smirnoff 
641c18ffdc8SGleb Smirnoff 	if (ifp->if_watchdog != NULL)
642b9175c45SRobert Watson 		if_printf(ifp,
643b9175c45SRobert Watson 		    "WARNING: using obsoleted if_watchdog interface\n");
644b9175c45SRobert Watson 	if (ifp->if_flags & IFF_NEEDSGIANT)
645b9175c45SRobert Watson 		if_printf(ifp,
646b9175c45SRobert Watson 		    "WARNING: using obsoleted IFF_NEEDSGIANT flag\n");
647df8bae1dSRodney W. Grimes }
6486182fdbdSPeter Wemm 
64931b1bfe1SHajimu UMEMOTO static void
65072fd1b6aSDag-Erling Smørgrav if_attachdomain(void *dummy)
65131b1bfe1SHajimu UMEMOTO {
6528b615593SMarko Zec 	INIT_VNET_NET(curvnet);
65331b1bfe1SHajimu UMEMOTO 	struct ifnet *ifp;
65431b1bfe1SHajimu UMEMOTO 	int s;
65531b1bfe1SHajimu UMEMOTO 
65631b1bfe1SHajimu UMEMOTO 	s = splnet();
657603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link)
65831b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
65931b1bfe1SHajimu UMEMOTO 	splx(s);
66031b1bfe1SHajimu UMEMOTO }
66169fb23b7SMax Laier SYSINIT(domainifattach, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_SECOND,
66231b1bfe1SHajimu UMEMOTO     if_attachdomain, NULL);
66331b1bfe1SHajimu UMEMOTO 
66431b1bfe1SHajimu UMEMOTO static void
66572fd1b6aSDag-Erling Smørgrav if_attachdomain1(struct ifnet *ifp)
66631b1bfe1SHajimu UMEMOTO {
66731b1bfe1SHajimu UMEMOTO 	struct domain *dp;
66831b1bfe1SHajimu UMEMOTO 	int s;
66931b1bfe1SHajimu UMEMOTO 
67031b1bfe1SHajimu UMEMOTO 	s = splnet();
67131b1bfe1SHajimu UMEMOTO 
672234a35c7SHajimu UMEMOTO 	/*
673234a35c7SHajimu UMEMOTO 	 * Since dp->dom_ifattach calls malloc() with M_WAITOK, we
674234a35c7SHajimu UMEMOTO 	 * cannot lock ifp->if_afdata initialization, entirely.
675234a35c7SHajimu UMEMOTO 	 */
676234a35c7SHajimu UMEMOTO 	if (IF_AFDATA_TRYLOCK(ifp) == 0) {
677234a35c7SHajimu UMEMOTO 		splx(s);
678234a35c7SHajimu UMEMOTO 		return;
679234a35c7SHajimu UMEMOTO 	}
68069fb23b7SMax Laier 	if (ifp->if_afdata_initialized >= domain_init_status) {
681234a35c7SHajimu UMEMOTO 		IF_AFDATA_UNLOCK(ifp);
682234a35c7SHajimu UMEMOTO 		splx(s);
6836237419dSRobert Watson 		printf("if_attachdomain called more than once on %s\n",
6846237419dSRobert Watson 		    ifp->if_xname);
685234a35c7SHajimu UMEMOTO 		return;
686234a35c7SHajimu UMEMOTO 	}
68769fb23b7SMax Laier 	ifp->if_afdata_initialized = domain_init_status;
688234a35c7SHajimu UMEMOTO 	IF_AFDATA_UNLOCK(ifp);
689234a35c7SHajimu UMEMOTO 
69031b1bfe1SHajimu UMEMOTO 	/* address family dependent data region */
69131b1bfe1SHajimu UMEMOTO 	bzero(ifp->if_afdata, sizeof(ifp->if_afdata));
69231b1bfe1SHajimu UMEMOTO 	for (dp = domains; dp; dp = dp->dom_next) {
69331b1bfe1SHajimu UMEMOTO 		if (dp->dom_ifattach)
69431b1bfe1SHajimu UMEMOTO 			ifp->if_afdata[dp->dom_family] =
69531b1bfe1SHajimu UMEMOTO 			    (*dp->dom_ifattach)(ifp);
69631b1bfe1SHajimu UMEMOTO 	}
69731b1bfe1SHajimu UMEMOTO 
69831b1bfe1SHajimu UMEMOTO 	splx(s);
69931b1bfe1SHajimu UMEMOTO }
70031b1bfe1SHajimu UMEMOTO 
7016182fdbdSPeter Wemm /*
702ec002feeSBruce M Simpson  * Remove any unicast or broadcast network addresses from an interface.
70345778b37SPeter Edwards  */
70445778b37SPeter Edwards void
70545778b37SPeter Edwards if_purgeaddrs(struct ifnet *ifp)
70645778b37SPeter Edwards {
70745778b37SPeter Edwards 	struct ifaddr *ifa, *next;
70845778b37SPeter Edwards 
70945778b37SPeter Edwards 	TAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, next) {
7104b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_LINK)
71145778b37SPeter Edwards 			continue;
71245778b37SPeter Edwards #ifdef INET
71345778b37SPeter Edwards 		/* XXX: Ugly!! ad hoc just for INET */
7144b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET) {
71545778b37SPeter Edwards 			struct ifaliasreq ifr;
71645778b37SPeter Edwards 
71745778b37SPeter Edwards 			bzero(&ifr, sizeof(ifr));
71845778b37SPeter Edwards 			ifr.ifra_addr = *ifa->ifa_addr;
71945778b37SPeter Edwards 			if (ifa->ifa_dstaddr)
72045778b37SPeter Edwards 				ifr.ifra_broadaddr = *ifa->ifa_dstaddr;
72145778b37SPeter Edwards 			if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp,
72245778b37SPeter Edwards 			    NULL) == 0)
72345778b37SPeter Edwards 				continue;
72445778b37SPeter Edwards 		}
72545778b37SPeter Edwards #endif /* INET */
72645778b37SPeter Edwards #ifdef INET6
7274b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET6) {
72845778b37SPeter Edwards 			in6_purgeaddr(ifa);
72945778b37SPeter Edwards 			/* ifp_addrhead is already updated */
73045778b37SPeter Edwards 			continue;
73145778b37SPeter Edwards 		}
73245778b37SPeter Edwards #endif /* INET6 */
73345778b37SPeter Edwards 		TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
73445778b37SPeter Edwards 		IFAFREE(ifa);
73545778b37SPeter Edwards 	}
73645778b37SPeter Edwards }
73745778b37SPeter Edwards 
73845778b37SPeter Edwards /*
739ec002feeSBruce M Simpson  * Remove any multicast network addresses from an interface.
740ec002feeSBruce M Simpson  */
741fb27dd1dSSam Leffler void
742ec002feeSBruce M Simpson if_purgemaddrs(struct ifnet *ifp)
743ec002feeSBruce M Simpson {
744ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
745ec002feeSBruce M Simpson 	struct ifmultiaddr *next;
746ec002feeSBruce M Simpson 
747ec002feeSBruce M Simpson 	IF_ADDR_LOCK(ifp);
748ec002feeSBruce M Simpson 	TAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
749ec002feeSBruce M Simpson 		if_delmulti_locked(ifp, ifma, 1);
750ec002feeSBruce M Simpson 	IF_ADDR_UNLOCK(ifp);
751ec002feeSBruce M Simpson }
752ec002feeSBruce M Simpson 
753ec002feeSBruce M Simpson /*
7546182fdbdSPeter Wemm  * Detach an interface, removing it from the
7554a0d6638SRuslan Ermilov  * list of "active" interfaces.
756b1c53bc9SRobert Watson  *
757b1c53bc9SRobert Watson  * XXXRW: There are some significant questions about event ordering, and
758b1c53bc9SRobert Watson  * how to prevent things from starting to use the interface during detach.
7596182fdbdSPeter Wemm  */
7606182fdbdSPeter Wemm void
76172fd1b6aSDag-Erling Smørgrav if_detach(struct ifnet *ifp)
7626182fdbdSPeter Wemm {
7638b615593SMarko Zec 	INIT_VNET_NET(ifp->if_vnet);
76445778b37SPeter Edwards 	struct ifaddr *ifa;
7655500d3beSWarner Losh 	struct radix_node_head	*rnh;
76614443589SSam Leffler 	int s, i, j;
76731b1bfe1SHajimu UMEMOTO 	struct domain *dp;
7683f35d515SPeter Pentchev  	struct ifnet *iter;
769457f48e6SGleb Smirnoff  	int found = 0;
770457f48e6SGleb Smirnoff 
771457f48e6SGleb Smirnoff 	IFNET_WLOCK();
772603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(iter, &V_ifnet, if_link)
773457f48e6SGleb Smirnoff 		if (iter == ifp) {
774603724d3SBjoern A. Zeeb 			TAILQ_REMOVE(&V_ifnet, ifp, if_link);
775457f48e6SGleb Smirnoff 			found = 1;
776457f48e6SGleb Smirnoff 			break;
777457f48e6SGleb Smirnoff 		}
778457f48e6SGleb Smirnoff 	IFNET_WUNLOCK();
779457f48e6SGleb Smirnoff 	if (!found)
780457f48e6SGleb Smirnoff 		return;
7816182fdbdSPeter Wemm 
78268a3482fSGleb Smirnoff 	/*
78368a3482fSGleb Smirnoff 	 * Remove/wait for pending events.
78468a3482fSGleb Smirnoff 	 */
78568a3482fSGleb Smirnoff 	taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
78668a3482fSGleb Smirnoff 
7876182fdbdSPeter Wemm 	/*
7886182fdbdSPeter Wemm 	 * Remove routes and flush queues.
7896182fdbdSPeter Wemm 	 */
7905500d3beSWarner Losh 	s = splnet();
7916182fdbdSPeter Wemm 	if_down(ifp);
79202b199f1SMax Laier #ifdef ALTQ
79302b199f1SMax Laier 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
79402b199f1SMax Laier 		altq_disable(&ifp->if_snd);
79502b199f1SMax Laier 	if (ALTQ_IS_ATTACHED(&ifp->if_snd))
79602b199f1SMax Laier 		altq_detach(&ifp->if_snd);
79702b199f1SMax Laier #endif
7986182fdbdSPeter Wemm 
79945778b37SPeter Edwards 	if_purgeaddrs(ifp);
8006182fdbdSPeter Wemm 
801b1c53bc9SRobert Watson #ifdef INET
802b1c53bc9SRobert Watson 	in_ifdetach(ifp);
803b1c53bc9SRobert Watson #endif
804b1c53bc9SRobert Watson 
80533841545SHajimu UMEMOTO #ifdef INET6
80633841545SHajimu UMEMOTO 	/*
80733841545SHajimu UMEMOTO 	 * Remove all IPv6 kernel structs related to ifp.  This should be done
80833841545SHajimu UMEMOTO 	 * before removing routing entries below, since IPv6 interface direct
80933841545SHajimu UMEMOTO 	 * routes are expected to be removed by the IPv6-specific kernel API.
81033841545SHajimu UMEMOTO 	 * Otherwise, the kernel will detect some inconsistency and bark it.
81133841545SHajimu UMEMOTO 	 */
81233841545SHajimu UMEMOTO 	in6_ifdetach(ifp);
81333841545SHajimu UMEMOTO #endif
814ec002feeSBruce M Simpson 	if_purgemaddrs(ifp);
815ec002feeSBruce M Simpson 
816f4247b59SLuigi Rizzo 	/*
8174a0d6638SRuslan Ermilov 	 * Remove link ifaddr pointer and maybe decrement if_index.
818f4247b59SLuigi Rizzo 	 * Clean up all addresses.
819f4247b59SLuigi Rizzo 	 */
8204a0d6638SRuslan Ermilov 	ifp->if_addr = NULL;
821f4247b59SLuigi Rizzo 	destroy_dev(ifdev_byindex(ifp->if_index));
82202f4879dSRobert Watson 	ifdev_setbyindex(ifp->if_index, NULL);
823f4247b59SLuigi Rizzo 
824212bd869SHajimu UMEMOTO 	/* We can now free link ifaddr. */
8253f35d515SPeter Pentchev 	if (!TAILQ_EMPTY(&ifp->if_addrhead)) {
826212bd869SHajimu UMEMOTO 		ifa = TAILQ_FIRST(&ifp->if_addrhead);
827212bd869SHajimu UMEMOTO 		TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
828212bd869SHajimu UMEMOTO 		IFAFREE(ifa);
8293f35d515SPeter Pentchev 	}
830212bd869SHajimu UMEMOTO 
8315500d3beSWarner Losh 	/*
8325500d3beSWarner Losh 	 * Delete all remaining routes using this interface
8335500d3beSWarner Losh 	 * Unfortuneatly the only way to do this is to slog through
8345500d3beSWarner Losh 	 * the entire routing table looking for routes which point
8355500d3beSWarner Losh 	 * to this interface...oh well...
8365500d3beSWarner Losh 	 */
8375500d3beSWarner Losh 	for (i = 1; i <= AF_MAX; i++) {
8388b07e49aSJulian Elischer 		for (j = 0; j < rt_numfibs; j++) {
839603724d3SBjoern A. Zeeb 			if ((rnh = V_rt_tables[j][i]) == NULL)
8405500d3beSWarner Losh 				continue;
841956b0b65SJeffrey Hsu 			RADIX_NODE_HEAD_LOCK(rnh);
8425500d3beSWarner Losh 			(void) rnh->rnh_walktree(rnh, if_rtdel, ifp);
843956b0b65SJeffrey Hsu 			RADIX_NODE_HEAD_UNLOCK(rnh);
8445500d3beSWarner Losh 		}
8458b07e49aSJulian Elischer 	}
8465500d3beSWarner Losh 
8477b6edd04SRuslan Ermilov 	/* Announce that the interface is gone. */
8487b6edd04SRuslan Ermilov 	rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
84952023244SMax Laier 	EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
850f3b90d48SAndrew Thompson 	devctl_notify("IFNET", ifp->if_xname, "DETACH", NULL);
8517b6edd04SRuslan Ermilov 
852234a35c7SHajimu UMEMOTO 	IF_AFDATA_LOCK(ifp);
85331b1bfe1SHajimu UMEMOTO 	for (dp = domains; dp; dp = dp->dom_next) {
85431b1bfe1SHajimu UMEMOTO 		if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family])
85531b1bfe1SHajimu UMEMOTO 			(*dp->dom_ifdetach)(ifp,
85631b1bfe1SHajimu UMEMOTO 			    ifp->if_afdata[dp->dom_family]);
85731b1bfe1SHajimu UMEMOTO 	}
858234a35c7SHajimu UMEMOTO 	IF_AFDATA_UNLOCK(ifp);
85931b1bfe1SHajimu UMEMOTO 
860e70cd263SRobert Watson #ifdef MAC
86130d239bcSRobert Watson 	mac_ifnet_destroy(ifp);
862e70cd263SRobert Watson #endif /* MAC */
863ad3b9257SJohn-Mark Gurney 	KNOTE_UNLOCKED(&ifp->if_klist, NOTE_EXIT);
864ad3b9257SJohn-Mark Gurney 	knlist_clear(&ifp->if_klist, 0);
865ad3b9257SJohn-Mark Gurney 	knlist_destroy(&ifp->if_klist);
866db7f0b97SKip Macy 	ifq_detach(&ifp->if_snd);
867234a35c7SHajimu UMEMOTO 	IF_AFDATA_DESTROY(ifp);
8685500d3beSWarner Losh 	splx(s);
8695500d3beSWarner Losh }
8705500d3beSWarner Losh 
8715500d3beSWarner Losh /*
8720dad3f0eSMax Laier  * Add a group to an interface
8730dad3f0eSMax Laier  */
8740dad3f0eSMax Laier int
8750dad3f0eSMax Laier if_addgroup(struct ifnet *ifp, const char *groupname)
8760dad3f0eSMax Laier {
8778b615593SMarko Zec 	INIT_VNET_NET(ifp->if_vnet);
8780dad3f0eSMax Laier 	struct ifg_list		*ifgl;
8790dad3f0eSMax Laier 	struct ifg_group	*ifg = NULL;
8800dad3f0eSMax Laier 	struct ifg_member	*ifgm;
8810dad3f0eSMax Laier 
8820dad3f0eSMax Laier 	if (groupname[0] && groupname[strlen(groupname) - 1] >= '0' &&
8830dad3f0eSMax Laier 	    groupname[strlen(groupname) - 1] <= '9')
8840dad3f0eSMax Laier 		return (EINVAL);
8850dad3f0eSMax Laier 
8860dad3f0eSMax Laier 	IFNET_WLOCK();
8870dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
8880dad3f0eSMax Laier 		if (!strcmp(ifgl->ifgl_group->ifg_group, groupname)) {
8890dad3f0eSMax Laier 			IFNET_WUNLOCK();
8900dad3f0eSMax Laier 			return (EEXIST);
8910dad3f0eSMax Laier 		}
8920dad3f0eSMax Laier 
8930dad3f0eSMax Laier 	if ((ifgl = (struct ifg_list *)malloc(sizeof(struct ifg_list), M_TEMP,
8940dad3f0eSMax Laier 	    M_NOWAIT)) == NULL) {
8950dad3f0eSMax Laier 	    	IFNET_WUNLOCK();
8960dad3f0eSMax Laier 		return (ENOMEM);
8970dad3f0eSMax Laier 	}
8980dad3f0eSMax Laier 
8990dad3f0eSMax Laier 	if ((ifgm = (struct ifg_member *)malloc(sizeof(struct ifg_member),
9000dad3f0eSMax Laier 	    M_TEMP, M_NOWAIT)) == NULL) {
9010dad3f0eSMax Laier 		free(ifgl, M_TEMP);
9020dad3f0eSMax Laier 		IFNET_WUNLOCK();
9030dad3f0eSMax Laier 		return (ENOMEM);
9040dad3f0eSMax Laier 	}
9050dad3f0eSMax Laier 
906603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
9070dad3f0eSMax Laier 		if (!strcmp(ifg->ifg_group, groupname))
9080dad3f0eSMax Laier 			break;
9090dad3f0eSMax Laier 
9100dad3f0eSMax Laier 	if (ifg == NULL) {
9110dad3f0eSMax Laier 		if ((ifg = (struct ifg_group *)malloc(sizeof(struct ifg_group),
9120dad3f0eSMax Laier 		    M_TEMP, M_NOWAIT)) == NULL) {
9130dad3f0eSMax Laier 			free(ifgl, M_TEMP);
9140dad3f0eSMax Laier 			free(ifgm, M_TEMP);
9150dad3f0eSMax Laier 			IFNET_WUNLOCK();
9160dad3f0eSMax Laier 			return (ENOMEM);
9170dad3f0eSMax Laier 		}
9180dad3f0eSMax Laier 		strlcpy(ifg->ifg_group, groupname, sizeof(ifg->ifg_group));
9190dad3f0eSMax Laier 		ifg->ifg_refcnt = 0;
9200dad3f0eSMax Laier 		TAILQ_INIT(&ifg->ifg_members);
9210dad3f0eSMax Laier 		EVENTHANDLER_INVOKE(group_attach_event, ifg);
922603724d3SBjoern A. Zeeb 		TAILQ_INSERT_TAIL(&V_ifg_head, ifg, ifg_next);
9230dad3f0eSMax Laier 	}
9240dad3f0eSMax Laier 
9250dad3f0eSMax Laier 	ifg->ifg_refcnt++;
9260dad3f0eSMax Laier 	ifgl->ifgl_group = ifg;
9270dad3f0eSMax Laier 	ifgm->ifgm_ifp = ifp;
9280dad3f0eSMax Laier 
9290dad3f0eSMax Laier 	IF_ADDR_LOCK(ifp);
9300dad3f0eSMax Laier 	TAILQ_INSERT_TAIL(&ifg->ifg_members, ifgm, ifgm_next);
9310dad3f0eSMax Laier 	TAILQ_INSERT_TAIL(&ifp->if_groups, ifgl, ifgl_next);
9320dad3f0eSMax Laier 	IF_ADDR_UNLOCK(ifp);
9330dad3f0eSMax Laier 
9340dad3f0eSMax Laier 	IFNET_WUNLOCK();
9350dad3f0eSMax Laier 
9360dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
9370dad3f0eSMax Laier 
9380dad3f0eSMax Laier 	return (0);
9390dad3f0eSMax Laier }
9400dad3f0eSMax Laier 
9410dad3f0eSMax Laier /*
9420dad3f0eSMax Laier  * Remove a group from an interface
9430dad3f0eSMax Laier  */
9440dad3f0eSMax Laier int
9450dad3f0eSMax Laier if_delgroup(struct ifnet *ifp, const char *groupname)
9460dad3f0eSMax Laier {
9478b615593SMarko Zec 	INIT_VNET_NET(ifp->if_vnet);
9480dad3f0eSMax Laier 	struct ifg_list		*ifgl;
9490dad3f0eSMax Laier 	struct ifg_member	*ifgm;
9500dad3f0eSMax Laier 
9510dad3f0eSMax Laier 	IFNET_WLOCK();
9520dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
9530dad3f0eSMax Laier 		if (!strcmp(ifgl->ifgl_group->ifg_group, groupname))
9540dad3f0eSMax Laier 			break;
9550dad3f0eSMax Laier 	if (ifgl == NULL) {
9560dad3f0eSMax Laier 		IFNET_WUNLOCK();
9570dad3f0eSMax Laier 		return (ENOENT);
9580dad3f0eSMax Laier 	}
9590dad3f0eSMax Laier 
9600dad3f0eSMax Laier 	IF_ADDR_LOCK(ifp);
9610dad3f0eSMax Laier 	TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
9620dad3f0eSMax Laier 	IF_ADDR_UNLOCK(ifp);
9630dad3f0eSMax Laier 
9640dad3f0eSMax Laier 	TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
9650dad3f0eSMax Laier 		if (ifgm->ifgm_ifp == ifp)
9660dad3f0eSMax Laier 			break;
9670dad3f0eSMax Laier 
9680dad3f0eSMax Laier 	if (ifgm != NULL) {
9690dad3f0eSMax Laier 		TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm, ifgm_next);
9700dad3f0eSMax Laier 		free(ifgm, M_TEMP);
9710dad3f0eSMax Laier 	}
9720dad3f0eSMax Laier 
9730dad3f0eSMax Laier 	if (--ifgl->ifgl_group->ifg_refcnt == 0) {
974603724d3SBjoern A. Zeeb 		TAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_next);
9750dad3f0eSMax Laier 		EVENTHANDLER_INVOKE(group_detach_event, ifgl->ifgl_group);
9760dad3f0eSMax Laier 		free(ifgl->ifgl_group, M_TEMP);
9770dad3f0eSMax Laier 	}
9780dad3f0eSMax Laier 	IFNET_WUNLOCK();
9790dad3f0eSMax Laier 
9800dad3f0eSMax Laier 	free(ifgl, M_TEMP);
9810dad3f0eSMax Laier 
9820dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
9830dad3f0eSMax Laier 
9840dad3f0eSMax Laier 	return (0);
9850dad3f0eSMax Laier }
9860dad3f0eSMax Laier 
9870dad3f0eSMax Laier /*
9880dad3f0eSMax Laier  * Stores all groups from an interface in memory pointed
9890dad3f0eSMax Laier  * to by data
9900dad3f0eSMax Laier  */
9910dad3f0eSMax Laier static int
9920dad3f0eSMax Laier if_getgroup(struct ifgroupreq *data, struct ifnet *ifp)
9930dad3f0eSMax Laier {
9940dad3f0eSMax Laier 	int			 len, error;
9950dad3f0eSMax Laier 	struct ifg_list		*ifgl;
9960dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
9970dad3f0eSMax Laier 	struct ifgroupreq	*ifgr = data;
9980dad3f0eSMax Laier 
9990dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
10000dad3f0eSMax Laier 		IF_ADDR_LOCK(ifp);
10010dad3f0eSMax Laier 		TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
10020dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(struct ifg_req);
10030dad3f0eSMax Laier 		IF_ADDR_UNLOCK(ifp);
10040dad3f0eSMax Laier 		return (0);
10050dad3f0eSMax Laier 	}
10060dad3f0eSMax Laier 
10070dad3f0eSMax Laier 	len = ifgr->ifgr_len;
10080dad3f0eSMax Laier 	ifgp = ifgr->ifgr_groups;
10090dad3f0eSMax Laier 	/* XXX: wire */
10100dad3f0eSMax Laier 	IF_ADDR_LOCK(ifp);
10110dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
10120dad3f0eSMax Laier 		if (len < sizeof(ifgrq)) {
10130dad3f0eSMax Laier 			IF_ADDR_UNLOCK(ifp);
10140dad3f0eSMax Laier 			return (EINVAL);
10150dad3f0eSMax Laier 		}
10160dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
10170dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_group, ifgl->ifgl_group->ifg_group,
10180dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_group));
10190dad3f0eSMax Laier 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
10200dad3f0eSMax Laier 		    	IF_ADDR_UNLOCK(ifp);
10210dad3f0eSMax Laier 			return (error);
10220dad3f0eSMax Laier 		}
10230dad3f0eSMax Laier 		len -= sizeof(ifgrq);
10240dad3f0eSMax Laier 		ifgp++;
10250dad3f0eSMax Laier 	}
10260dad3f0eSMax Laier 	IF_ADDR_UNLOCK(ifp);
10270dad3f0eSMax Laier 
10280dad3f0eSMax Laier 	return (0);
10290dad3f0eSMax Laier }
10300dad3f0eSMax Laier 
10310dad3f0eSMax Laier /*
10320dad3f0eSMax Laier  * Stores all members of a group in memory pointed to by data
10330dad3f0eSMax Laier  */
10340dad3f0eSMax Laier static int
10350dad3f0eSMax Laier if_getgroupmembers(struct ifgroupreq *data)
10360dad3f0eSMax Laier {
10378b615593SMarko Zec 	INIT_VNET_NET(curvnet);
10380dad3f0eSMax Laier 	struct ifgroupreq	*ifgr = data;
10390dad3f0eSMax Laier 	struct ifg_group	*ifg;
10400dad3f0eSMax Laier 	struct ifg_member	*ifgm;
10410dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
10420dad3f0eSMax Laier 	int			 len, error;
10430dad3f0eSMax Laier 
10440dad3f0eSMax Laier 	IFNET_RLOCK();
1045603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
10460dad3f0eSMax Laier 		if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
10470dad3f0eSMax Laier 			break;
10480dad3f0eSMax Laier 	if (ifg == NULL) {
10490dad3f0eSMax Laier 		IFNET_RUNLOCK();
10500dad3f0eSMax Laier 		return (ENOENT);
10510dad3f0eSMax Laier 	}
10520dad3f0eSMax Laier 
10530dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
10540dad3f0eSMax Laier 		TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
10550dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(ifgrq);
10560dad3f0eSMax Laier 		IFNET_RUNLOCK();
10570dad3f0eSMax Laier 		return (0);
10580dad3f0eSMax Laier 	}
10590dad3f0eSMax Laier 
10600dad3f0eSMax Laier 	len = ifgr->ifgr_len;
10610dad3f0eSMax Laier 	ifgp = ifgr->ifgr_groups;
10620dad3f0eSMax Laier 	TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next) {
10630dad3f0eSMax Laier 		if (len < sizeof(ifgrq)) {
10640dad3f0eSMax Laier 			IFNET_RUNLOCK();
10650dad3f0eSMax Laier 			return (EINVAL);
10660dad3f0eSMax Laier 		}
10670dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
10680dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_member, ifgm->ifgm_ifp->if_xname,
10690dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_member));
10700dad3f0eSMax Laier 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
10710dad3f0eSMax Laier 			IFNET_RUNLOCK();
10720dad3f0eSMax Laier 			return (error);
10730dad3f0eSMax Laier 		}
10740dad3f0eSMax Laier 		len -= sizeof(ifgrq);
10750dad3f0eSMax Laier 		ifgp++;
10760dad3f0eSMax Laier 	}
10770dad3f0eSMax Laier 	IFNET_RUNLOCK();
10780dad3f0eSMax Laier 
10790dad3f0eSMax Laier 	return (0);
10800dad3f0eSMax Laier }
10810dad3f0eSMax Laier 
10820dad3f0eSMax Laier /*
10835500d3beSWarner Losh  * Delete Routes for a Network Interface
10845500d3beSWarner Losh  *
10855500d3beSWarner Losh  * Called for each routing entry via the rnh->rnh_walktree() call above
10865500d3beSWarner Losh  * to delete all route entries referencing a detaching network interface.
10875500d3beSWarner Losh  *
10885500d3beSWarner Losh  * Arguments:
10895500d3beSWarner Losh  *	rn	pointer to node in the routing table
10905500d3beSWarner Losh  *	arg	argument passed to rnh->rnh_walktree() - detaching interface
10915500d3beSWarner Losh  *
10925500d3beSWarner Losh  * Returns:
10935500d3beSWarner Losh  *	0	successful
10945500d3beSWarner Losh  *	errno	failed - reason indicated
10955500d3beSWarner Losh  *
10965500d3beSWarner Losh  */
10975500d3beSWarner Losh static int
109872fd1b6aSDag-Erling Smørgrav if_rtdel(struct radix_node *rn, void *arg)
10995500d3beSWarner Losh {
11005500d3beSWarner Losh 	struct rtentry	*rt = (struct rtentry *)rn;
11015500d3beSWarner Losh 	struct ifnet	*ifp = arg;
11025500d3beSWarner Losh 	int		err;
11035500d3beSWarner Losh 
11045500d3beSWarner Losh 	if (rt->rt_ifp == ifp) {
11055500d3beSWarner Losh 
11065500d3beSWarner Losh 		/*
11075500d3beSWarner Losh 		 * Protect (sorta) against walktree recursion problems
11085500d3beSWarner Losh 		 * with cloned routes
11095500d3beSWarner Losh 		 */
11105500d3beSWarner Losh 		if ((rt->rt_flags & RTF_UP) == 0)
11115500d3beSWarner Losh 			return (0);
11125500d3beSWarner Losh 
11138b07e49aSJulian Elischer 		err = rtrequest_fib(RTM_DELETE, rt_key(rt), rt->rt_gateway,
11145500d3beSWarner Losh 				rt_mask(rt), rt->rt_flags,
11158b07e49aSJulian Elischer 				(struct rtentry **) NULL, rt->rt_fibnum);
11165500d3beSWarner Losh 		if (err) {
11175500d3beSWarner Losh 			log(LOG_WARNING, "if_rtdel: error %d\n", err);
11185500d3beSWarner Losh 		}
11195500d3beSWarner Losh 	}
11205500d3beSWarner Losh 
11215500d3beSWarner Losh 	return (0);
11226182fdbdSPeter Wemm }
11236182fdbdSPeter Wemm 
112440d8a302SBruce M Simpson /*
112540d8a302SBruce M Simpson  * XXX: Because sockaddr_dl has deeper structure than the sockaddr
112640d8a302SBruce M Simpson  * structs used to represent other address families, it is necessary
112740d8a302SBruce M Simpson  * to perform a different comparison.
112840d8a302SBruce M Simpson  */
112940d8a302SBruce M Simpson 
113040d8a302SBruce M Simpson #define	sa_equal(a1, a2)	\
113140d8a302SBruce M Simpson 	(bcmp((a1), (a2), ((a1))->sa_len) == 0)
113240d8a302SBruce M Simpson 
113340d8a302SBruce M Simpson #define	sa_dl_equal(a1, a2)	\
113440d8a302SBruce M Simpson 	((((struct sockaddr_dl *)(a1))->sdl_len ==			\
113540d8a302SBruce M Simpson 	 ((struct sockaddr_dl *)(a2))->sdl_len) &&			\
113640d8a302SBruce M Simpson 	 (bcmp(LLADDR((struct sockaddr_dl *)(a1)),			\
113740d8a302SBruce M Simpson 	       LLADDR((struct sockaddr_dl *)(a2)),			\
113840d8a302SBruce M Simpson 	       ((struct sockaddr_dl *)(a1))->sdl_alen) == 0))
113919fc74fbSJeffrey Hsu 
114030aad87dSBrooks Davis /*
1141df8bae1dSRodney W. Grimes  * Locate an interface based on a complete address.
1142df8bae1dSRodney W. Grimes  */
1143df8bae1dSRodney W. Grimes /*ARGSUSED*/
1144df8bae1dSRodney W. Grimes struct ifaddr *
114572fd1b6aSDag-Erling Smørgrav ifa_ifwithaddr(struct sockaddr *addr)
1146df8bae1dSRodney W. Grimes {
11478b615593SMarko Zec 	INIT_VNET_NET(curvnet);
11480b59d917SJonathan Lemon 	struct ifnet *ifp;
11490b59d917SJonathan Lemon 	struct ifaddr *ifa;
1150df8bae1dSRodney W. Grimes 
1151b30a244cSJeffrey Hsu 	IFNET_RLOCK();
1152603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link)
115337d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1154df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1155df8bae1dSRodney W. Grimes 				continue;
1156d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_addr))
11570b59d917SJonathan Lemon 				goto done;
115882cd038dSYoshinobu Inoue 			/* IP6 doesn't have broadcast */
11590b59d917SJonathan Lemon 			if ((ifp->if_flags & IFF_BROADCAST) &&
11600b59d917SJonathan Lemon 			    ifa->ifa_broadaddr &&
116182cd038dSYoshinobu Inoue 			    ifa->ifa_broadaddr->sa_len != 0 &&
1162d8d5b10eSRobert Watson 			    sa_equal(ifa->ifa_broadaddr, addr))
11630b59d917SJonathan Lemon 				goto done;
11640b59d917SJonathan Lemon 		}
11650b59d917SJonathan Lemon 	ifa = NULL;
11660b59d917SJonathan Lemon done:
1167b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
1168df8bae1dSRodney W. Grimes 	return (ifa);
1169df8bae1dSRodney W. Grimes }
11700b59d917SJonathan Lemon 
1171df8bae1dSRodney W. Grimes /*
1172773725a2SAndre Oppermann  * Locate an interface based on the broadcast address.
1173773725a2SAndre Oppermann  */
1174773725a2SAndre Oppermann /* ARGSUSED */
1175773725a2SAndre Oppermann struct ifaddr *
1176773725a2SAndre Oppermann ifa_ifwithbroadaddr(struct sockaddr *addr)
1177773725a2SAndre Oppermann {
11788b615593SMarko Zec 	INIT_VNET_NET(curvnet);
1179773725a2SAndre Oppermann 	struct ifnet *ifp;
1180773725a2SAndre Oppermann 	struct ifaddr *ifa;
1181773725a2SAndre Oppermann 
1182773725a2SAndre Oppermann 	IFNET_RLOCK();
1183603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link)
1184773725a2SAndre Oppermann 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1185773725a2SAndre Oppermann 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1186773725a2SAndre Oppermann 				continue;
1187773725a2SAndre Oppermann 			if ((ifp->if_flags & IFF_BROADCAST) &&
1188773725a2SAndre Oppermann 			    ifa->ifa_broadaddr &&
1189773725a2SAndre Oppermann 			    ifa->ifa_broadaddr->sa_len != 0 &&
1190773725a2SAndre Oppermann 			    sa_equal(ifa->ifa_broadaddr, addr))
1191773725a2SAndre Oppermann 				goto done;
1192773725a2SAndre Oppermann 		}
1193773725a2SAndre Oppermann 	ifa = NULL;
1194773725a2SAndre Oppermann done:
1195773725a2SAndre Oppermann 	IFNET_RUNLOCK();
1196773725a2SAndre Oppermann 	return (ifa);
1197773725a2SAndre Oppermann }
1198773725a2SAndre Oppermann 
1199773725a2SAndre Oppermann /*
1200df8bae1dSRodney W. Grimes  * Locate the point to point interface with a given destination address.
1201df8bae1dSRodney W. Grimes  */
1202df8bae1dSRodney W. Grimes /*ARGSUSED*/
1203df8bae1dSRodney W. Grimes struct ifaddr *
120472fd1b6aSDag-Erling Smørgrav ifa_ifwithdstaddr(struct sockaddr *addr)
1205df8bae1dSRodney W. Grimes {
12068b615593SMarko Zec 	INIT_VNET_NET(curvnet);
12070b59d917SJonathan Lemon 	struct ifnet *ifp;
12080b59d917SJonathan Lemon 	struct ifaddr *ifa;
1209df8bae1dSRodney W. Grimes 
1210b30a244cSJeffrey Hsu 	IFNET_RLOCK();
1211603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
12120b59d917SJonathan Lemon 		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
12130b59d917SJonathan Lemon 			continue;
121437d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1215df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1216df8bae1dSRodney W. Grimes 				continue;
1217f0c04221SBjoern A. Zeeb 			if (ifa->ifa_dstaddr != NULL &&
1218d8d5b10eSRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr))
12190b59d917SJonathan Lemon 				goto done;
1220df8bae1dSRodney W. Grimes 		}
12210b59d917SJonathan Lemon 	}
12220b59d917SJonathan Lemon 	ifa = NULL;
12230b59d917SJonathan Lemon done:
1224b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
12250b59d917SJonathan Lemon 	return (ifa);
1226df8bae1dSRodney W. Grimes }
1227df8bae1dSRodney W. Grimes 
1228df8bae1dSRodney W. Grimes /*
1229df8bae1dSRodney W. Grimes  * Find an interface on a specific network.  If many, choice
1230df8bae1dSRodney W. Grimes  * is most specific found.
1231df8bae1dSRodney W. Grimes  */
1232df8bae1dSRodney W. Grimes struct ifaddr *
123372fd1b6aSDag-Erling Smørgrav ifa_ifwithnet(struct sockaddr *addr)
1234df8bae1dSRodney W. Grimes {
12358b615593SMarko Zec 	INIT_VNET_NET(curvnet);
123672fd1b6aSDag-Erling Smørgrav 	struct ifnet *ifp;
123772fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
1238df8bae1dSRodney W. Grimes 	struct ifaddr *ifa_maybe = (struct ifaddr *) 0;
1239df8bae1dSRodney W. Grimes 	u_int af = addr->sa_family;
1240df8bae1dSRodney W. Grimes 	char *addr_data = addr->sa_data, *cplim;
1241df8bae1dSRodney W. Grimes 
12427e2a6151SJulian Elischer 	/*
12437e2a6151SJulian Elischer 	 * AF_LINK addresses can be looked up directly by their index number,
12447e2a6151SJulian Elischer 	 * so do that if we can.
12457e2a6151SJulian Elischer 	 */
1246df8bae1dSRodney W. Grimes 	if (af == AF_LINK) {
1247d1dd20beSSam Leffler 	    struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
1248603724d3SBjoern A. Zeeb 	    if (sdl->sdl_index && sdl->sdl_index <= V_if_index)
1249f9132cebSJonathan Lemon 		return (ifaddr_byindex(sdl->sdl_index));
1250df8bae1dSRodney W. Grimes 	}
12517e2a6151SJulian Elischer 
12527e2a6151SJulian Elischer 	/*
12537e2a6151SJulian Elischer 	 * Scan though each interface, looking for ones that have
12547e2a6151SJulian Elischer 	 * addresses in this address family.
12557e2a6151SJulian Elischer 	 */
1256b30a244cSJeffrey Hsu 	IFNET_RLOCK();
1257603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
125837d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
125972fd1b6aSDag-Erling Smørgrav 			char *cp, *cp2, *cp3;
1260df8bae1dSRodney W. Grimes 
1261523a02aaSDavid Greenman 			if (ifa->ifa_addr->sa_family != af)
1262df8bae1dSRodney W. Grimes next:				continue;
1263c61cd599SHajimu UMEMOTO 			if (af == AF_INET && ifp->if_flags & IFF_POINTOPOINT) {
12647e2a6151SJulian Elischer 				/*
12657e2a6151SJulian Elischer 				 * This is a bit broken as it doesn't
12667e2a6151SJulian Elischer 				 * take into account that the remote end may
12677e2a6151SJulian Elischer 				 * be a single node in the network we are
12687e2a6151SJulian Elischer 				 * looking for.
12697e2a6151SJulian Elischer 				 * The trouble is that we don't know the
12707e2a6151SJulian Elischer 				 * netmask for the remote end.
12717e2a6151SJulian Elischer 				 */
1272f0c04221SBjoern A. Zeeb 				if (ifa->ifa_dstaddr != NULL &&
1273d8d5b10eSRobert Watson 				    sa_equal(addr, ifa->ifa_dstaddr))
12740b59d917SJonathan Lemon 					goto done;
12753740e2adSDavid Greenman 			} else {
12767e2a6151SJulian Elischer 				/*
12777ed8f465SJulian Elischer 				 * if we have a special address handler,
12787ed8f465SJulian Elischer 				 * then use it instead of the generic one.
12797ed8f465SJulian Elischer 				 */
12807ed8f465SJulian Elischer 				if (ifa->ifa_claim_addr) {
12810b59d917SJonathan Lemon 					if ((*ifa->ifa_claim_addr)(ifa, addr))
12820b59d917SJonathan Lemon 						goto done;
12837ed8f465SJulian Elischer 					continue;
12847ed8f465SJulian Elischer 				}
12857ed8f465SJulian Elischer 
12867ed8f465SJulian Elischer 				/*
12877e2a6151SJulian Elischer 				 * Scan all the bits in the ifa's address.
12887e2a6151SJulian Elischer 				 * If a bit dissagrees with what we are
12897e2a6151SJulian Elischer 				 * looking for, mask it with the netmask
12907e2a6151SJulian Elischer 				 * to see if it really matters.
12917e2a6151SJulian Elischer 				 * (A byte at a time)
12927e2a6151SJulian Elischer 				 */
1293523a02aaSDavid Greenman 				if (ifa->ifa_netmask == 0)
1294523a02aaSDavid Greenman 					continue;
1295df8bae1dSRodney W. Grimes 				cp = addr_data;
1296df8bae1dSRodney W. Grimes 				cp2 = ifa->ifa_addr->sa_data;
1297df8bae1dSRodney W. Grimes 				cp3 = ifa->ifa_netmask->sa_data;
12987e2a6151SJulian Elischer 				cplim = ifa->ifa_netmask->sa_len
12997e2a6151SJulian Elischer 					+ (char *)ifa->ifa_netmask;
1300df8bae1dSRodney W. Grimes 				while (cp3 < cplim)
1301df8bae1dSRodney W. Grimes 					if ((*cp++ ^ *cp2++) & *cp3++)
13027e2a6151SJulian Elischer 						goto next; /* next address! */
13037e2a6151SJulian Elischer 				/*
13047e2a6151SJulian Elischer 				 * If the netmask of what we just found
13057e2a6151SJulian Elischer 				 * is more specific than what we had before
13067e2a6151SJulian Elischer 				 * (if we had one) then remember the new one
13077e2a6151SJulian Elischer 				 * before continuing to search
13087e2a6151SJulian Elischer 				 * for an even better one.
13097e2a6151SJulian Elischer 				 */
1310df8bae1dSRodney W. Grimes 				if (ifa_maybe == 0 ||
1311df8bae1dSRodney W. Grimes 				    rn_refines((caddr_t)ifa->ifa_netmask,
1312df8bae1dSRodney W. Grimes 				    (caddr_t)ifa_maybe->ifa_netmask))
1313df8bae1dSRodney W. Grimes 					ifa_maybe = ifa;
1314df8bae1dSRodney W. Grimes 			}
1315b2af64fdSDavid Greenman 		}
1316b2af64fdSDavid Greenman 	}
13170b59d917SJonathan Lemon 	ifa = ifa_maybe;
13180b59d917SJonathan Lemon done:
1319b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
13200b59d917SJonathan Lemon 	return (ifa);
1321df8bae1dSRodney W. Grimes }
1322df8bae1dSRodney W. Grimes 
1323df8bae1dSRodney W. Grimes /*
1324df8bae1dSRodney W. Grimes  * Find an interface address specific to an interface best matching
1325df8bae1dSRodney W. Grimes  * a given address.
1326df8bae1dSRodney W. Grimes  */
1327df8bae1dSRodney W. Grimes struct ifaddr *
132872fd1b6aSDag-Erling Smørgrav ifaof_ifpforaddr(struct sockaddr *addr, struct ifnet *ifp)
1329df8bae1dSRodney W. Grimes {
133072fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
133172fd1b6aSDag-Erling Smørgrav 	char *cp, *cp2, *cp3;
133272fd1b6aSDag-Erling Smørgrav 	char *cplim;
1333df8bae1dSRodney W. Grimes 	struct ifaddr *ifa_maybe = 0;
1334df8bae1dSRodney W. Grimes 	u_int af = addr->sa_family;
1335df8bae1dSRodney W. Grimes 
1336df8bae1dSRodney W. Grimes 	if (af >= AF_MAX)
1337df8bae1dSRodney W. Grimes 		return (0);
133837d40066SPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1339df8bae1dSRodney W. Grimes 		if (ifa->ifa_addr->sa_family != af)
1340df8bae1dSRodney W. Grimes 			continue;
1341381dd1d2SJulian Elischer 		if (ifa_maybe == 0)
1342df8bae1dSRodney W. Grimes 			ifa_maybe = ifa;
1343df8bae1dSRodney W. Grimes 		if (ifa->ifa_netmask == 0) {
1344d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_addr) ||
1345d8d5b10eSRobert Watson 			    (ifa->ifa_dstaddr &&
1346d8d5b10eSRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr)))
13472defe5cdSJonathan Lemon 				goto done;
1348df8bae1dSRodney W. Grimes 			continue;
1349df8bae1dSRodney W. Grimes 		}
1350b2af64fdSDavid Greenman 		if (ifp->if_flags & IFF_POINTOPOINT) {
1351d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_dstaddr))
1352a8637146SJonathan Lemon 				goto done;
13533740e2adSDavid Greenman 		} else {
1354df8bae1dSRodney W. Grimes 			cp = addr->sa_data;
1355df8bae1dSRodney W. Grimes 			cp2 = ifa->ifa_addr->sa_data;
1356df8bae1dSRodney W. Grimes 			cp3 = ifa->ifa_netmask->sa_data;
1357df8bae1dSRodney W. Grimes 			cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
1358df8bae1dSRodney W. Grimes 			for (; cp3 < cplim; cp3++)
1359df8bae1dSRodney W. Grimes 				if ((*cp++ ^ *cp2++) & *cp3)
1360df8bae1dSRodney W. Grimes 					break;
1361df8bae1dSRodney W. Grimes 			if (cp3 == cplim)
13622defe5cdSJonathan Lemon 				goto done;
1363df8bae1dSRodney W. Grimes 		}
1364b2af64fdSDavid Greenman 	}
1365f9132cebSJonathan Lemon 	ifa = ifa_maybe;
1366f9132cebSJonathan Lemon done:
1367f9132cebSJonathan Lemon 	return (ifa);
1368df8bae1dSRodney W. Grimes }
1369df8bae1dSRodney W. Grimes 
13706e6b3f7cSQing Li #include <net/route.h>
13716e6b3f7cSQing Li #include <net/if_llatbl.h>
13726e6b3f7cSQing Li 
1373df8bae1dSRodney W. Grimes /*
1374df8bae1dSRodney W. Grimes  * Default action when installing a route with a Link Level gateway.
1375df8bae1dSRodney W. Grimes  * Lookup an appropriate real ifa to point to.
1376df8bae1dSRodney W. Grimes  * This should be moved to /sys/net/link.c eventually.
1377df8bae1dSRodney W. Grimes  */
13783bda9f9bSPoul-Henning Kamp static void
137972fd1b6aSDag-Erling Smørgrav link_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
1380df8bae1dSRodney W. Grimes {
138172fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa, *oifa;
1382df8bae1dSRodney W. Grimes 	struct sockaddr *dst;
1383df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
1384df8bae1dSRodney W. Grimes 
1385d1dd20beSSam Leffler 	RT_LOCK_ASSERT(rt);
1386d1dd20beSSam Leffler 
1387df8bae1dSRodney W. Grimes 	if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) ||
1388df8bae1dSRodney W. Grimes 	    ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0))
1389df8bae1dSRodney W. Grimes 		return;
13909448326fSPoul-Henning Kamp 	ifa = ifaof_ifpforaddr(dst, ifp);
13919448326fSPoul-Henning Kamp 	if (ifa) {
139219fc74fbSJeffrey Hsu 		IFAREF(ifa);		/* XXX */
1393d1dd20beSSam Leffler 		oifa = rt->rt_ifa;
1394df8bae1dSRodney W. Grimes 		rt->rt_ifa = ifa;
1395d1dd20beSSam Leffler 		IFAFREE(oifa);
1396df8bae1dSRodney W. Grimes 		if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
13978071913dSRuslan Ermilov 			ifa->ifa_rtrequest(cmd, rt, info);
1398df8bae1dSRodney W. Grimes 	}
1399df8bae1dSRodney W. Grimes }
1400df8bae1dSRodney W. Grimes 
1401df8bae1dSRodney W. Grimes /*
1402df8bae1dSRodney W. Grimes  * Mark an interface down and notify protocols of
1403df8bae1dSRodney W. Grimes  * the transition.
1404df8bae1dSRodney W. Grimes  * NOTE: must be called at splnet or eqivalent.
1405df8bae1dSRodney W. Grimes  */
14068614fb12SMax Laier static void
140772fd1b6aSDag-Erling Smørgrav if_unroute(struct ifnet *ifp, int flag, int fam)
1408df8bae1dSRodney W. Grimes {
140972fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
1410df8bae1dSRodney W. Grimes 
1411292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_unroute: flag != IFF_UP"));
1412292ee7beSRobert Watson 
1413e8c2601dSPoul-Henning Kamp 	ifp->if_flags &= ~flag;
141498b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
1415e8c2601dSPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
1416e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
1417df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
1418db7f0b97SKip Macy 	ifp->if_qflush(ifp);
1419db7f0b97SKip Macy 
1420a9771948SGleb Smirnoff #ifdef DEV_CARP
1421a9771948SGleb Smirnoff 	if (ifp->if_carp)
1422a9771948SGleb Smirnoff 		carp_carpdev_state(ifp->if_carp);
1423a9771948SGleb Smirnoff #endif
1424df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
1425df8bae1dSRodney W. Grimes }
1426df8bae1dSRodney W. Grimes 
1427df8bae1dSRodney W. Grimes /*
1428df8bae1dSRodney W. Grimes  * Mark an interface up and notify protocols of
1429df8bae1dSRodney W. Grimes  * the transition.
1430df8bae1dSRodney W. Grimes  * NOTE: must be called at splnet or eqivalent.
1431df8bae1dSRodney W. Grimes  */
14328614fb12SMax Laier static void
143372fd1b6aSDag-Erling Smørgrav if_route(struct ifnet *ifp, int flag, int fam)
1434df8bae1dSRodney W. Grimes {
143572fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
1436df8bae1dSRodney W. Grimes 
1437292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_route: flag != IFF_UP"));
1438292ee7beSRobert Watson 
1439e8c2601dSPoul-Henning Kamp 	ifp->if_flags |= flag;
144098b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
1441e8c2601dSPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
1442e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
1443df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFUP, ifa->ifa_addr);
1444a9771948SGleb Smirnoff #ifdef DEV_CARP
1445a9771948SGleb Smirnoff 	if (ifp->if_carp)
1446a9771948SGleb Smirnoff 		carp_carpdev_state(ifp->if_carp);
1447a9771948SGleb Smirnoff #endif
1448df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
144982cd038dSYoshinobu Inoue #ifdef INET6
145082cd038dSYoshinobu Inoue 	in6_if_up(ifp);
145182cd038dSYoshinobu Inoue #endif
1452df8bae1dSRodney W. Grimes }
1453df8bae1dSRodney W. Grimes 
145494f5c9cfSSam Leffler void	(*vlan_link_state_p)(struct ifnet *, int);	/* XXX: private from if_vlan */
145575ee267cSGleb Smirnoff void	(*vlan_trunk_cap_p)(struct ifnet *);		/* XXX: private from if_vlan */
145694f5c9cfSSam Leffler 
145794f5c9cfSSam Leffler /*
145868a3482fSGleb Smirnoff  * Handle a change in the interface link state. To avoid LORs
145968a3482fSGleb Smirnoff  * between driver lock and upper layer locks, as well as possible
146068a3482fSGleb Smirnoff  * recursions, we post event to taskqueue, and all job
146168a3482fSGleb Smirnoff  * is done in static do_link_state_change().
146294f5c9cfSSam Leffler  */
146394f5c9cfSSam Leffler void
146494f5c9cfSSam Leffler if_link_state_change(struct ifnet *ifp, int link_state)
146594f5c9cfSSam Leffler {
14664d96314fSGleb Smirnoff 	/* Return if state hasn't changed. */
14674d96314fSGleb Smirnoff 	if (ifp->if_link_state == link_state)
14684d96314fSGleb Smirnoff 		return;
14694d96314fSGleb Smirnoff 
147094f5c9cfSSam Leffler 	ifp->if_link_state = link_state;
14714d96314fSGleb Smirnoff 
147268a3482fSGleb Smirnoff 	taskqueue_enqueue(taskqueue_swi, &ifp->if_linktask);
147368a3482fSGleb Smirnoff }
147468a3482fSGleb Smirnoff 
147568a3482fSGleb Smirnoff static void
147668a3482fSGleb Smirnoff do_link_state_change(void *arg, int pending)
147768a3482fSGleb Smirnoff {
147868a3482fSGleb Smirnoff 	struct ifnet *ifp = (struct ifnet *)arg;
147968a3482fSGleb Smirnoff 	int link_state = ifp->if_link_state;
148068a3482fSGleb Smirnoff 	int link;
14818b615593SMarko Zec 	CURVNET_SET(ifp->if_vnet);
148268a3482fSGleb Smirnoff 
14834d96314fSGleb Smirnoff 	/* Notify that the link state has changed. */
148494f5c9cfSSam Leffler 	rt_ifmsg(ifp);
148594f5c9cfSSam Leffler 	if (link_state == LINK_STATE_UP)
148694f5c9cfSSam Leffler 		link = NOTE_LINKUP;
148794f5c9cfSSam Leffler 	else if (link_state == LINK_STATE_DOWN)
148894f5c9cfSSam Leffler 		link = NOTE_LINKDOWN;
148994f5c9cfSSam Leffler 	else
149094f5c9cfSSam Leffler 		link = NOTE_LINKINV;
149194f5c9cfSSam Leffler 	KNOTE_UNLOCKED(&ifp->if_klist, link);
149275ee267cSGleb Smirnoff 	if (ifp->if_vlantrunk != NULL)
149394f5c9cfSSam Leffler 		(*vlan_link_state_p)(ifp, link);
14941c7899c7SGleb Smirnoff 
14951c7899c7SGleb Smirnoff 	if ((ifp->if_type == IFT_ETHER || ifp->if_type == IFT_L2VLAN) &&
14961c7899c7SGleb Smirnoff 	    IFP2AC(ifp)->ac_netgraph != NULL)
14971c7899c7SGleb Smirnoff 		(*ng_ether_link_state_p)(ifp, link_state);
14984d96314fSGleb Smirnoff #ifdef DEV_CARP
14994d96314fSGleb Smirnoff 	if (ifp->if_carp)
15004d96314fSGleb Smirnoff 		carp_carpdev_state(ifp->if_carp);
15014d96314fSGleb Smirnoff #endif
15028f867517SAndrew Thompson 	if (ifp->if_bridge) {
15038f867517SAndrew Thompson 		KASSERT(bstp_linkstate_p != NULL,("if_bridge bstp not loaded!"));
15048f867517SAndrew Thompson 		(*bstp_linkstate_p)(ifp, link_state);
15058f867517SAndrew Thompson 	}
150618242d3bSAndrew Thompson 	if (ifp->if_lagg) {
150718242d3bSAndrew Thompson 		KASSERT(lagg_linkstate_p != NULL,("if_lagg not loaded!"));
150818242d3bSAndrew Thompson 		(*lagg_linkstate_p)(ifp, link_state);
1509b47888ceSAndrew Thompson 	}
15108f867517SAndrew Thompson 
15119d80a330SBrooks Davis 	devctl_notify("IFNET", ifp->if_xname,
15129d80a330SBrooks Davis 	    (link_state == LINK_STATE_UP) ? "LINK_UP" : "LINK_DOWN", NULL);
151368a3482fSGleb Smirnoff 	if (pending > 1)
151468a3482fSGleb Smirnoff 		if_printf(ifp, "%d link states coalesced\n", pending);
15155515c2e7SGleb Smirnoff 	if (log_link_state_change)
15168b02df24SGleb Smirnoff 		log(LOG_NOTICE, "%s: link state changed to %s\n", ifp->if_xname,
15178b02df24SGleb Smirnoff 		    (link_state == LINK_STATE_UP) ? "UP" : "DOWN" );
15188b615593SMarko Zec 	CURVNET_RESTORE();
151994f5c9cfSSam Leffler }
152094f5c9cfSSam Leffler 
1521df8bae1dSRodney W. Grimes /*
1522e8c2601dSPoul-Henning Kamp  * Mark an interface down and notify protocols of
1523e8c2601dSPoul-Henning Kamp  * the transition.
1524e8c2601dSPoul-Henning Kamp  * NOTE: must be called at splnet or eqivalent.
1525e8c2601dSPoul-Henning Kamp  */
1526e8c2601dSPoul-Henning Kamp void
152772fd1b6aSDag-Erling Smørgrav if_down(struct ifnet *ifp)
1528e8c2601dSPoul-Henning Kamp {
1529e8c2601dSPoul-Henning Kamp 
1530e8c2601dSPoul-Henning Kamp 	if_unroute(ifp, IFF_UP, AF_UNSPEC);
1531e8c2601dSPoul-Henning Kamp }
1532e8c2601dSPoul-Henning Kamp 
1533e8c2601dSPoul-Henning Kamp /*
1534e8c2601dSPoul-Henning Kamp  * Mark an interface up and notify protocols of
1535e8c2601dSPoul-Henning Kamp  * the transition.
1536e8c2601dSPoul-Henning Kamp  * NOTE: must be called at splnet or eqivalent.
1537e8c2601dSPoul-Henning Kamp  */
1538e8c2601dSPoul-Henning Kamp void
153972fd1b6aSDag-Erling Smørgrav if_up(struct ifnet *ifp)
1540e8c2601dSPoul-Henning Kamp {
1541e8c2601dSPoul-Henning Kamp 
1542e8c2601dSPoul-Henning Kamp 	if_route(ifp, IFF_UP, AF_UNSPEC);
1543e8c2601dSPoul-Henning Kamp }
1544e8c2601dSPoul-Henning Kamp 
1545e8c2601dSPoul-Henning Kamp /*
1546df8bae1dSRodney W. Grimes  * Flush an interface queue.
1547df8bae1dSRodney W. Grimes  */
15483bda9f9bSPoul-Henning Kamp static void
1549db7f0b97SKip Macy if_qflush(struct ifnet *ifp)
1550df8bae1dSRodney W. Grimes {
155172fd1b6aSDag-Erling Smørgrav 	struct mbuf *m, *n;
1552db7f0b97SKip Macy 	struct ifaltq *ifq;
1553df8bae1dSRodney W. Grimes 
1554db7f0b97SKip Macy 	ifq = &ifp->if_snd;
15557b21048cSMax Laier 	IFQ_LOCK(ifq);
155602b199f1SMax Laier #ifdef ALTQ
155702b199f1SMax Laier 	if (ALTQ_IS_ENABLED(ifq))
155802b199f1SMax Laier 		ALTQ_PURGE(ifq);
155902b199f1SMax Laier #endif
1560df8bae1dSRodney W. Grimes 	n = ifq->ifq_head;
15619448326fSPoul-Henning Kamp 	while ((m = n) != 0) {
1562df8bae1dSRodney W. Grimes 		n = m->m_act;
1563df8bae1dSRodney W. Grimes 		m_freem(m);
1564df8bae1dSRodney W. Grimes 	}
1565df8bae1dSRodney W. Grimes 	ifq->ifq_head = 0;
1566df8bae1dSRodney W. Grimes 	ifq->ifq_tail = 0;
1567df8bae1dSRodney W. Grimes 	ifq->ifq_len = 0;
15687b21048cSMax Laier 	IFQ_UNLOCK(ifq);
1569df8bae1dSRodney W. Grimes }
1570df8bae1dSRodney W. Grimes 
1571df8bae1dSRodney W. Grimes /*
1572df8bae1dSRodney W. Grimes  * Handle interface watchdog timer routines.  Called
1573df8bae1dSRodney W. Grimes  * from softclock, we decrement timers (if set) and
1574df8bae1dSRodney W. Grimes  * call the appropriate interface routine on expiration.
1575af5e59bfSRobert Watson  *
1576af5e59bfSRobert Watson  * XXXRW: Note that because timeouts run with Giant, if_watchdog() is called
1577af5e59bfSRobert Watson  * holding Giant.  If we switch to an MPSAFE callout, we likely need to grab
1578af5e59bfSRobert Watson  * Giant before entering if_watchdog() on an IFF_NEEDSGIANT interface.
1579df8bae1dSRodney W. Grimes  */
15803bda9f9bSPoul-Henning Kamp static void
158172fd1b6aSDag-Erling Smørgrav if_slowtimo(void *arg)
1582df8bae1dSRodney W. Grimes {
15838b615593SMarko Zec 	VNET_ITERATOR_DECL(vnet_iter);
158472fd1b6aSDag-Erling Smørgrav 	struct ifnet *ifp;
1585df8bae1dSRodney W. Grimes 	int s = splimp();
1586df8bae1dSRodney W. Grimes 
1587b30a244cSJeffrey Hsu 	IFNET_RLOCK();
15888b615593SMarko Zec 	VNET_LIST_RLOCK();
15898b615593SMarko Zec 	VNET_FOREACH(vnet_iter) {
15908b615593SMarko Zec 		CURVNET_SET(vnet_iter);
15918b615593SMarko Zec 		INIT_VNET_NET(vnet_iter);
1592603724d3SBjoern A. Zeeb 		TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1593df8bae1dSRodney W. Grimes 			if (ifp->if_timer == 0 || --ifp->if_timer)
1594df8bae1dSRodney W. Grimes 				continue;
1595df8bae1dSRodney W. Grimes 			if (ifp->if_watchdog)
15964a5f1499SDavid Greenman 				(*ifp->if_watchdog)(ifp);
1597df8bae1dSRodney W. Grimes 		}
15988b615593SMarko Zec 		CURVNET_RESTORE();
15998b615593SMarko Zec 	}
16008b615593SMarko Zec 	VNET_LIST_RUNLOCK();
1601b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
1602df8bae1dSRodney W. Grimes 	splx(s);
1603df8bae1dSRodney W. Grimes 	timeout(if_slowtimo, (void *)0, hz / IFNET_SLOWHZ);
1604df8bae1dSRodney W. Grimes }
1605df8bae1dSRodney W. Grimes 
1606df8bae1dSRodney W. Grimes /*
1607df8bae1dSRodney W. Grimes  * Map interface name to
1608df8bae1dSRodney W. Grimes  * interface structure pointer.
1609df8bae1dSRodney W. Grimes  */
1610df8bae1dSRodney W. Grimes struct ifnet *
161130aad87dSBrooks Davis ifunit(const char *name)
1612df8bae1dSRodney W. Grimes {
16138b615593SMarko Zec 	INIT_VNET_NET(curvnet);
16148b7805e4SBoris Popov 	struct ifnet *ifp;
1615df8bae1dSRodney W. Grimes 
1616b30a244cSJeffrey Hsu 	IFNET_RLOCK();
1617603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
161836c19a57SBrooks Davis 		if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0)
1619df8bae1dSRodney W. Grimes 			break;
1620df8bae1dSRodney W. Grimes 	}
1621b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
1622df8bae1dSRodney W. Grimes 	return (ifp);
1623df8bae1dSRodney W. Grimes }
1624df8bae1dSRodney W. Grimes 
162582cd038dSYoshinobu Inoue /*
1626f13ad206SJonathan Lemon  * Hardware specific interface ioctls.
1627df8bae1dSRodney W. Grimes  */
1628f13ad206SJonathan Lemon static int
1629f13ad206SJonathan Lemon ifhwioctl(u_long cmd, struct ifnet *ifp, caddr_t data, struct thread *td)
1630df8bae1dSRodney W. Grimes {
1631f13ad206SJonathan Lemon 	struct ifreq *ifr;
1632413dd0baSPoul-Henning Kamp 	struct ifstat *ifs;
1633f13ad206SJonathan Lemon 	int error = 0;
1634292ee7beSRobert Watson 	int new_flags, temp_flags;
163536c19a57SBrooks Davis 	size_t namelen, onamelen;
163636c19a57SBrooks Davis 	char new_name[IFNAMSIZ];
163736c19a57SBrooks Davis 	struct ifaddr *ifa;
163836c19a57SBrooks Davis 	struct sockaddr_dl *sdl;
1639df8bae1dSRodney W. Grimes 
1640df8bae1dSRodney W. Grimes 	ifr = (struct ifreq *)data;
164130aad87dSBrooks Davis 	switch (cmd) {
1642de593450SJonathan Lemon 	case SIOCGIFINDEX:
1643de593450SJonathan Lemon 		ifr->ifr_index = ifp->if_index;
1644de593450SJonathan Lemon 		break;
1645de593450SJonathan Lemon 
1646df8bae1dSRodney W. Grimes 	case SIOCGIFFLAGS:
1647292ee7beSRobert Watson 		temp_flags = ifp->if_flags | ifp->if_drv_flags;
1648292ee7beSRobert Watson 		ifr->ifr_flags = temp_flags & 0xffff;
1649292ee7beSRobert Watson 		ifr->ifr_flagshigh = temp_flags >> 16;
1650df8bae1dSRodney W. Grimes 		break;
1651df8bae1dSRodney W. Grimes 
1652016da741SJonathan Lemon 	case SIOCGIFCAP:
1653016da741SJonathan Lemon 		ifr->ifr_reqcap = ifp->if_capabilities;
1654016da741SJonathan Lemon 		ifr->ifr_curcap = ifp->if_capenable;
1655016da741SJonathan Lemon 		break;
1656016da741SJonathan Lemon 
16578f293a63SRobert Watson #ifdef MAC
16588f293a63SRobert Watson 	case SIOCGIFMAC:
165930d239bcSRobert Watson 		error = mac_ifnet_ioctl_get(td->td_ucred, ifr, ifp);
16608f293a63SRobert Watson 		break;
16618f293a63SRobert Watson #endif
16628f293a63SRobert Watson 
1663df8bae1dSRodney W. Grimes 	case SIOCGIFMETRIC:
1664df8bae1dSRodney W. Grimes 		ifr->ifr_metric = ifp->if_metric;
1665df8bae1dSRodney W. Grimes 		break;
1666df8bae1dSRodney W. Grimes 
1667a7028af7SDavid Greenman 	case SIOCGIFMTU:
1668a7028af7SDavid Greenman 		ifr->ifr_mtu = ifp->if_mtu;
1669a7028af7SDavid Greenman 		break;
1670a7028af7SDavid Greenman 
1671074c4a4eSGarrett Wollman 	case SIOCGIFPHYS:
1672074c4a4eSGarrett Wollman 		ifr->ifr_phys = ifp->if_physical;
1673074c4a4eSGarrett Wollman 		break;
1674074c4a4eSGarrett Wollman 
1675df8bae1dSRodney W. Grimes 	case SIOCSIFFLAGS:
1676acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFFLAGS);
16779448326fSPoul-Henning Kamp 		if (error)
1678df8bae1dSRodney W. Grimes 			return (error);
1679292ee7beSRobert Watson 		/*
1680292ee7beSRobert Watson 		 * Currently, no driver owned flags pass the IFF_CANTCHANGE
1681292ee7beSRobert Watson 		 * check, so we don't need special handling here yet.
1682292ee7beSRobert Watson 		 */
168362f76486SMaxim Sobolev 		new_flags = (ifr->ifr_flags & 0xffff) |
168462f76486SMaxim Sobolev 		    (ifr->ifr_flagshigh << 16);
1685cf4b9371SPoul-Henning Kamp 		if (ifp->if_flags & IFF_SMART) {
1686cf4b9371SPoul-Henning Kamp 			/* Smart drivers twiddle their own routes */
16872f55ead7SPoul-Henning Kamp 		} else if (ifp->if_flags & IFF_UP &&
168862f76486SMaxim Sobolev 		    (new_flags & IFF_UP) == 0) {
1689df8bae1dSRodney W. Grimes 			int s = splimp();
1690df8bae1dSRodney W. Grimes 			if_down(ifp);
1691df8bae1dSRodney W. Grimes 			splx(s);
169262f76486SMaxim Sobolev 		} else if (new_flags & IFF_UP &&
1693cf4b9371SPoul-Henning Kamp 		    (ifp->if_flags & IFF_UP) == 0) {
1694df8bae1dSRodney W. Grimes 			int s = splimp();
1695df8bae1dSRodney W. Grimes 			if_up(ifp);
1696df8bae1dSRodney W. Grimes 			splx(s);
1697df8bae1dSRodney W. Grimes 		}
16987aebc5e8SYaroslav Tykhiy 		/* See if permanently promiscuous mode bit is about to flip */
16997aebc5e8SYaroslav Tykhiy 		if ((ifp->if_flags ^ new_flags) & IFF_PPROMISC) {
17007aebc5e8SYaroslav Tykhiy 			if (new_flags & IFF_PPROMISC)
17017aebc5e8SYaroslav Tykhiy 				ifp->if_flags |= IFF_PROMISC;
17027aebc5e8SYaroslav Tykhiy 			else if (ifp->if_pcount == 0)
17037aebc5e8SYaroslav Tykhiy 				ifp->if_flags &= ~IFF_PROMISC;
17047aebc5e8SYaroslav Tykhiy 			log(LOG_INFO, "%s: permanently promiscuous mode %s\n",
17057aebc5e8SYaroslav Tykhiy 			    ifp->if_xname,
17067aebc5e8SYaroslav Tykhiy 			    (new_flags & IFF_PPROMISC) ? "enabled" : "disabled");
17077aebc5e8SYaroslav Tykhiy 		}
1708df8bae1dSRodney W. Grimes 		ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
170962f76486SMaxim Sobolev 			(new_flags &~ IFF_CANTCHANGE);
171031302ebfSRobert Watson 		if (ifp->if_ioctl) {
171131302ebfSRobert Watson 			IFF_LOCKGIANT(ifp);
1712df8bae1dSRodney W. Grimes 			(void) (*ifp->if_ioctl)(ifp, cmd, data);
171331302ebfSRobert Watson 			IFF_UNLOCKGIANT(ifp);
171431302ebfSRobert Watson 		}
171598b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
1716df8bae1dSRodney W. Grimes 		break;
1717df8bae1dSRodney W. Grimes 
1718016da741SJonathan Lemon 	case SIOCSIFCAP:
1719acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFCAP);
1720016da741SJonathan Lemon 		if (error)
1721016da741SJonathan Lemon 			return (error);
1722efb4018bSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
1723efb4018bSYaroslav Tykhiy 			return (EOPNOTSUPP);
1724016da741SJonathan Lemon 		if (ifr->ifr_reqcap & ~ifp->if_capabilities)
1725016da741SJonathan Lemon 			return (EINVAL);
172631302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
1727efb4018bSYaroslav Tykhiy 		error = (*ifp->if_ioctl)(ifp, cmd, data);
172831302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
1729efb4018bSYaroslav Tykhiy 		if (error == 0)
1730efb4018bSYaroslav Tykhiy 			getmicrotime(&ifp->if_lastchange);
1731016da741SJonathan Lemon 		break;
1732016da741SJonathan Lemon 
17338f293a63SRobert Watson #ifdef MAC
17348f293a63SRobert Watson 	case SIOCSIFMAC:
173530d239bcSRobert Watson 		error = mac_ifnet_ioctl_set(td->td_ucred, ifr, ifp);
17368f293a63SRobert Watson 		break;
17378f293a63SRobert Watson #endif
17388f293a63SRobert Watson 
173936c19a57SBrooks Davis 	case SIOCSIFNAME:
1740acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFNAME);
1741acd3428bSRobert Watson 		if (error)
174236c19a57SBrooks Davis 			return (error);
174336c19a57SBrooks Davis 		error = copyinstr(ifr->ifr_data, new_name, IFNAMSIZ, NULL);
1744bc1470f1SBrooks Davis 		if (error != 0)
174536c19a57SBrooks Davis 			return (error);
1746bc1470f1SBrooks Davis 		if (new_name[0] == '\0')
1747bc1470f1SBrooks Davis 			return (EINVAL);
174836c19a57SBrooks Davis 		if (ifunit(new_name) != NULL)
174936c19a57SBrooks Davis 			return (EEXIST);
175036c19a57SBrooks Davis 
175136c19a57SBrooks Davis 		/* Announce the departure of the interface. */
175236c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
175352023244SMax Laier 		EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
175436c19a57SBrooks Davis 
175571672bb6SBrooks Davis 		log(LOG_INFO, "%s: changing name to '%s'\n",
175671672bb6SBrooks Davis 		    ifp->if_xname, new_name);
175771672bb6SBrooks Davis 
175836c19a57SBrooks Davis 		strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname));
17594a0d6638SRuslan Ermilov 		ifa = ifp->if_addr;
176036c19a57SBrooks Davis 		IFA_LOCK(ifa);
176136c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_addr;
176236c19a57SBrooks Davis 		namelen = strlen(new_name);
176336c19a57SBrooks Davis 		onamelen = sdl->sdl_nlen;
176436c19a57SBrooks Davis 		/*
176536c19a57SBrooks Davis 		 * Move the address if needed.  This is safe because we
176636c19a57SBrooks Davis 		 * allocate space for a name of length IFNAMSIZ when we
176736c19a57SBrooks Davis 		 * create this in if_attach().
176836c19a57SBrooks Davis 		 */
176936c19a57SBrooks Davis 		if (namelen != onamelen) {
177036c19a57SBrooks Davis 			bcopy(sdl->sdl_data + onamelen,
177136c19a57SBrooks Davis 			    sdl->sdl_data + namelen, sdl->sdl_alen);
177236c19a57SBrooks Davis 		}
177336c19a57SBrooks Davis 		bcopy(new_name, sdl->sdl_data, namelen);
177436c19a57SBrooks Davis 		sdl->sdl_nlen = namelen;
177536c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_netmask;
177636c19a57SBrooks Davis 		bzero(sdl->sdl_data, onamelen);
177736c19a57SBrooks Davis 		while (namelen != 0)
177836c19a57SBrooks Davis 			sdl->sdl_data[--namelen] = 0xff;
177936c19a57SBrooks Davis 		IFA_UNLOCK(ifa);
178036c19a57SBrooks Davis 
178125a4adceSMax Laier 		EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
178236c19a57SBrooks Davis 		/* Announce the return of the interface. */
178336c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
178436c19a57SBrooks Davis 		break;
178536c19a57SBrooks Davis 
1786df8bae1dSRodney W. Grimes 	case SIOCSIFMETRIC:
1787acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMETRIC);
17889448326fSPoul-Henning Kamp 		if (error)
1789df8bae1dSRodney W. Grimes 			return (error);
1790df8bae1dSRodney W. Grimes 		ifp->if_metric = ifr->ifr_metric;
179198b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
1792df8bae1dSRodney W. Grimes 		break;
1793df8bae1dSRodney W. Grimes 
1794074c4a4eSGarrett Wollman 	case SIOCSIFPHYS:
1795acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFPHYS);
1796e39a0280SGary Palmer 		if (error)
1797913e410eSYaroslav Tykhiy 			return (error);
1798913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
1799913e410eSYaroslav Tykhiy 			return (EOPNOTSUPP);
180031302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
1801e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
180231302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
1803e39a0280SGary Palmer 		if (error == 0)
180498b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
1805913e410eSYaroslav Tykhiy 		break;
1806074c4a4eSGarrett Wollman 
1807a7028af7SDavid Greenman 	case SIOCSIFMTU:
180882cd038dSYoshinobu Inoue 	{
180982cd038dSYoshinobu Inoue 		u_long oldmtu = ifp->if_mtu;
181082cd038dSYoshinobu Inoue 
1811acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMTU);
18129448326fSPoul-Henning Kamp 		if (error)
1813a7028af7SDavid Greenman 			return (error);
1814aab3beeeSBrian Somers 		if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU)
181575ee03cbSDavid Greenman 			return (EINVAL);
1816f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
1817f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
181831302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
1819e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
182031302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
182148f71763SRuslan Ermilov 		if (error == 0) {
182298b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
182348f71763SRuslan Ermilov 			rt_ifmsg(ifp);
182448f71763SRuslan Ermilov 		}
182582cd038dSYoshinobu Inoue 		/*
182682cd038dSYoshinobu Inoue 		 * If the link MTU changed, do network layer specific procedure.
182782cd038dSYoshinobu Inoue 		 */
182882cd038dSYoshinobu Inoue 		if (ifp->if_mtu != oldmtu) {
182982cd038dSYoshinobu Inoue #ifdef INET6
183082cd038dSYoshinobu Inoue 			nd6_setmtu(ifp);
183182cd038dSYoshinobu Inoue #endif
183282cd038dSYoshinobu Inoue 		}
1833f13ad206SJonathan Lemon 		break;
183482cd038dSYoshinobu Inoue 	}
1835a7028af7SDavid Greenman 
1836df8bae1dSRodney W. Grimes 	case SIOCADDMULTI:
1837df8bae1dSRodney W. Grimes 	case SIOCDELMULTI:
1838acd3428bSRobert Watson 		if (cmd == SIOCADDMULTI)
1839acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_ADDMULTI);
1840acd3428bSRobert Watson 		else
1841acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_DELMULTI);
18429448326fSPoul-Henning Kamp 		if (error)
1843df8bae1dSRodney W. Grimes 			return (error);
1844477180fbSGarrett Wollman 
1845477180fbSGarrett Wollman 		/* Don't allow group membership on non-multicast interfaces. */
1846477180fbSGarrett Wollman 		if ((ifp->if_flags & IFF_MULTICAST) == 0)
1847f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
1848477180fbSGarrett Wollman 
1849477180fbSGarrett Wollman 		/* Don't let users screw up protocols' entries. */
1850477180fbSGarrett Wollman 		if (ifr->ifr_addr.sa_family != AF_LINK)
1851f13ad206SJonathan Lemon 			return (EINVAL);
1852477180fbSGarrett Wollman 
1853477180fbSGarrett Wollman 		if (cmd == SIOCADDMULTI) {
1854477180fbSGarrett Wollman 			struct ifmultiaddr *ifma;
1855ec002feeSBruce M Simpson 
1856ec002feeSBruce M Simpson 			/*
1857ec002feeSBruce M Simpson 			 * Userland is only permitted to join groups once
1858ec002feeSBruce M Simpson 			 * via the if_addmulti() KPI, because it cannot hold
1859ec002feeSBruce M Simpson 			 * struct ifmultiaddr * between calls. It may also
1860ec002feeSBruce M Simpson 			 * lose a race while we check if the membership
1861ec002feeSBruce M Simpson 			 * already exists.
1862ec002feeSBruce M Simpson 			 */
1863ec002feeSBruce M Simpson 			IF_ADDR_LOCK(ifp);
1864ec002feeSBruce M Simpson 			ifma = if_findmulti(ifp, &ifr->ifr_addr);
1865ec002feeSBruce M Simpson 			IF_ADDR_UNLOCK(ifp);
1866ec002feeSBruce M Simpson 			if (ifma != NULL)
1867ec002feeSBruce M Simpson 				error = EADDRINUSE;
1868ec002feeSBruce M Simpson 			else
1869477180fbSGarrett Wollman 				error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
1870477180fbSGarrett Wollman 		} else {
1871477180fbSGarrett Wollman 			error = if_delmulti(ifp, &ifr->ifr_addr);
1872477180fbSGarrett Wollman 		}
1873e39a0280SGary Palmer 		if (error == 0)
187498b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
1875f13ad206SJonathan Lemon 		break;
1876df8bae1dSRodney W. Grimes 
187741b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR:
187841b3e8e5SJun-ichiro itojun Hagino 	case SIOCDIFPHYADDR:
187941b3e8e5SJun-ichiro itojun Hagino #ifdef INET6
188041b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR_IN6:
188141b3e8e5SJun-ichiro itojun Hagino #endif
188233841545SHajimu UMEMOTO 	case SIOCSLIFPHYADDR:
1883a912e453SPeter Wemm 	case SIOCSIFMEDIA:
1884d7189ec6SJoerg Wunsch 	case SIOCSIFGENERIC:
1885acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_HWIOCTL);
1886a912e453SPeter Wemm 		if (error)
1887a912e453SPeter Wemm 			return (error);
1888f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
1889a912e453SPeter Wemm 			return (EOPNOTSUPP);
189031302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
1891a912e453SPeter Wemm 		error = (*ifp->if_ioctl)(ifp, cmd, data);
189231302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
1893a912e453SPeter Wemm 		if (error == 0)
189498b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
1895f13ad206SJonathan Lemon 		break;
1896a912e453SPeter Wemm 
1897413dd0baSPoul-Henning Kamp 	case SIOCGIFSTATUS:
1898413dd0baSPoul-Henning Kamp 		ifs = (struct ifstat *)data;
1899413dd0baSPoul-Henning Kamp 		ifs->ascii[0] = '\0';
1900413dd0baSPoul-Henning Kamp 
190133841545SHajimu UMEMOTO 	case SIOCGIFPSRCADDR:
190233841545SHajimu UMEMOTO 	case SIOCGIFPDSTADDR:
190333841545SHajimu UMEMOTO 	case SIOCGLIFPHYADDR:
1904a912e453SPeter Wemm 	case SIOCGIFMEDIA:
1905d7189ec6SJoerg Wunsch 	case SIOCGIFGENERIC:
1906913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
1907a912e453SPeter Wemm 			return (EOPNOTSUPP);
190831302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
1909f13ad206SJonathan Lemon 		error = (*ifp->if_ioctl)(ifp, cmd, data);
191031302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
1911f13ad206SJonathan Lemon 		break;
1912a912e453SPeter Wemm 
1913b106252cSBill Paul 	case SIOCSIFLLADDR:
1914acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETLLADDR);
1915b106252cSBill Paul 		if (error)
1916b106252cSBill Paul 			return (error);
1917f13ad206SJonathan Lemon 		error = if_setlladdr(ifp,
191866ce51ceSArchie Cobbs 		    ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len);
1919f13ad206SJonathan Lemon 		break;
192066ce51ceSArchie Cobbs 
19210dad3f0eSMax Laier 	case SIOCAIFGROUP:
19220dad3f0eSMax Laier 	{
19230dad3f0eSMax Laier 		struct ifgroupreq *ifgr = (struct ifgroupreq *)ifr;
19240dad3f0eSMax Laier 
1925acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_ADDIFGROUP);
19260dad3f0eSMax Laier 		if (error)
19270dad3f0eSMax Laier 			return (error);
19280dad3f0eSMax Laier 		if ((error = if_addgroup(ifp, ifgr->ifgr_group)))
19290dad3f0eSMax Laier 			return (error);
19300dad3f0eSMax Laier 		break;
19310dad3f0eSMax Laier 	}
19320dad3f0eSMax Laier 
19330dad3f0eSMax Laier 	case SIOCGIFGROUP:
19340dad3f0eSMax Laier 		if ((error = if_getgroup((struct ifgroupreq *)ifr, ifp)))
19350dad3f0eSMax Laier 			return (error);
19360dad3f0eSMax Laier 		break;
19370dad3f0eSMax Laier 
19380dad3f0eSMax Laier 	case SIOCDIFGROUP:
19390dad3f0eSMax Laier 	{
19400dad3f0eSMax Laier 		struct ifgroupreq *ifgr = (struct ifgroupreq *)ifr;
19410dad3f0eSMax Laier 
1942acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_DELIFGROUP);
19430dad3f0eSMax Laier 		if (error)
19440dad3f0eSMax Laier 			return (error);
19450dad3f0eSMax Laier 		if ((error = if_delgroup(ifp, ifgr->ifgr_group)))
19460dad3f0eSMax Laier 			return (error);
19470dad3f0eSMax Laier 		break;
19480dad3f0eSMax Laier 	}
19490dad3f0eSMax Laier 
1950df8bae1dSRodney W. Grimes 	default:
1951f13ad206SJonathan Lemon 		error = ENOIOCTL;
1952f13ad206SJonathan Lemon 		break;
1953f13ad206SJonathan Lemon 	}
1954f13ad206SJonathan Lemon 	return (error);
1955f13ad206SJonathan Lemon }
1956f13ad206SJonathan Lemon 
1957f13ad206SJonathan Lemon /*
1958f13ad206SJonathan Lemon  * Interface ioctls.
1959f13ad206SJonathan Lemon  */
1960f13ad206SJonathan Lemon int
196172fd1b6aSDag-Erling Smørgrav ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td)
1962f13ad206SJonathan Lemon {
1963f13ad206SJonathan Lemon 	struct ifnet *ifp;
1964f13ad206SJonathan Lemon 	struct ifreq *ifr;
1965f13ad206SJonathan Lemon 	int error;
196662f76486SMaxim Sobolev 	int oif_flags;
1967f13ad206SJonathan Lemon 
1968f13ad206SJonathan Lemon 	switch (cmd) {
1969f13ad206SJonathan Lemon 	case SIOCGIFCONF:
1970f13ad206SJonathan Lemon 	case OSIOCGIFCONF:
197119cf0498SPaul Saab #ifdef __amd64__
197219cf0498SPaul Saab 	case SIOCGIFCONF32:
197319cf0498SPaul Saab #endif
1974f13ad206SJonathan Lemon 		return (ifconf(cmd, data));
1975f13ad206SJonathan Lemon 	}
1976f13ad206SJonathan Lemon 	ifr = (struct ifreq *)data;
1977f13ad206SJonathan Lemon 
1978f13ad206SJonathan Lemon 	switch (cmd) {
1979f13ad206SJonathan Lemon 	case SIOCIFCREATE:
19806b7330e2SSam Leffler 	case SIOCIFCREATE2:
1981acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFCREATE);
1982acd3428bSRobert Watson 		if (error)
19836b7330e2SSam Leffler 			return (error);
19846b7330e2SSam Leffler 		return (if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name),
19856b7330e2SSam Leffler 			cmd == SIOCIFCREATE2 ? ifr->ifr_data : NULL));
1986f13ad206SJonathan Lemon 	case SIOCIFDESTROY:
1987acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFDESTROY);
1988acd3428bSRobert Watson 		if (error)
1989f13ad206SJonathan Lemon 			return (error);
19906b7330e2SSam Leffler 		return if_clone_destroy(ifr->ifr_name);
1991f13ad206SJonathan Lemon 
1992f13ad206SJonathan Lemon 	case SIOCIFGCLONERS:
1993f13ad206SJonathan Lemon 		return (if_clone_list((struct if_clonereq *)data));
19940dad3f0eSMax Laier 	case SIOCGIFGMEMB:
19950dad3f0eSMax Laier 		return (if_getgroupmembers((struct ifgroupreq *)data));
1996f13ad206SJonathan Lemon 	}
1997f13ad206SJonathan Lemon 
1998f13ad206SJonathan Lemon 	ifp = ifunit(ifr->ifr_name);
1999f13ad206SJonathan Lemon 	if (ifp == 0)
2000f13ad206SJonathan Lemon 		return (ENXIO);
2001f13ad206SJonathan Lemon 
2002f13ad206SJonathan Lemon 	error = ifhwioctl(cmd, ifp, data, td);
2003f13ad206SJonathan Lemon 	if (error != ENOIOCTL)
2004f13ad206SJonathan Lemon 		return (error);
2005f13ad206SJonathan Lemon 
200682cd038dSYoshinobu Inoue 	oif_flags = ifp->if_flags;
2007df8bae1dSRodney W. Grimes 	if (so->so_proto == 0)
2008df8bae1dSRodney W. Grimes 		return (EOPNOTSUPP);
2009df8bae1dSRodney W. Grimes #ifndef COMPAT_43
201082cd038dSYoshinobu Inoue 	error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd,
20112c37256eSGarrett Wollman 								 data,
2012b40ce416SJulian Elischer 								 ifp, td));
2013df8bae1dSRodney W. Grimes #else
2014df8bae1dSRodney W. Grimes 	{
2015df8bae1dSRodney W. Grimes 		int ocmd = cmd;
2016df8bae1dSRodney W. Grimes 
2017df8bae1dSRodney W. Grimes 		switch (cmd) {
2018df8bae1dSRodney W. Grimes 
2019df8bae1dSRodney W. Grimes 		case SIOCSIFDSTADDR:
2020df8bae1dSRodney W. Grimes 		case SIOCSIFADDR:
2021df8bae1dSRodney W. Grimes 		case SIOCSIFBRDADDR:
2022df8bae1dSRodney W. Grimes 		case SIOCSIFNETMASK:
2023df8bae1dSRodney W. Grimes #if BYTE_ORDER != BIG_ENDIAN
2024df8bae1dSRodney W. Grimes 			if (ifr->ifr_addr.sa_family == 0 &&
2025df8bae1dSRodney W. Grimes 			    ifr->ifr_addr.sa_len < 16) {
2026df8bae1dSRodney W. Grimes 				ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len;
2027df8bae1dSRodney W. Grimes 				ifr->ifr_addr.sa_len = 16;
2028df8bae1dSRodney W. Grimes 			}
2029df8bae1dSRodney W. Grimes #else
2030df8bae1dSRodney W. Grimes 			if (ifr->ifr_addr.sa_len == 0)
2031df8bae1dSRodney W. Grimes 				ifr->ifr_addr.sa_len = 16;
2032df8bae1dSRodney W. Grimes #endif
2033df8bae1dSRodney W. Grimes 			break;
2034df8bae1dSRodney W. Grimes 
2035df8bae1dSRodney W. Grimes 		case OSIOCGIFADDR:
2036df8bae1dSRodney W. Grimes 			cmd = SIOCGIFADDR;
2037df8bae1dSRodney W. Grimes 			break;
2038df8bae1dSRodney W. Grimes 
2039df8bae1dSRodney W. Grimes 		case OSIOCGIFDSTADDR:
2040df8bae1dSRodney W. Grimes 			cmd = SIOCGIFDSTADDR;
2041df8bae1dSRodney W. Grimes 			break;
2042df8bae1dSRodney W. Grimes 
2043df8bae1dSRodney W. Grimes 		case OSIOCGIFBRDADDR:
2044df8bae1dSRodney W. Grimes 			cmd = SIOCGIFBRDADDR;
2045df8bae1dSRodney W. Grimes 			break;
2046df8bae1dSRodney W. Grimes 
2047df8bae1dSRodney W. Grimes 		case OSIOCGIFNETMASK:
2048df8bae1dSRodney W. Grimes 			cmd = SIOCGIFNETMASK;
2049df8bae1dSRodney W. Grimes 		}
20502c37256eSGarrett Wollman 		error =  ((*so->so_proto->pr_usrreqs->pru_control)(so,
20512c37256eSGarrett Wollman 								   cmd,
20522c37256eSGarrett Wollman 								   data,
2053b40ce416SJulian Elischer 								   ifp, td));
2054df8bae1dSRodney W. Grimes 		switch (ocmd) {
2055df8bae1dSRodney W. Grimes 
2056df8bae1dSRodney W. Grimes 		case OSIOCGIFADDR:
2057df8bae1dSRodney W. Grimes 		case OSIOCGIFDSTADDR:
2058df8bae1dSRodney W. Grimes 		case OSIOCGIFBRDADDR:
2059df8bae1dSRodney W. Grimes 		case OSIOCGIFNETMASK:
2060df8bae1dSRodney W. Grimes 			*(u_short *)&ifr->ifr_addr = ifr->ifr_addr.sa_family;
206182cd038dSYoshinobu Inoue 
206282cd038dSYoshinobu Inoue 		}
206382cd038dSYoshinobu Inoue 	}
206482cd038dSYoshinobu Inoue #endif /* COMPAT_43 */
206582cd038dSYoshinobu Inoue 
206682cd038dSYoshinobu Inoue 	if ((oif_flags ^ ifp->if_flags) & IFF_UP) {
206782cd038dSYoshinobu Inoue #ifdef INET6
206888ff5695SSUZUKI Shinsuke 		DELAY(100);/* XXX: temporary workaround for fxp issue*/
206982cd038dSYoshinobu Inoue 		if (ifp->if_flags & IFF_UP) {
207082cd038dSYoshinobu Inoue 			int s = splimp();
207182cd038dSYoshinobu Inoue 			in6_if_up(ifp);
207282cd038dSYoshinobu Inoue 			splx(s);
207382cd038dSYoshinobu Inoue 		}
207482cd038dSYoshinobu Inoue #endif
2075df8bae1dSRodney W. Grimes 	}
2076df8bae1dSRodney W. Grimes 	return (error);
2077df8bae1dSRodney W. Grimes }
2078df8bae1dSRodney W. Grimes 
2079df8bae1dSRodney W. Grimes /*
2080292ee7beSRobert Watson  * The code common to handling reference counted flags,
20811a3b6859SYaroslav Tykhiy  * e.g., in ifpromisc() and if_allmulti().
2082b5c8bd59SYaroslav Tykhiy  * The "pflag" argument can specify a permanent mode flag to check,
20831a3b6859SYaroslav Tykhiy  * such as IFF_PPROMISC for promiscuous mode; should be 0 if none.
2084292ee7beSRobert Watson  *
2085292ee7beSRobert Watson  * Only to be used on stack-owned flags, not driver-owned flags.
20861a3b6859SYaroslav Tykhiy  */
20871a3b6859SYaroslav Tykhiy static int
20881a3b6859SYaroslav Tykhiy if_setflag(struct ifnet *ifp, int flag, int pflag, int *refcount, int onswitch)
20891a3b6859SYaroslav Tykhiy {
20901a3b6859SYaroslav Tykhiy 	struct ifreq ifr;
20911a3b6859SYaroslav Tykhiy 	int error;
20921a3b6859SYaroslav Tykhiy 	int oldflags, oldcount;
20931a3b6859SYaroslav Tykhiy 
20941a3b6859SYaroslav Tykhiy 	/* Sanity checks to catch programming errors */
2095b5c8bd59SYaroslav Tykhiy 	KASSERT((flag & (IFF_DRV_OACTIVE|IFF_DRV_RUNNING)) == 0,
2096b5c8bd59SYaroslav Tykhiy 	    ("%s: setting driver-owned flag %d", __func__, flag));
2097b5c8bd59SYaroslav Tykhiy 
2098b5c8bd59SYaroslav Tykhiy 	if (onswitch)
2099b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount >= 0,
2100b5c8bd59SYaroslav Tykhiy 		    ("%s: increment negative refcount %d for flag %d",
2101b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
2102b5c8bd59SYaroslav Tykhiy 	else
2103b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount > 0,
2104b5c8bd59SYaroslav Tykhiy 		    ("%s: decrement non-positive refcount %d for flag %d",
2105b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
21061a3b6859SYaroslav Tykhiy 
21071a3b6859SYaroslav Tykhiy 	/* In case this mode is permanent, just touch refcount */
21081a3b6859SYaroslav Tykhiy 	if (ifp->if_flags & pflag) {
21091a3b6859SYaroslav Tykhiy 		*refcount += onswitch ? 1 : -1;
21101a3b6859SYaroslav Tykhiy 		return (0);
21111a3b6859SYaroslav Tykhiy 	}
21121a3b6859SYaroslav Tykhiy 
21131a3b6859SYaroslav Tykhiy 	/* Save ifnet parameters for if_ioctl() may fail */
21141a3b6859SYaroslav Tykhiy 	oldcount = *refcount;
21151a3b6859SYaroslav Tykhiy 	oldflags = ifp->if_flags;
21161a3b6859SYaroslav Tykhiy 
21171a3b6859SYaroslav Tykhiy 	/*
21181a3b6859SYaroslav Tykhiy 	 * See if we aren't the only and touching refcount is enough.
21191a3b6859SYaroslav Tykhiy 	 * Actually toggle interface flag if we are the first or last.
21201a3b6859SYaroslav Tykhiy 	 */
21211a3b6859SYaroslav Tykhiy 	if (onswitch) {
21221a3b6859SYaroslav Tykhiy 		if ((*refcount)++)
21231a3b6859SYaroslav Tykhiy 			return (0);
21241a3b6859SYaroslav Tykhiy 		ifp->if_flags |= flag;
21251a3b6859SYaroslav Tykhiy 	} else {
21261a3b6859SYaroslav Tykhiy 		if (--(*refcount))
21271a3b6859SYaroslav Tykhiy 			return (0);
21281a3b6859SYaroslav Tykhiy 		ifp->if_flags &= ~flag;
21291a3b6859SYaroslav Tykhiy 	}
21301a3b6859SYaroslav Tykhiy 
21311a3b6859SYaroslav Tykhiy 	/* Call down the driver since we've changed interface flags */
21321a3b6859SYaroslav Tykhiy 	if (ifp->if_ioctl == NULL) {
21331a3b6859SYaroslav Tykhiy 		error = EOPNOTSUPP;
21341a3b6859SYaroslav Tykhiy 		goto recover;
21351a3b6859SYaroslav Tykhiy 	}
21361a3b6859SYaroslav Tykhiy 	ifr.ifr_flags = ifp->if_flags & 0xffff;
21371a3b6859SYaroslav Tykhiy 	ifr.ifr_flagshigh = ifp->if_flags >> 16;
21381a3b6859SYaroslav Tykhiy 	IFF_LOCKGIANT(ifp);
21391a3b6859SYaroslav Tykhiy 	error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
21401a3b6859SYaroslav Tykhiy 	IFF_UNLOCKGIANT(ifp);
21411a3b6859SYaroslav Tykhiy 	if (error)
21421a3b6859SYaroslav Tykhiy 		goto recover;
21431a3b6859SYaroslav Tykhiy 	/* Notify userland that interface flags have changed */
21441a3b6859SYaroslav Tykhiy 	rt_ifmsg(ifp);
21451a3b6859SYaroslav Tykhiy 	return (0);
21461a3b6859SYaroslav Tykhiy 
21471a3b6859SYaroslav Tykhiy recover:
21481a3b6859SYaroslav Tykhiy 	/* Recover after driver error */
21491a3b6859SYaroslav Tykhiy 	*refcount = oldcount;
21501a3b6859SYaroslav Tykhiy 	ifp->if_flags = oldflags;
21511a3b6859SYaroslav Tykhiy 	return (error);
21521a3b6859SYaroslav Tykhiy }
21531a3b6859SYaroslav Tykhiy 
21541a3b6859SYaroslav Tykhiy /*
2155963e4c2aSGarrett Wollman  * Set/clear promiscuous mode on interface ifp based on the truth value
2156963e4c2aSGarrett Wollman  * of pswitch.  The calls are reference counted so that only the first
2157963e4c2aSGarrett Wollman  * "on" request actually has an effect, as does the final "off" request.
2158963e4c2aSGarrett Wollman  * Results are undefined if the "off" and "on" requests are not matched.
2159963e4c2aSGarrett Wollman  */
2160963e4c2aSGarrett Wollman int
216172fd1b6aSDag-Erling Smørgrav ifpromisc(struct ifnet *ifp, int pswitch)
2162963e4c2aSGarrett Wollman {
21634a26224cSGarrett Wollman 	int error;
21641a3b6859SYaroslav Tykhiy 	int oldflags = ifp->if_flags;
2165963e4c2aSGarrett Wollman 
21661a3b6859SYaroslav Tykhiy 	error = if_setflag(ifp, IFF_PROMISC, IFF_PPROMISC,
21671a3b6859SYaroslav Tykhiy 			   &ifp->if_pcount, pswitch);
21681a3b6859SYaroslav Tykhiy 	/* If promiscuous mode status has changed, log a message */
21691a3b6859SYaroslav Tykhiy 	if (error == 0 && ((ifp->if_flags ^ oldflags) & IFF_PROMISC))
21709bf40edeSBrooks Davis 		log(LOG_INFO, "%s: promiscuous mode %s\n",
21719bf40edeSBrooks Davis 		    ifp->if_xname,
21724f3c11a6SBill Fenner 		    (ifp->if_flags & IFF_PROMISC) ? "enabled" : "disabled");
21731a3b6859SYaroslav Tykhiy 	return (error);
2174963e4c2aSGarrett Wollman }
2175963e4c2aSGarrett Wollman 
2176963e4c2aSGarrett Wollman /*
2177df8bae1dSRodney W. Grimes  * Return interface configuration
2178df8bae1dSRodney W. Grimes  * of system.  List may be used
2179df8bae1dSRodney W. Grimes  * in later ioctl's (above) to get
2180df8bae1dSRodney W. Grimes  * other information.
2181df8bae1dSRodney W. Grimes  */
2182df8bae1dSRodney W. Grimes /*ARGSUSED*/
21833bda9f9bSPoul-Henning Kamp static int
218472fd1b6aSDag-Erling Smørgrav ifconf(u_long cmd, caddr_t data)
2185df8bae1dSRodney W. Grimes {
21868b615593SMarko Zec 	INIT_VNET_NET(curvnet);
21870b59d917SJonathan Lemon 	struct ifconf *ifc = (struct ifconf *)data;
218819cf0498SPaul Saab #ifdef __amd64__
218919cf0498SPaul Saab 	struct ifconf32 *ifc32 = (struct ifconf32 *)data;
219019cf0498SPaul Saab 	struct ifconf ifc_swab;
219119cf0498SPaul Saab #endif
21920b59d917SJonathan Lemon 	struct ifnet *ifp;
21930b59d917SJonathan Lemon 	struct ifaddr *ifa;
21944dcf2bbbSBrooks Davis 	struct ifreq ifr;
21954dcf2bbbSBrooks Davis 	struct sbuf *sb;
21964dcf2bbbSBrooks Davis 	int error, full = 0, valid_len, max_len;
2197df8bae1dSRodney W. Grimes 
219819cf0498SPaul Saab #ifdef __amd64__
219919cf0498SPaul Saab 	if (cmd == SIOCGIFCONF32) {
220019cf0498SPaul Saab 		ifc_swab.ifc_len = ifc32->ifc_len;
220119cf0498SPaul Saab 		ifc_swab.ifc_buf = (caddr_t)(uintptr_t)ifc32->ifc_buf;
220219cf0498SPaul Saab 		ifc = &ifc_swab;
220319cf0498SPaul Saab 	}
220419cf0498SPaul Saab #endif
22054dcf2bbbSBrooks Davis 	/* Limit initial buffer size to MAXPHYS to avoid DoS from userspace. */
22064dcf2bbbSBrooks Davis 	max_len = MAXPHYS - 1;
22074dcf2bbbSBrooks Davis 
2208b0b4b28bSXin LI 	/* Prevent hostile input from being able to crash the system */
2209b0b4b28bSXin LI 	if (ifc->ifc_len <= 0)
2210b0b4b28bSXin LI 		return (EINVAL);
2211b0b4b28bSXin LI 
22124dcf2bbbSBrooks Davis again:
22134dcf2bbbSBrooks Davis 	if (ifc->ifc_len <= max_len) {
22144dcf2bbbSBrooks Davis 		max_len = ifc->ifc_len;
22154dcf2bbbSBrooks Davis 		full = 1;
22164dcf2bbbSBrooks Davis 	}
22174dcf2bbbSBrooks Davis 	sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
22184dcf2bbbSBrooks Davis 	max_len = 0;
22194dcf2bbbSBrooks Davis 	valid_len = 0;
22204dcf2bbbSBrooks Davis 
2221b30a244cSJeffrey Hsu 	IFNET_RLOCK();		/* could sleep XXX */
2222603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
22239bf40edeSBrooks Davis 		int addrs;
22242624cf89SGarrett Wollman 
2225fbd24c5eSColin Percival 		/*
2226fbd24c5eSColin Percival 		 * Zero the ifr_name buffer to make sure we don't
2227fbd24c5eSColin Percival 		 * disclose the contents of the stack.
2228fbd24c5eSColin Percival 		 */
2229fbd24c5eSColin Percival 		memset(ifr.ifr_name, 0, sizeof(ifr.ifr_name));
2230fbd24c5eSColin Percival 
22319bf40edeSBrooks Davis 		if (strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name))
223262313e4cSSam Leffler 		    >= sizeof(ifr.ifr_name)) {
223362313e4cSSam Leffler 			sbuf_delete(sb);
223462313e4cSSam Leffler 			IFNET_RUNLOCK();
22354dcf2bbbSBrooks Davis 			return (ENAMETOOLONG);
223662313e4cSSam Leffler 		}
22372624cf89SGarrett Wollman 
223875c13541SPoul-Henning Kamp 		addrs = 0;
22392defe5cdSJonathan Lemon 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
22402defe5cdSJonathan Lemon 			struct sockaddr *sa = ifa->ifa_addr;
22412defe5cdSJonathan Lemon 
2242a854ed98SJohn Baldwin 			if (jailed(curthread->td_ucred) &&
2243413628a7SBjoern A. Zeeb 			    !prison_if(curthread->td_ucred, sa))
224475c13541SPoul-Henning Kamp 				continue;
224575c13541SPoul-Henning Kamp 			addrs++;
2246df8bae1dSRodney W. Grimes #ifdef COMPAT_43
2247df8bae1dSRodney W. Grimes 			if (cmd == OSIOCGIFCONF) {
2248df8bae1dSRodney W. Grimes 				struct osockaddr *osa =
2249df8bae1dSRodney W. Grimes 					 (struct osockaddr *)&ifr.ifr_addr;
2250df8bae1dSRodney W. Grimes 				ifr.ifr_addr = *sa;
2251df8bae1dSRodney W. Grimes 				osa->sa_family = sa->sa_family;
22524dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr, sizeof(ifr));
22534dcf2bbbSBrooks Davis 				max_len += sizeof(ifr);
2254df8bae1dSRodney W. Grimes 			} else
2255df8bae1dSRodney W. Grimes #endif
2256df8bae1dSRodney W. Grimes 			if (sa->sa_len <= sizeof(*sa)) {
2257df8bae1dSRodney W. Grimes 				ifr.ifr_addr = *sa;
22584dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr, sizeof(ifr));
22594dcf2bbbSBrooks Davis 				max_len += sizeof(ifr);
2260df8bae1dSRodney W. Grimes 			} else {
22614dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr,
22624dcf2bbbSBrooks Davis 				    offsetof(struct ifreq, ifr_addr));
22634dcf2bbbSBrooks Davis 				max_len += offsetof(struct ifreq, ifr_addr);
22644dcf2bbbSBrooks Davis 				sbuf_bcat(sb, sa, sa->sa_len);
22654dcf2bbbSBrooks Davis 				max_len += sa->sa_len;
2266df8bae1dSRodney W. Grimes 			}
22674dcf2bbbSBrooks Davis 
22684dcf2bbbSBrooks Davis 			if (!sbuf_overflowed(sb))
22694dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
2270df8bae1dSRodney W. Grimes 		}
22714dcf2bbbSBrooks Davis 		if (addrs == 0) {
227275c13541SPoul-Henning Kamp 			bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
22734dcf2bbbSBrooks Davis 			sbuf_bcat(sb, &ifr, sizeof(ifr));
22744dcf2bbbSBrooks Davis 			max_len += sizeof(ifr);
22754dcf2bbbSBrooks Davis 
22764dcf2bbbSBrooks Davis 			if (!sbuf_overflowed(sb))
22774dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
227875c13541SPoul-Henning Kamp 		}
2279df8bae1dSRodney W. Grimes 	}
2280b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
22814dcf2bbbSBrooks Davis 
22824dcf2bbbSBrooks Davis 	/*
22834dcf2bbbSBrooks Davis 	 * If we didn't allocate enough space (uncommon), try again.  If
22844dcf2bbbSBrooks Davis 	 * we have already allocated as much space as we are allowed,
22854dcf2bbbSBrooks Davis 	 * return what we've got.
22864dcf2bbbSBrooks Davis 	 */
22874dcf2bbbSBrooks Davis 	if (valid_len != max_len && !full) {
22884dcf2bbbSBrooks Davis 		sbuf_delete(sb);
22894dcf2bbbSBrooks Davis 		goto again;
22904dcf2bbbSBrooks Davis 	}
22914dcf2bbbSBrooks Davis 
22924dcf2bbbSBrooks Davis 	ifc->ifc_len = valid_len;
229319cf0498SPaul Saab #ifdef __amd64__
229419cf0498SPaul Saab 	if (cmd == SIOCGIFCONF32)
229519cf0498SPaul Saab 		ifc32->ifc_len = valid_len;
229619cf0498SPaul Saab #endif
22975ed8cedcSBrian Feldman 	sbuf_finish(sb);
22984dcf2bbbSBrooks Davis 	error = copyout(sbuf_data(sb), ifc->ifc_req, ifc->ifc_len);
22994dcf2bbbSBrooks Davis 	sbuf_delete(sb);
2300df8bae1dSRodney W. Grimes 	return (error);
2301df8bae1dSRodney W. Grimes }
2302df8bae1dSRodney W. Grimes 
23031158dfb7SGarrett Wollman /*
23048b25904eSGleb Smirnoff  * Just like ifpromisc(), but for all-multicast-reception mode.
23051158dfb7SGarrett Wollman  */
23061158dfb7SGarrett Wollman int
230772fd1b6aSDag-Erling Smørgrav if_allmulti(struct ifnet *ifp, int onswitch)
23081158dfb7SGarrett Wollman {
23091158dfb7SGarrett Wollman 
23101a3b6859SYaroslav Tykhiy 	return (if_setflag(ifp, IFF_ALLMULTI, 0, &ifp->if_amcount, onswitch));
23111158dfb7SGarrett Wollman }
23121158dfb7SGarrett Wollman 
23135896d124SBruce M Simpson struct ifmultiaddr *
2314c3b31afdSRobert Watson if_findmulti(struct ifnet *ifp, struct sockaddr *sa)
23151158dfb7SGarrett Wollman {
23161158dfb7SGarrett Wollman 	struct ifmultiaddr *ifma;
23171158dfb7SGarrett Wollman 
2318c3b31afdSRobert Watson 	IF_ADDR_LOCK_ASSERT(ifp);
2319c3b31afdSRobert Watson 
23206817526dSPoul-Henning Kamp 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
232140d8a302SBruce M Simpson 		if (sa->sa_family == AF_LINK) {
232240d8a302SBruce M Simpson 			if (sa_dl_equal(ifma->ifma_addr, sa))
232340d8a302SBruce M Simpson 				break;
232440d8a302SBruce M Simpson 		} else {
2325c3b31afdSRobert Watson 			if (sa_equal(ifma->ifma_addr, sa))
2326c3b31afdSRobert Watson 				break;
23271158dfb7SGarrett Wollman 		}
232840d8a302SBruce M Simpson 	}
2329c3b31afdSRobert Watson 
2330c3b31afdSRobert Watson 	return ifma;
233157af7922SJulian Elischer }
23321158dfb7SGarrett Wollman 
23331158dfb7SGarrett Wollman /*
2334c3b31afdSRobert Watson  * Allocate a new ifmultiaddr and initialize based on passed arguments.  We
2335c3b31afdSRobert Watson  * make copies of passed sockaddrs.  The ifmultiaddr will not be added to
2336c3b31afdSRobert Watson  * the ifnet multicast address list here, so the caller must do that and
2337c3b31afdSRobert Watson  * other setup work (such as notifying the device driver).  The reference
2338c3b31afdSRobert Watson  * count is initialized to 1.
23391158dfb7SGarrett Wollman  */
2340c3b31afdSRobert Watson static struct ifmultiaddr *
2341c3b31afdSRobert Watson if_allocmulti(struct ifnet *ifp, struct sockaddr *sa, struct sockaddr *llsa,
2342c3b31afdSRobert Watson     int mflags)
2343c3b31afdSRobert Watson {
2344c3b31afdSRobert Watson 	struct ifmultiaddr *ifma;
2345c3b31afdSRobert Watson 	struct sockaddr *dupsa;
2346c3b31afdSRobert Watson 
23471ede983cSDag-Erling Smørgrav 	ifma = malloc(sizeof *ifma, M_IFMADDR, mflags |
2348c3b31afdSRobert Watson 	    M_ZERO);
2349c3b31afdSRobert Watson 	if (ifma == NULL)
2350c3b31afdSRobert Watson 		return (NULL);
2351c3b31afdSRobert Watson 
23521ede983cSDag-Erling Smørgrav 	dupsa = malloc(sa->sa_len, M_IFMADDR, mflags);
2353c3b31afdSRobert Watson 	if (dupsa == NULL) {
23541ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
2355c3b31afdSRobert Watson 		return (NULL);
23561158dfb7SGarrett Wollman 	}
23571158dfb7SGarrett Wollman 	bcopy(sa, dupsa, sa->sa_len);
23581158dfb7SGarrett Wollman 	ifma->ifma_addr = dupsa;
2359c3b31afdSRobert Watson 
23601158dfb7SGarrett Wollman 	ifma->ifma_ifp = ifp;
23611158dfb7SGarrett Wollman 	ifma->ifma_refcount = 1;
2362d4d22970SGleb Smirnoff 	ifma->ifma_protospec = NULL;
2363c3b31afdSRobert Watson 
2364c3b31afdSRobert Watson 	if (llsa == NULL) {
2365c3b31afdSRobert Watson 		ifma->ifma_lladdr = NULL;
2366c3b31afdSRobert Watson 		return (ifma);
2367c3b31afdSRobert Watson 	}
2368c3b31afdSRobert Watson 
23691ede983cSDag-Erling Smørgrav 	dupsa = malloc(llsa->sa_len, M_IFMADDR, mflags);
2370c3b31afdSRobert Watson 	if (dupsa == NULL) {
23711ede983cSDag-Erling Smørgrav 		free(ifma->ifma_addr, M_IFMADDR);
23721ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
2373c3b31afdSRobert Watson 		return (NULL);
2374c3b31afdSRobert Watson 	}
2375c3b31afdSRobert Watson 	bcopy(llsa, dupsa, llsa->sa_len);
2376c3b31afdSRobert Watson 	ifma->ifma_lladdr = dupsa;
2377c3b31afdSRobert Watson 
2378c3b31afdSRobert Watson 	return (ifma);
2379c3b31afdSRobert Watson }
2380373f88edSGarrett Wollman 
23811158dfb7SGarrett Wollman /*
2382c3b31afdSRobert Watson  * if_freemulti: free ifmultiaddr structure and possibly attached related
2383c3b31afdSRobert Watson  * addresses.  The caller is responsible for implementing reference
2384c3b31afdSRobert Watson  * counting, notifying the driver, handling routing messages, and releasing
2385c3b31afdSRobert Watson  * any dependent link layer state.
23861158dfb7SGarrett Wollman  */
2387c3b31afdSRobert Watson static void
2388c3b31afdSRobert Watson if_freemulti(struct ifmultiaddr *ifma)
2389c3b31afdSRobert Watson {
2390c3b31afdSRobert Watson 
2391ec002feeSBruce M Simpson 	KASSERT(ifma->ifma_refcount == 0, ("if_freemulti: refcount %d",
2392c3b31afdSRobert Watson 	    ifma->ifma_refcount));
2393c3b31afdSRobert Watson 	KASSERT(ifma->ifma_protospec == NULL,
2394c3b31afdSRobert Watson 	    ("if_freemulti: protospec not NULL"));
2395c3b31afdSRobert Watson 
2396c3b31afdSRobert Watson 	if (ifma->ifma_lladdr != NULL)
23971ede983cSDag-Erling Smørgrav 		free(ifma->ifma_lladdr, M_IFMADDR);
23981ede983cSDag-Erling Smørgrav 	free(ifma->ifma_addr, M_IFMADDR);
23991ede983cSDag-Erling Smørgrav 	free(ifma, M_IFMADDR);
2400c3b31afdSRobert Watson }
2401c3b31afdSRobert Watson 
2402c3b31afdSRobert Watson /*
2403c3b31afdSRobert Watson  * Register an additional multicast address with a network interface.
2404c3b31afdSRobert Watson  *
2405c3b31afdSRobert Watson  * - If the address is already present, bump the reference count on the
2406c3b31afdSRobert Watson  *   address and return.
2407c3b31afdSRobert Watson  * - If the address is not link-layer, look up a link layer address.
2408c3b31afdSRobert Watson  * - Allocate address structures for one or both addresses, and attach to the
2409c3b31afdSRobert Watson  *   multicast address list on the interface.  If automatically adding a link
2410c3b31afdSRobert Watson  *   layer address, the protocol address will own a reference to the link
2411c3b31afdSRobert Watson  *   layer address, to be freed when it is freed.
2412c3b31afdSRobert Watson  * - Notify the network device driver of an addition to the multicast address
2413c3b31afdSRobert Watson  *   list.
2414c3b31afdSRobert Watson  *
2415c3b31afdSRobert Watson  * 'sa' points to caller-owned memory with the desired multicast address.
2416c3b31afdSRobert Watson  *
2417c3b31afdSRobert Watson  * 'retifma' will be used to return a pointer to the resulting multicast
2418c3b31afdSRobert Watson  * address reference, if desired.
2419c3b31afdSRobert Watson  */
2420c3b31afdSRobert Watson int
2421c3b31afdSRobert Watson if_addmulti(struct ifnet *ifp, struct sockaddr *sa,
2422c3b31afdSRobert Watson     struct ifmultiaddr **retifma)
2423c3b31afdSRobert Watson {
2424c3b31afdSRobert Watson 	struct ifmultiaddr *ifma, *ll_ifma;
2425c3b31afdSRobert Watson 	struct sockaddr *llsa;
2426c3b31afdSRobert Watson 	int error;
2427c3b31afdSRobert Watson 
2428c3b31afdSRobert Watson 	/*
2429c3b31afdSRobert Watson 	 * If the address is already present, return a new reference to it;
2430c3b31afdSRobert Watson 	 * otherwise, allocate storage and set up a new address.
2431c3b31afdSRobert Watson 	 */
2432c3b31afdSRobert Watson 	IF_ADDR_LOCK(ifp);
2433c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
2434c3b31afdSRobert Watson 	if (ifma != NULL) {
2435c3b31afdSRobert Watson 		ifma->ifma_refcount++;
2436c3b31afdSRobert Watson 		if (retifma != NULL)
2437c3b31afdSRobert Watson 			*retifma = ifma;
2438c3b31afdSRobert Watson 		IF_ADDR_UNLOCK(ifp);
2439c3b31afdSRobert Watson 		return (0);
2440c3b31afdSRobert Watson 	}
2441c3b31afdSRobert Watson 
2442c3b31afdSRobert Watson 	/*
2443c3b31afdSRobert Watson 	 * The address isn't already present; resolve the protocol address
2444c3b31afdSRobert Watson 	 * into a link layer address, and then look that up, bump its
2445c3b31afdSRobert Watson 	 * refcount or allocate an ifma for that also.  If 'llsa' was
2446c3b31afdSRobert Watson 	 * returned, we will need to free it later.
2447c3b31afdSRobert Watson 	 */
2448c3b31afdSRobert Watson 	llsa = NULL;
2449c3b31afdSRobert Watson 	ll_ifma = NULL;
2450c3b31afdSRobert Watson 	if (ifp->if_resolvemulti != NULL) {
2451c3b31afdSRobert Watson 		error = ifp->if_resolvemulti(ifp, &llsa, sa);
2452c3b31afdSRobert Watson 		if (error)
2453c3b31afdSRobert Watson 			goto unlock_out;
2454c3b31afdSRobert Watson 	}
2455c3b31afdSRobert Watson 
2456c3b31afdSRobert Watson 	/*
2457c3b31afdSRobert Watson 	 * Allocate the new address.  Don't hook it up yet, as we may also
2458c3b31afdSRobert Watson 	 * need to allocate a link layer multicast address.
2459c3b31afdSRobert Watson 	 */
2460c3b31afdSRobert Watson 	ifma = if_allocmulti(ifp, sa, llsa, M_NOWAIT);
2461c3b31afdSRobert Watson 	if (ifma == NULL) {
2462c3b31afdSRobert Watson 		error = ENOMEM;
2463c3b31afdSRobert Watson 		goto free_llsa_out;
2464c3b31afdSRobert Watson 	}
2465c3b31afdSRobert Watson 
2466c3b31afdSRobert Watson 	/*
2467c3b31afdSRobert Watson 	 * If a link layer address is found, we'll need to see if it's
2468c3b31afdSRobert Watson 	 * already present in the address list, or allocate is as well.
2469c3b31afdSRobert Watson 	 * When this block finishes, the link layer address will be on the
2470c3b31afdSRobert Watson 	 * list.
2471c3b31afdSRobert Watson 	 */
2472c3b31afdSRobert Watson 	if (llsa != NULL) {
2473c3b31afdSRobert Watson 		ll_ifma = if_findmulti(ifp, llsa);
2474c3b31afdSRobert Watson 		if (ll_ifma == NULL) {
2475c3b31afdSRobert Watson 			ll_ifma = if_allocmulti(ifp, llsa, NULL, M_NOWAIT);
2476c3b31afdSRobert Watson 			if (ll_ifma == NULL) {
2477ec002feeSBruce M Simpson 				--ifma->ifma_refcount;
2478c3b31afdSRobert Watson 				if_freemulti(ifma);
2479c3b31afdSRobert Watson 				error = ENOMEM;
2480c3b31afdSRobert Watson 				goto free_llsa_out;
2481c3b31afdSRobert Watson 			}
2482c3b31afdSRobert Watson 			TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ll_ifma,
2483c3b31afdSRobert Watson 			    ifma_link);
2484c3b31afdSRobert Watson 		} else
2485c3b31afdSRobert Watson 			ll_ifma->ifma_refcount++;
2486ec002feeSBruce M Simpson 		ifma->ifma_llifma = ll_ifma;
2487c3b31afdSRobert Watson 	}
2488c3b31afdSRobert Watson 
2489c3b31afdSRobert Watson 	/*
2490c3b31afdSRobert Watson 	 * We now have a new multicast address, ifma, and possibly a new or
2491c3b31afdSRobert Watson 	 * referenced link layer address.  Add the primary address to the
2492c3b31afdSRobert Watson 	 * ifnet address list.
2493c3b31afdSRobert Watson 	 */
24946817526dSPoul-Henning Kamp 	TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
2495c3b31afdSRobert Watson 
249613990766SJonathan Mini 	if (retifma != NULL)
2497373f88edSGarrett Wollman 		*retifma = ifma;
24981158dfb7SGarrett Wollman 
2499c3b31afdSRobert Watson 	/*
2500c3b31afdSRobert Watson 	 * Must generate the message while holding the lock so that 'ifma'
2501c3b31afdSRobert Watson 	 * pointer is still valid.
2502c3b31afdSRobert Watson 	 */
2503c3b31afdSRobert Watson 	rt_newmaddrmsg(RTM_NEWMADDR, ifma);
2504c3b31afdSRobert Watson 	IF_ADDR_UNLOCK(ifp);
2505c3b31afdSRobert Watson 
25061158dfb7SGarrett Wollman 	/*
25071158dfb7SGarrett Wollman 	 * We are certain we have added something, so call down to the
25081158dfb7SGarrett Wollman 	 * interface to let them know about it.
25091158dfb7SGarrett Wollman 	 */
25102432c31cSRobert Watson 	if (ifp->if_ioctl != NULL) {
251131302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
25121a3b6859SYaroslav Tykhiy 		(void) (*ifp->if_ioctl)(ifp, SIOCADDMULTI, 0);
251331302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
25141a3b6859SYaroslav Tykhiy 	}
25151158dfb7SGarrett Wollman 
2516c3b31afdSRobert Watson 	if (llsa != NULL)
25171ede983cSDag-Erling Smørgrav 		free(llsa, M_IFMADDR);
2518c3b31afdSRobert Watson 
2519c3b31afdSRobert Watson 	return (0);
2520c3b31afdSRobert Watson 
2521c3b31afdSRobert Watson free_llsa_out:
2522c3b31afdSRobert Watson 	if (llsa != NULL)
25231ede983cSDag-Erling Smørgrav 		free(llsa, M_IFMADDR);
2524c3b31afdSRobert Watson 
2525c3b31afdSRobert Watson unlock_out:
2526c3b31afdSRobert Watson 	IF_ADDR_UNLOCK(ifp);
2527c3b31afdSRobert Watson 	return (error);
25281158dfb7SGarrett Wollman }
25291158dfb7SGarrett Wollman 
25301158dfb7SGarrett Wollman /*
2531ec002feeSBruce M Simpson  * Delete a multicast group membership by network-layer group address.
2532ec002feeSBruce M Simpson  *
2533ec002feeSBruce M Simpson  * Returns ENOENT if the entry could not be found. If ifp no longer
2534ec002feeSBruce M Simpson  * exists, results are undefined. This entry point should only be used
2535ec002feeSBruce M Simpson  * from subsystems which do appropriate locking to hold ifp for the
2536ec002feeSBruce M Simpson  * duration of the call.
2537ec002feeSBruce M Simpson  * Network-layer protocol domains must use if_delmulti_ifma().
25381158dfb7SGarrett Wollman  */
25391158dfb7SGarrett Wollman int
254072fd1b6aSDag-Erling Smørgrav if_delmulti(struct ifnet *ifp, struct sockaddr *sa)
25411158dfb7SGarrett Wollman {
2542ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
2543ec002feeSBruce M Simpson 	int lastref;
2544ec002feeSBruce M Simpson #ifdef INVARIANTS
2545ec002feeSBruce M Simpson 	struct ifnet *oifp;
25468b615593SMarko Zec 	INIT_VNET_NET(ifp->if_vnet);
2547ec002feeSBruce M Simpson 
2548ec002feeSBruce M Simpson 	IFNET_RLOCK();
2549603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(oifp, &V_ifnet, if_link)
2550ec002feeSBruce M Simpson 		if (ifp == oifp)
2551ec002feeSBruce M Simpson 			break;
2552ec002feeSBruce M Simpson 	if (ifp != oifp)
2553ec002feeSBruce M Simpson 		ifp = NULL;
2554ec002feeSBruce M Simpson 	IFNET_RUNLOCK();
2555ec002feeSBruce M Simpson 
2556ec002feeSBruce M Simpson 	KASSERT(ifp != NULL, ("%s: ifnet went away", __func__));
2557ec002feeSBruce M Simpson #endif
2558ec002feeSBruce M Simpson 	if (ifp == NULL)
2559ec002feeSBruce M Simpson 		return (ENOENT);
25601158dfb7SGarrett Wollman 
2561c3b31afdSRobert Watson 	IF_ADDR_LOCK(ifp);
2562ec002feeSBruce M Simpson 	lastref = 0;
2563c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
2564ec002feeSBruce M Simpson 	if (ifma != NULL)
2565ec002feeSBruce M Simpson 		lastref = if_delmulti_locked(ifp, ifma, 0);
2566c3b31afdSRobert Watson 	IF_ADDR_UNLOCK(ifp);
2567c3b31afdSRobert Watson 
2568ec002feeSBruce M Simpson 	if (ifma == NULL)
2569ec002feeSBruce M Simpson 		return (ENOENT);
2570ec002feeSBruce M Simpson 
2571ec002feeSBruce M Simpson 	if (lastref && ifp->if_ioctl != NULL) {
257231302ebfSRobert Watson 		IFF_LOCKGIANT(ifp);
25731a3b6859SYaroslav Tykhiy 		(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
257431302ebfSRobert Watson 		IFF_UNLOCKGIANT(ifp);
257531302ebfSRobert Watson 	}
25761158dfb7SGarrett Wollman 
2577ec002feeSBruce M Simpson 	return (0);
2578ec002feeSBruce M Simpson }
2579ec002feeSBruce M Simpson 
2580ec002feeSBruce M Simpson /*
2581ec002feeSBruce M Simpson  * Delete a multicast group membership by group membership pointer.
2582ec002feeSBruce M Simpson  * Network-layer protocol domains must use this routine.
2583ec002feeSBruce M Simpson  *
2584ec002feeSBruce M Simpson  * It is safe to call this routine if the ifp disappeared. Callers should
2585ec002feeSBruce M Simpson  * hold IFF_LOCKGIANT() to avoid a LOR in case the hardware needs to be
2586ec002feeSBruce M Simpson  * reconfigured.
2587ec002feeSBruce M Simpson  */
2588ec002feeSBruce M Simpson void
2589ec002feeSBruce M Simpson if_delmulti_ifma(struct ifmultiaddr *ifma)
2590ec002feeSBruce M Simpson {
25918b615593SMarko Zec #ifdef DIAGNOSTIC
25928b615593SMarko Zec 	INIT_VNET_NET(curvnet);
25938b615593SMarko Zec #endif
2594ec002feeSBruce M Simpson 	struct ifnet *ifp;
2595ec002feeSBruce M Simpson 	int lastref;
2596ec002feeSBruce M Simpson 
2597ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
2598ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
2599ec002feeSBruce M Simpson 	if (ifp == NULL) {
2600ec002feeSBruce M Simpson 		printf("%s: ifma_ifp seems to be detached\n", __func__);
2601ec002feeSBruce M Simpson 	} else {
2602ec002feeSBruce M Simpson 		struct ifnet *oifp;
2603ec002feeSBruce M Simpson 
2604ec002feeSBruce M Simpson 		IFNET_RLOCK();
2605603724d3SBjoern A. Zeeb 		TAILQ_FOREACH(oifp, &V_ifnet, if_link)
2606ec002feeSBruce M Simpson 			if (ifp == oifp)
2607ec002feeSBruce M Simpson 				break;
2608ec002feeSBruce M Simpson 		if (ifp != oifp) {
2609ec002feeSBruce M Simpson 			printf("%s: ifnet %p disappeared\n", __func__, ifp);
2610ec002feeSBruce M Simpson 			ifp = NULL;
2611ec002feeSBruce M Simpson 		}
2612ec002feeSBruce M Simpson 		IFNET_RUNLOCK();
2613ec002feeSBruce M Simpson 	}
2614ec002feeSBruce M Simpson #endif
2615ec002feeSBruce M Simpson 	/*
2616ec002feeSBruce M Simpson 	 * If and only if the ifnet instance exists: Acquire the address lock.
2617ec002feeSBruce M Simpson 	 */
2618ec002feeSBruce M Simpson 	if (ifp != NULL)
2619ec002feeSBruce M Simpson 		IF_ADDR_LOCK(ifp);
2620ec002feeSBruce M Simpson 
2621ec002feeSBruce M Simpson 	lastref = if_delmulti_locked(ifp, ifma, 0);
2622ec002feeSBruce M Simpson 
2623ec002feeSBruce M Simpson 	if (ifp != NULL) {
2624ec002feeSBruce M Simpson 		/*
2625ec002feeSBruce M Simpson 		 * If and only if the ifnet instance exists:
2626ec002feeSBruce M Simpson 		 *  Release the address lock.
2627ec002feeSBruce M Simpson 		 *  If the group was left: update the hardware hash filter.
2628ec002feeSBruce M Simpson 		 */
2629ec002feeSBruce M Simpson 		IF_ADDR_UNLOCK(ifp);
2630ec002feeSBruce M Simpson 		if (lastref && ifp->if_ioctl != NULL) {
2631ec002feeSBruce M Simpson 			IFF_LOCKGIANT(ifp);
2632ec002feeSBruce M Simpson 			(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
2633ec002feeSBruce M Simpson 			IFF_UNLOCKGIANT(ifp);
2634ec002feeSBruce M Simpson 		}
2635ec002feeSBruce M Simpson 	}
2636ec002feeSBruce M Simpson }
2637ec002feeSBruce M Simpson 
2638ec002feeSBruce M Simpson /*
2639ec002feeSBruce M Simpson  * Perform deletion of network-layer and/or link-layer multicast address.
2640ec002feeSBruce M Simpson  *
2641ec002feeSBruce M Simpson  * Return 0 if the reference count was decremented.
2642ec002feeSBruce M Simpson  * Return 1 if the final reference was released, indicating that the
2643ec002feeSBruce M Simpson  * hardware hash filter should be reprogrammed.
2644ec002feeSBruce M Simpson  */
2645ec002feeSBruce M Simpson static int
2646ec002feeSBruce M Simpson if_delmulti_locked(struct ifnet *ifp, struct ifmultiaddr *ifma, int detaching)
2647ec002feeSBruce M Simpson {
2648ec002feeSBruce M Simpson 	struct ifmultiaddr *ll_ifma;
2649ec002feeSBruce M Simpson 
2650ec002feeSBruce M Simpson 	if (ifp != NULL && ifma->ifma_ifp != NULL) {
2651ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_ifp == ifp,
2652ec002feeSBruce M Simpson 		    ("%s: inconsistent ifp %p", __func__, ifp));
2653ec002feeSBruce M Simpson 		IF_ADDR_LOCK_ASSERT(ifp);
2654ec002feeSBruce M Simpson 	}
2655ec002feeSBruce M Simpson 
2656ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
2657ec002feeSBruce M Simpson 
2658ec002feeSBruce M Simpson 	/*
2659ec002feeSBruce M Simpson 	 * If the ifnet is detaching, null out references to ifnet,
2660ec002feeSBruce M Simpson 	 * so that upper protocol layers will notice, and not attempt
266175ae0c01SBruce M Simpson 	 * to obtain locks for an ifnet which no longer exists. The
266275ae0c01SBruce M Simpson 	 * routing socket announcement must happen before the ifnet
266375ae0c01SBruce M Simpson 	 * instance is detached from the system.
2664ec002feeSBruce M Simpson 	 */
2665ec002feeSBruce M Simpson 	if (detaching) {
2666ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
2667ec002feeSBruce M Simpson 		printf("%s: detaching ifnet instance %p\n", __func__, ifp);
2668ec002feeSBruce M Simpson #endif
266975ae0c01SBruce M Simpson 		/*
267075ae0c01SBruce M Simpson 		 * ifp may already be nulled out if we are being reentered
267175ae0c01SBruce M Simpson 		 * to delete the ll_ifma.
267275ae0c01SBruce M Simpson 		 */
267375ae0c01SBruce M Simpson 		if (ifp != NULL) {
267475ae0c01SBruce M Simpson 			rt_newmaddrmsg(RTM_DELMADDR, ifma);
2675ec002feeSBruce M Simpson 			ifma->ifma_ifp = NULL;
2676ec002feeSBruce M Simpson 		}
267775ae0c01SBruce M Simpson 	}
2678ec002feeSBruce M Simpson 
2679ec002feeSBruce M Simpson 	if (--ifma->ifma_refcount > 0)
26801158dfb7SGarrett Wollman 		return 0;
2681ec002feeSBruce M Simpson 
2682ec002feeSBruce M Simpson 	/*
2683ec002feeSBruce M Simpson 	 * If this ifma is a network-layer ifma, a link-layer ifma may
2684ec002feeSBruce M Simpson 	 * have been associated with it. Release it first if so.
2685ec002feeSBruce M Simpson 	 */
2686ec002feeSBruce M Simpson 	ll_ifma = ifma->ifma_llifma;
2687ec002feeSBruce M Simpson 	if (ll_ifma != NULL) {
2688ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_lladdr != NULL,
2689ec002feeSBruce M Simpson 		    ("%s: llifma w/o lladdr", __func__));
2690ec002feeSBruce M Simpson 		if (detaching)
2691ec002feeSBruce M Simpson 			ll_ifma->ifma_ifp = NULL;	/* XXX */
2692ec002feeSBruce M Simpson 		if (--ll_ifma->ifma_refcount == 0) {
2693ec002feeSBruce M Simpson 			if (ifp != NULL) {
2694ec002feeSBruce M Simpson 				TAILQ_REMOVE(&ifp->if_multiaddrs, ll_ifma,
2695ec002feeSBruce M Simpson 				    ifma_link);
2696ec002feeSBruce M Simpson 			}
2697ec002feeSBruce M Simpson 			if_freemulti(ll_ifma);
2698ec002feeSBruce M Simpson 		}
2699ec002feeSBruce M Simpson 	}
2700ec002feeSBruce M Simpson 
2701ec002feeSBruce M Simpson 	if (ifp != NULL)
2702ec002feeSBruce M Simpson 		TAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifma_link);
2703ec002feeSBruce M Simpson 
2704ec002feeSBruce M Simpson 	if_freemulti(ifma);
2705ec002feeSBruce M Simpson 
2706ec002feeSBruce M Simpson 	/*
2707ec002feeSBruce M Simpson 	 * The last reference to this instance of struct ifmultiaddr
2708ec002feeSBruce M Simpson 	 * was released; the hardware should be notified of this change.
2709ec002feeSBruce M Simpson 	 */
2710ec002feeSBruce M Simpson 	return 1;
27111158dfb7SGarrett Wollman }
27121158dfb7SGarrett Wollman 
271366ce51ceSArchie Cobbs /*
271466ce51ceSArchie Cobbs  * Set the link layer address on an interface.
271566ce51ceSArchie Cobbs  *
271666ce51ceSArchie Cobbs  * At this time we only support certain types of interfaces,
271766ce51ceSArchie Cobbs  * and we don't allow the length of the address to change.
271866ce51ceSArchie Cobbs  */
271966ce51ceSArchie Cobbs int
272066ce51ceSArchie Cobbs if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len)
272166ce51ceSArchie Cobbs {
272266ce51ceSArchie Cobbs 	struct sockaddr_dl *sdl;
272366ce51ceSArchie Cobbs 	struct ifaddr *ifa;
2724d637e989SPeter Wemm 	struct ifreq ifr;
272566ce51ceSArchie Cobbs 
27264a0d6638SRuslan Ermilov 	ifa = ifp->if_addr;
272766ce51ceSArchie Cobbs 	if (ifa == NULL)
272866ce51ceSArchie Cobbs 		return (EINVAL);
272966ce51ceSArchie Cobbs 	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
273066ce51ceSArchie Cobbs 	if (sdl == NULL)
273166ce51ceSArchie Cobbs 		return (EINVAL);
273266ce51ceSArchie Cobbs 	if (len != sdl->sdl_alen)	/* don't allow length to change */
273366ce51ceSArchie Cobbs 		return (EINVAL);
273466ce51ceSArchie Cobbs 	switch (ifp->if_type) {
2735d09ed26fSRuslan Ermilov 	case IFT_ETHER:
273666ce51ceSArchie Cobbs 	case IFT_FDDI:
273766ce51ceSArchie Cobbs 	case IFT_XETHER:
273866ce51ceSArchie Cobbs 	case IFT_ISO88025:
2739b7bffa71SYaroslav Tykhiy 	case IFT_L2VLAN:
27408f867517SAndrew Thompson 	case IFT_BRIDGE:
27416cdcc159SMax Khon 	case IFT_ARCNET:
2742b47888ceSAndrew Thompson 	case IFT_IEEE8023ADLAG:
274366ce51ceSArchie Cobbs 		bcopy(lladdr, LLADDR(sdl), len);
274466ce51ceSArchie Cobbs 		break;
274566ce51ceSArchie Cobbs 	default:
274666ce51ceSArchie Cobbs 		return (ENODEV);
274766ce51ceSArchie Cobbs 	}
274866ce51ceSArchie Cobbs 	/*
274966ce51ceSArchie Cobbs 	 * If the interface is already up, we need
275066ce51ceSArchie Cobbs 	 * to re-init it in order to reprogram its
275166ce51ceSArchie Cobbs 	 * address filter.
275266ce51ceSArchie Cobbs 	 */
275366ce51ceSArchie Cobbs 	if ((ifp->if_flags & IFF_UP) != 0) {
27541a3b6859SYaroslav Tykhiy 		if (ifp->if_ioctl) {
275531302ebfSRobert Watson 			IFF_LOCKGIANT(ifp);
275666ce51ceSArchie Cobbs 			ifp->if_flags &= ~IFF_UP;
275762f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
275862f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
2759ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
276066ce51ceSArchie Cobbs 			ifp->if_flags |= IFF_UP;
276162f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
276262f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
2763ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
276431302ebfSRobert Watson 			IFF_UNLOCKGIANT(ifp);
27651a3b6859SYaroslav Tykhiy 		}
2766b2c08f43SLuigi Rizzo #ifdef INET
2767b2c08f43SLuigi Rizzo 		/*
2768b2c08f43SLuigi Rizzo 		 * Also send gratuitous ARPs to notify other nodes about
2769b2c08f43SLuigi Rizzo 		 * the address change.
2770b2c08f43SLuigi Rizzo 		 */
2771b2c08f43SLuigi Rizzo 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
27724b97d7afSYaroslav Tykhiy 			if (ifa->ifa_addr->sa_family == AF_INET)
2773c0933269SPeter Wemm 				arp_ifinit(ifp, ifa);
2774b2c08f43SLuigi Rizzo 		}
2775b2c08f43SLuigi Rizzo #endif
277666ce51ceSArchie Cobbs 	}
277766ce51ceSArchie Cobbs 	return (0);
277866ce51ceSArchie Cobbs }
277966ce51ceSArchie Cobbs 
27809bf40edeSBrooks Davis /*
27819bf40edeSBrooks Davis  * The name argument must be a pointer to storage which will last as
27829bf40edeSBrooks Davis  * long as the interface does.  For physical devices, the result of
27839bf40edeSBrooks Davis  * device_get_name(dev) is a good choice and for pseudo-devices a
27849bf40edeSBrooks Davis  * static string works well.
27859bf40edeSBrooks Davis  */
27869bf40edeSBrooks Davis void
27879bf40edeSBrooks Davis if_initname(struct ifnet *ifp, const char *name, int unit)
27889bf40edeSBrooks Davis {
27899bf40edeSBrooks Davis 	ifp->if_dname = name;
27909bf40edeSBrooks Davis 	ifp->if_dunit = unit;
27919bf40edeSBrooks Davis 	if (unit != IF_DUNIT_NONE)
27929bf40edeSBrooks Davis 		snprintf(ifp->if_xname, IFNAMSIZ, "%s%d", name, unit);
27939bf40edeSBrooks Davis 	else
27949bf40edeSBrooks Davis 		strlcpy(ifp->if_xname, name, IFNAMSIZ);
27959bf40edeSBrooks Davis }
27969bf40edeSBrooks Davis 
2797fa882e87SBrooks Davis int
2798fa882e87SBrooks Davis if_printf(struct ifnet *ifp, const char * fmt, ...)
2799fa882e87SBrooks Davis {
2800fa882e87SBrooks Davis 	va_list ap;
2801fa882e87SBrooks Davis 	int retval;
2802fa882e87SBrooks Davis 
28039bf40edeSBrooks Davis 	retval = printf("%s: ", ifp->if_xname);
2804fa882e87SBrooks Davis 	va_start(ap, fmt);
2805fa882e87SBrooks Davis 	retval += vprintf(fmt, ap);
2806fa882e87SBrooks Davis 	va_end(ap);
2807fa882e87SBrooks Davis 	return (retval);
2808fa882e87SBrooks Davis }
2809fa882e87SBrooks Davis 
2810af5e59bfSRobert Watson /*
2811af5e59bfSRobert Watson  * When an interface is marked IFF_NEEDSGIANT, its if_start() routine cannot
2812af5e59bfSRobert Watson  * be called without Giant.  However, we often can't acquire the Giant lock
2813af5e59bfSRobert Watson  * at those points; instead, we run it via a task queue that holds Giant via
2814af5e59bfSRobert Watson  * if_start_deferred.
2815af5e59bfSRobert Watson  *
2816af5e59bfSRobert Watson  * XXXRW: We need to make sure that the ifnet isn't fully detached until any
2817af5e59bfSRobert Watson  * outstanding if_start_deferred() tasks that will run after the free.  This
2818af5e59bfSRobert Watson  * probably means waiting in if_detach().
2819af5e59bfSRobert Watson  */
2820af5e59bfSRobert Watson void
2821af5e59bfSRobert Watson if_start(struct ifnet *ifp)
2822af5e59bfSRobert Watson {
2823af5e59bfSRobert Watson 
282433d2bb9cSRobert Watson 	if (ifp->if_flags & IFF_NEEDSGIANT) {
2825af5e59bfSRobert Watson 		if (mtx_owned(&Giant))
2826af5e59bfSRobert Watson 			(*(ifp)->if_start)(ifp);
2827af5e59bfSRobert Watson 		else
2828af5e59bfSRobert Watson 			taskqueue_enqueue(taskqueue_swi_giant,
2829af5e59bfSRobert Watson 			    &ifp->if_starttask);
2830af5e59bfSRobert Watson 	} else
2831af5e59bfSRobert Watson 		(*(ifp)->if_start)(ifp);
2832af5e59bfSRobert Watson }
2833af5e59bfSRobert Watson 
2834af5e59bfSRobert Watson static void
2835af5e59bfSRobert Watson if_start_deferred(void *context, int pending)
2836af5e59bfSRobert Watson {
2837af5e59bfSRobert Watson 	struct ifnet *ifp;
2838af5e59bfSRobert Watson 
2839af5e59bfSRobert Watson 	GIANT_REQUIRED;
2840af5e59bfSRobert Watson 
2841fc74a9f9SBrooks Davis 	ifp = context;
2842af5e59bfSRobert Watson 	(ifp->if_start)(ifp);
2843af5e59bfSRobert Watson }
2844af5e59bfSRobert Watson 
2845db7f0b97SKip Macy /*
2846db7f0b97SKip Macy  * Backwards compatibility interface for drivers
2847db7f0b97SKip Macy  * that have not implemented it
2848db7f0b97SKip Macy  */
2849db7f0b97SKip Macy static int
2850db7f0b97SKip Macy if_transmit(struct ifnet *ifp, struct mbuf *m)
2851db7f0b97SKip Macy {
2852db7f0b97SKip Macy 	int error;
2853db7f0b97SKip Macy 
2854db7f0b97SKip Macy 	IFQ_HANDOFF(ifp, m, error);
2855db7f0b97SKip Macy 	return (error);
2856db7f0b97SKip Macy }
2857db7f0b97SKip Macy 
28580b762445SRobert Watson int
28590b762445SRobert Watson if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp, int adjust)
28600b762445SRobert Watson {
28610b762445SRobert Watson 	int active = 0;
28620b762445SRobert Watson 
28630b762445SRobert Watson 	IF_LOCK(ifq);
28640b762445SRobert Watson 	if (_IF_QFULL(ifq)) {
28650b762445SRobert Watson 		_IF_DROP(ifq);
28660b762445SRobert Watson 		IF_UNLOCK(ifq);
28670b762445SRobert Watson 		m_freem(m);
28680b762445SRobert Watson 		return (0);
28690b762445SRobert Watson 	}
28700b762445SRobert Watson 	if (ifp != NULL) {
28710b762445SRobert Watson 		ifp->if_obytes += m->m_pkthdr.len + adjust;
28720b762445SRobert Watson 		if (m->m_flags & (M_BCAST|M_MCAST))
28730b762445SRobert Watson 			ifp->if_omcasts++;
2874292ee7beSRobert Watson 		active = ifp->if_drv_flags & IFF_DRV_OACTIVE;
28750b762445SRobert Watson 	}
28760b762445SRobert Watson 	_IF_ENQUEUE(ifq, m);
28770b762445SRobert Watson 	IF_UNLOCK(ifq);
28780b762445SRobert Watson 	if (ifp != NULL && !active)
28790b762445SRobert Watson 		if_start(ifp);
28800b762445SRobert Watson 	return (1);
28810b762445SRobert Watson }
2882fc74a9f9SBrooks Davis 
2883fc74a9f9SBrooks Davis void
2884fc74a9f9SBrooks Davis if_register_com_alloc(u_char type,
2885fc74a9f9SBrooks Davis     if_com_alloc_t *a, if_com_free_t *f)
2886fc74a9f9SBrooks Davis {
2887fc74a9f9SBrooks Davis 
2888fc74a9f9SBrooks Davis 	KASSERT(if_com_alloc[type] == NULL,
2889fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d already registered", type));
2890fc74a9f9SBrooks Davis 	KASSERT(if_com_free[type] == NULL,
2891fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d free already registered", type));
2892fc74a9f9SBrooks Davis 
2893fc74a9f9SBrooks Davis 	if_com_alloc[type] = a;
2894fc74a9f9SBrooks Davis 	if_com_free[type] = f;
2895fc74a9f9SBrooks Davis }
2896fc74a9f9SBrooks Davis 
2897fc74a9f9SBrooks Davis void
2898fc74a9f9SBrooks Davis if_deregister_com_alloc(u_char type)
2899fc74a9f9SBrooks Davis {
2900fc74a9f9SBrooks Davis 
2901affcaf78SMax Khon 	KASSERT(if_com_alloc[type] != NULL,
2902fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d not registered", type));
2903affcaf78SMax Khon 	KASSERT(if_com_free[type] != NULL,
2904fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d free not registered", type));
2905fc74a9f9SBrooks Davis 	if_com_alloc[type] = NULL;
2906fc74a9f9SBrooks Davis 	if_com_free[type] = NULL;
2907fc74a9f9SBrooks Davis }
2908