1c398230bSWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4df8bae1dSRodney W. Grimes * Copyright (c) 1982, 1986, 1991, 1993 5df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 681d96ce8SMax Laier * Copyright (C) 2001 WIDE Project. All rights reserved. 7df8bae1dSRodney W. Grimes * 8df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 9df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 10df8bae1dSRodney W. Grimes * are met: 11df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 12df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 13df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 14df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 15df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 16fbbd9655SWarner Losh * 3. Neither the name of the University nor the names of its contributors 17df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 18df8bae1dSRodney W. Grimes * without specific prior written permission. 19df8bae1dSRodney W. Grimes * 20df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30df8bae1dSRodney W. Grimes * SUCH DAMAGE. 31df8bae1dSRodney W. Grimes */ 32df8bae1dSRodney W. Grimes 334b421e2dSMike Silbersack #include <sys/cdefs.h> 34eb8dcdeaSGleb Smirnoff #include "opt_inet.h" 35eb8dcdeaSGleb Smirnoff 362f35e7d9SMike Karels #define IN_HISTORICAL_NETS /* include class masks */ 372f35e7d9SMike Karels 38df8bae1dSRodney W. Grimes #include <sys/param.h> 39c3322cb9SGleb Smirnoff #include <sys/eventhandler.h> 4026f9a767SRodney W. Grimes #include <sys/systm.h> 4151a53488SBruce Evans #include <sys/sockio.h> 42df8bae1dSRodney W. Grimes #include <sys/malloc.h> 43acd3428bSRobert Watson #include <sys/priv.h> 44df8bae1dSRodney W. Grimes #include <sys/socket.h> 455ce0eb7fSBjoern A. Zeeb #include <sys/jail.h> 46f6d24a78SPoul-Henning Kamp #include <sys/kernel.h> 47cc0a3c8cSAndrey V. Elsukov #include <sys/lock.h> 485ce0eb7fSBjoern A. Zeeb #include <sys/proc.h> 49f6d24a78SPoul-Henning Kamp #include <sys/sysctl.h> 50ebc90701SQing Li #include <sys/syslog.h> 51f7a39160SGleb Smirnoff #include <sys/sx.h> 52df8bae1dSRodney W. Grimes 53df8bae1dSRodney W. Grimes #include <net/if.h> 54df813b7eSQing Li #include <net/if_var.h> 55e162ea60SGeorge V. Neville-Neil #include <net/if_arp.h> 56ebc90701SQing Li #include <net/if_dl.h> 576e6b3f7cSQing Li #include <net/if_llatbl.h> 583d0d5b21SJustin Hibbits #include <net/if_private.h> 596a800098SYoshinobu Inoue #include <net/if_types.h> 60df8bae1dSRodney W. Grimes #include <net/route.h> 6181728a53SAlexander V. Chernikov #include <net/route/nhop.h> 6281728a53SAlexander V. Chernikov #include <net/route/route_ctl.h> 63ebc90701SQing Li #include <net/vnet.h> 64df8bae1dSRodney W. Grimes 6508b68b0eSGleb Smirnoff #include <netinet/if_ether.h> 66df8bae1dSRodney W. Grimes #include <netinet/in.h> 67936f4a42SAlexander V. Chernikov #include <netinet/in_fib.h> 68df8bae1dSRodney W. Grimes #include <netinet/in_var.h> 69e43cc4aeSHajimu UMEMOTO #include <netinet/in_pcb.h> 7071498f30SBruce M Simpson #include <netinet/ip_var.h> 7108b68b0eSGleb Smirnoff #include <netinet/ip_carp.h> 72d10910e6SBruce M Simpson #include <netinet/igmp_var.h> 73eddfbb76SRobert Watson #include <netinet/udp.h> 74eddfbb76SRobert Watson #include <netinet/udp_var.h> 7555166637SPoul-Henning Kamp 76215bab79SShivank Garg #ifdef MAC 77215bab79SShivank Garg #include <security/mac/mac_framework.h> 78215bab79SShivank Garg #endif 79215bab79SShivank Garg 80f375bf0eSAlexander V. Chernikov static int in_aifaddr_ioctl(u_long, caddr_t, struct ifnet *, struct ucred *); 81f375bf0eSAlexander V. Chernikov static int in_difaddr_ioctl(u_long, caddr_t, struct ifnet *, struct ucred *); 82f375bf0eSAlexander V. Chernikov static int in_gifaddr_ioctl(u_long, caddr_t, struct ifnet *, struct ucred *); 836a800098SYoshinobu Inoue 844d77a549SAlfred Perlstein static void in_socktrim(struct sockaddr_in *); 85ec002feeSBruce M Simpson static void in_purgemaddrs(struct ifnet *); 86df8bae1dSRodney W. Grimes 87130aebbaSAlexander V. Chernikov static bool ia_need_loopback_route(const struct in_ifaddr *); 88130aebbaSAlexander V. Chernikov 895f901c92SAndrew Turner VNET_DEFINE_STATIC(int, nosameprefix); 9008b68b0eSGleb Smirnoff #define V_nosameprefix VNET(nosameprefix) 916df8a710SGleb Smirnoff SYSCTL_INT(_net_inet_ip, OID_AUTO, no_same_prefix, CTLFLAG_VNET | CTLFLAG_RW, 9208b68b0eSGleb Smirnoff &VNET_NAME(nosameprefix), 0, 931ae95409SGleb Smirnoff "Refuse to create same prefixes on different interfaces"); 94477180fbSGarrett Wollman 95fd076593SMike Karels VNET_DEFINE_STATIC(bool, broadcast_lowest); 96fd076593SMike Karels #define V_broadcast_lowest VNET(broadcast_lowest) 97fd076593SMike Karels SYSCTL_BOOL(_net_inet_ip, OID_AUTO, broadcast_lowest, CTLFLAG_VNET | CTLFLAG_RW, 98fd076593SMike Karels &VNET_NAME(broadcast_lowest), 0, 99fd076593SMike Karels "Treat lowest address on a subnet (host 0) as broadcast"); 100fd076593SMike Karels 101efe58855SMike Karels VNET_DEFINE(bool, ip_allow_net240) = false; 102efe58855SMike Karels #define V_ip_allow_net240 VNET(ip_allow_net240) 103efe58855SMike Karels SYSCTL_BOOL(_net_inet_ip, OID_AUTO, allow_net240, 104efe58855SMike Karels CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip_allow_net240), 0, 105efe58855SMike Karels "Allow use of Experimental addresses, aka Class E (240/4)"); 106efe58855SMike Karels /* see https://datatracker.ietf.org/doc/draft-schoen-intarea-unicast-240 */ 107efe58855SMike Karels 108efe58855SMike Karels VNET_DEFINE(bool, ip_allow_net0) = false; 109efe58855SMike Karels SYSCTL_BOOL(_net_inet_ip, OID_AUTO, allow_net0, 110efe58855SMike Karels CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip_allow_net0), 0, 111efe58855SMike Karels "Allow use of addresses in network 0/8"); 112efe58855SMike Karels /* see https://datatracker.ietf.org/doc/draft-schoen-intarea-unicast-0 */ 113efe58855SMike Karels 114efe58855SMike Karels VNET_DEFINE(uint32_t, in_loopback_mask) = IN_LOOPBACK_MASK_DFLT; 115efe58855SMike Karels #define V_in_loopback_mask VNET(in_loopback_mask) 116efe58855SMike Karels static int sysctl_loopback_prefixlen(SYSCTL_HANDLER_ARGS); 117efe58855SMike Karels SYSCTL_PROC(_net_inet_ip, OID_AUTO, loopback_prefixlen, 118efe58855SMike Karels CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW, 119efe58855SMike Karels NULL, 0, sysctl_loopback_prefixlen, "I", 120efe58855SMike Karels "Prefix length of address space reserved for loopback"); 121efe58855SMike Karels /* see https://datatracker.ietf.org/doc/draft-schoen-intarea-unicast-127 */ 122efe58855SMike Karels 12382cea7e6SBjoern A. Zeeb VNET_DECLARE(struct inpcbinfo, ripcbinfo); 12482cea7e6SBjoern A. Zeeb #define V_ripcbinfo VNET(ripcbinfo) 12582cea7e6SBjoern A. Zeeb 126f7a39160SGleb Smirnoff static struct sx in_control_sx; 127f7a39160SGleb Smirnoff SX_SYSINIT(in_control_sx, &in_control_sx, "in_control"); 128f7a39160SGleb Smirnoff 129df8bae1dSRodney W. Grimes /* 130df8bae1dSRodney W. Grimes * Return 1 if an internet address is for a ``local'' host 131b365d954SGleb Smirnoff * (one to which we have a connection). 132df8bae1dSRodney W. Grimes */ 13326f9a767SRodney W. Grimes int 134f2565d68SRobert Watson in_localaddr(struct in_addr in) 135df8bae1dSRodney W. Grimes { 1363e85b721SEd Maste u_long i = ntohl(in.s_addr); 1373e85b721SEd Maste struct in_ifaddr *ia; 138df8bae1dSRodney W. Grimes 1392144431cSGleb Smirnoff NET_EPOCH_ASSERT(); 1402144431cSGleb Smirnoff 141d7c5a620SMatt Macy CK_STAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) { 1422144431cSGleb Smirnoff if ((i & ia->ia_subnetmask) == ia->ia_subnet) 1432d9cfabaSRobert Watson return (1); 1442d9cfabaSRobert Watson } 1452144431cSGleb Smirnoff 146df8bae1dSRodney W. Grimes return (0); 147df8bae1dSRodney W. Grimes } 148df8bae1dSRodney W. Grimes 149df8bae1dSRodney W. Grimes /* 1502eccc90bSAndre Oppermann * Return 1 if an internet address is for the local host and configured 1512eccc90bSAndre Oppermann * on one of its interfaces. 1522eccc90bSAndre Oppermann */ 153c8ee75f2SGleb Smirnoff bool 154f2565d68SRobert Watson in_localip(struct in_addr in) 1552eccc90bSAndre Oppermann { 1562eccc90bSAndre Oppermann struct in_ifaddr *ia; 1572eccc90bSAndre Oppermann 158c8ee75f2SGleb Smirnoff NET_EPOCH_ASSERT(); 159c8ee75f2SGleb Smirnoff 160c8ee75f2SGleb Smirnoff CK_LIST_FOREACH(ia, INADDR_HASH(in.s_addr), ia_hash) 161c8ee75f2SGleb Smirnoff if (IA_SIN(ia)->sin_addr.s_addr == in.s_addr) 162c8ee75f2SGleb Smirnoff return (true); 163c8ee75f2SGleb Smirnoff 164c8ee75f2SGleb Smirnoff return (false); 1652eccc90bSAndre Oppermann } 1662eccc90bSAndre Oppermann 1672eccc90bSAndre Oppermann /* 16856f78600SGleb Smirnoff * Like in_localip(), but FIB-aware and carp(4)-aware. 1699c89392fSGleb Smirnoff */ 1709c89392fSGleb Smirnoff bool 1719c89392fSGleb Smirnoff in_localip_fib(struct in_addr in, uint16_t fib) 1729c89392fSGleb Smirnoff { 1739c89392fSGleb Smirnoff struct in_ifaddr *ia; 1749c89392fSGleb Smirnoff 1759c89392fSGleb Smirnoff NET_EPOCH_ASSERT(); 1769c89392fSGleb Smirnoff 1779c89392fSGleb Smirnoff CK_LIST_FOREACH(ia, INADDR_HASH(in.s_addr), ia_hash) 1789c89392fSGleb Smirnoff if (IA_SIN(ia)->sin_addr.s_addr == in.s_addr && 17956f78600SGleb Smirnoff (ia->ia_ifa.ifa_carp == NULL || 18056f78600SGleb Smirnoff carp_master_p(&ia->ia_ifa)) && 1819c89392fSGleb Smirnoff ia->ia_ifa.ifa_ifp->if_fib == fib) 1829c89392fSGleb Smirnoff return (true); 1839c89392fSGleb Smirnoff 1849c89392fSGleb Smirnoff return (false); 1859c89392fSGleb Smirnoff } 1869c89392fSGleb Smirnoff 1879c89392fSGleb Smirnoff /* 18828ebe80cSGleb Smirnoff * Return 1 if an internet address is configured on an interface. 18928ebe80cSGleb Smirnoff */ 19028ebe80cSGleb Smirnoff int 19128ebe80cSGleb Smirnoff in_ifhasaddr(struct ifnet *ifp, struct in_addr in) 19228ebe80cSGleb Smirnoff { 19328ebe80cSGleb Smirnoff struct ifaddr *ifa; 19428ebe80cSGleb Smirnoff struct in_ifaddr *ia; 19528ebe80cSGleb Smirnoff 196b8a6e03fSGleb Smirnoff NET_EPOCH_ASSERT(); 197b8a6e03fSGleb Smirnoff 198d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 19928ebe80cSGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 20028ebe80cSGleb Smirnoff continue; 20128ebe80cSGleb Smirnoff ia = (struct in_ifaddr *)ifa; 202b8a6e03fSGleb Smirnoff if (ia->ia_addr.sin_addr.s_addr == in.s_addr) 20328ebe80cSGleb Smirnoff return (1); 20428ebe80cSGleb Smirnoff } 20528ebe80cSGleb Smirnoff 20628ebe80cSGleb Smirnoff return (0); 20728ebe80cSGleb Smirnoff } 20828ebe80cSGleb Smirnoff 20928ebe80cSGleb Smirnoff /* 210f7a39160SGleb Smirnoff * Return a reference to the interface address which is different to 211f7a39160SGleb Smirnoff * the supplied one but with same IP address value. 212f7a39160SGleb Smirnoff */ 213f7a39160SGleb Smirnoff static struct in_ifaddr * 2149fdbf7eeSAlexander V. Chernikov in_localip_more(struct in_ifaddr *original_ia) 215f7a39160SGleb Smirnoff { 216c8ee75f2SGleb Smirnoff struct epoch_tracker et; 2179fdbf7eeSAlexander V. Chernikov in_addr_t original_addr = IA_SIN(original_ia)->sin_addr.s_addr; 2189fdbf7eeSAlexander V. Chernikov uint32_t original_fib = original_ia->ia_ifa.ifa_ifp->if_fib; 2199fdbf7eeSAlexander V. Chernikov struct in_ifaddr *ia; 220f7a39160SGleb Smirnoff 221c8ee75f2SGleb Smirnoff NET_EPOCH_ENTER(et); 222c8ee75f2SGleb Smirnoff CK_LIST_FOREACH(ia, INADDR_HASH(original_addr), ia_hash) { 2239fdbf7eeSAlexander V. Chernikov in_addr_t addr = IA_SIN(ia)->sin_addr.s_addr; 2249fdbf7eeSAlexander V. Chernikov uint32_t fib = ia->ia_ifa.ifa_ifp->if_fib; 2259fdbf7eeSAlexander V. Chernikov if (!V_rt_add_addr_allfibs && (original_fib != fib)) 2269fdbf7eeSAlexander V. Chernikov continue; 2279fdbf7eeSAlexander V. Chernikov if ((original_ia != ia) && (original_addr == addr)) { 2289fdbf7eeSAlexander V. Chernikov ifa_ref(&ia->ia_ifa); 229c8ee75f2SGleb Smirnoff NET_EPOCH_EXIT(et); 2309fdbf7eeSAlexander V. Chernikov return (ia); 231f7a39160SGleb Smirnoff } 232f7a39160SGleb Smirnoff } 233c8ee75f2SGleb Smirnoff NET_EPOCH_EXIT(et); 234f7a39160SGleb Smirnoff 235f7a39160SGleb Smirnoff return (NULL); 236f7a39160SGleb Smirnoff } 237f7a39160SGleb Smirnoff 238f7a39160SGleb Smirnoff /* 2394b631fc8SAlexander V. Chernikov * Tries to find first IPv4 address in the provided fib. 2404b631fc8SAlexander V. Chernikov * Prefers non-loopback addresses and return loopback IFF 2414b631fc8SAlexander V. Chernikov * @loopback_ok is set. 2424b631fc8SAlexander V. Chernikov * 2434b631fc8SAlexander V. Chernikov * Returns ifa or NULL. 2444b631fc8SAlexander V. Chernikov */ 2454b631fc8SAlexander V. Chernikov struct in_ifaddr * 2464b631fc8SAlexander V. Chernikov in_findlocal(uint32_t fibnum, bool loopback_ok) 2474b631fc8SAlexander V. Chernikov { 2484b631fc8SAlexander V. Chernikov struct in_ifaddr *ia = NULL, *ia_lo = NULL; 2494b631fc8SAlexander V. Chernikov 2504b631fc8SAlexander V. Chernikov NET_EPOCH_ASSERT(); 2514b631fc8SAlexander V. Chernikov 2524b631fc8SAlexander V. Chernikov CK_STAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) { 2534b631fc8SAlexander V. Chernikov uint32_t ia_fib = ia->ia_ifa.ifa_ifp->if_fib; 2544b631fc8SAlexander V. Chernikov if (!V_rt_add_addr_allfibs && (fibnum != ia_fib)) 2554b631fc8SAlexander V. Chernikov continue; 2564b631fc8SAlexander V. Chernikov 2574b631fc8SAlexander V. Chernikov if (!IN_LOOPBACK(ntohl(IA_SIN(ia)->sin_addr.s_addr))) 2584b631fc8SAlexander V. Chernikov break; 2594b631fc8SAlexander V. Chernikov if (loopback_ok) 2604b631fc8SAlexander V. Chernikov ia_lo = ia; 2614b631fc8SAlexander V. Chernikov } 2624b631fc8SAlexander V. Chernikov 2634b631fc8SAlexander V. Chernikov if (ia == NULL) 2644b631fc8SAlexander V. Chernikov ia = ia_lo; 2654b631fc8SAlexander V. Chernikov 2664b631fc8SAlexander V. Chernikov return (ia); 2674b631fc8SAlexander V. Chernikov } 2684b631fc8SAlexander V. Chernikov 2694b631fc8SAlexander V. Chernikov /* 270df8bae1dSRodney W. Grimes * Determine whether an IP address is in a reserved set of addresses 271df8bae1dSRodney W. Grimes * that may not be forwarded, or whether datagrams to that destination 272df8bae1dSRodney W. Grimes * may be forwarded. 273df8bae1dSRodney W. Grimes */ 27426f9a767SRodney W. Grimes int 275f2565d68SRobert Watson in_canforward(struct in_addr in) 276df8bae1dSRodney W. Grimes { 2773e85b721SEd Maste u_long i = ntohl(in.s_addr); 278df8bae1dSRodney W. Grimes 279efe58855SMike Karels if (IN_MULTICAST(i) || IN_LINKLOCAL(i) || IN_LOOPBACK(i)) 280efe58855SMike Karels return (0); 281efe58855SMike Karels if (IN_EXPERIMENTAL(i) && !V_ip_allow_net240) 282efe58855SMike Karels return (0); 283efe58855SMike Karels if (IN_ZERONET(i) && !V_ip_allow_net0) 284df8bae1dSRodney W. Grimes return (0); 285df8bae1dSRodney W. Grimes return (1); 286df8bae1dSRodney W. Grimes } 287df8bae1dSRodney W. Grimes 288df8bae1dSRodney W. Grimes /* 289efe58855SMike Karels * Sysctl to manage prefix of reserved loopback network; translate 290efe58855SMike Karels * to/from mask. The mask is always contiguous high-order 1 bits 291efe58855SMike Karels * followed by all 0 bits. 292efe58855SMike Karels */ 293efe58855SMike Karels static int 294efe58855SMike Karels sysctl_loopback_prefixlen(SYSCTL_HANDLER_ARGS) 295efe58855SMike Karels { 296efe58855SMike Karels int error, preflen; 297efe58855SMike Karels 298efe58855SMike Karels /* ffs is 1-based; compensate. */ 299efe58855SMike Karels preflen = 33 - ffs(V_in_loopback_mask); 300efe58855SMike Karels error = sysctl_handle_int(oidp, &preflen, 0, req); 301efe58855SMike Karels if (error || !req->newptr) 302efe58855SMike Karels return (error); 303fb8ef16bSMike Karels if (preflen < 8 || preflen > 31) 304efe58855SMike Karels return (EINVAL); 305efe58855SMike Karels V_in_loopback_mask = 0xffffffff << (32 - preflen); 306efe58855SMike Karels return (0); 307efe58855SMike Karels } 308efe58855SMike Karels 309efe58855SMike Karels /* 310df8bae1dSRodney W. Grimes * Trim a mask in a sockaddr 311df8bae1dSRodney W. Grimes */ 3120312fbe9SPoul-Henning Kamp static void 313f2565d68SRobert Watson in_socktrim(struct sockaddr_in *ap) 314df8bae1dSRodney W. Grimes { 3153e85b721SEd Maste char *cplim = (char *) &ap->sin_addr; 3163e85b721SEd Maste char *cp = (char *) (&ap->sin_addr + 1); 317df8bae1dSRodney W. Grimes 318df8bae1dSRodney W. Grimes ap->sin_len = 0; 319df00058dSGarrett Wollman while (--cp >= cplim) 320df8bae1dSRodney W. Grimes if (*cp) { 321df8bae1dSRodney W. Grimes (ap)->sin_len = cp - (char *) (ap) + 1; 322df8bae1dSRodney W. Grimes break; 323df8bae1dSRodney W. Grimes } 324df8bae1dSRodney W. Grimes } 325df8bae1dSRodney W. Grimes 326df8bae1dSRodney W. Grimes /* 327df8bae1dSRodney W. Grimes * Generic internet control operations (ioctl's). 328df8bae1dSRodney W. Grimes */ 32926f9a767SRodney W. Grimes int 330bb06a80cSAlexander V. Chernikov in_control_ioctl(u_long cmd, void *data, struct ifnet *ifp, 331bb06a80cSAlexander V. Chernikov struct ucred *cred) 332df8bae1dSRodney W. Grimes { 333f7a39160SGleb Smirnoff struct ifreq *ifr = (struct ifreq *)data; 334f7a39160SGleb Smirnoff struct sockaddr_in *addr = (struct sockaddr_in *)&ifr->ifr_addr; 335a68cc388SGleb Smirnoff struct epoch_tracker et; 336821b5cafSGleb Smirnoff struct ifaddr *ifa; 337f7a39160SGleb Smirnoff struct in_ifaddr *ia; 338f7a39160SGleb Smirnoff int error; 339f7a39160SGleb Smirnoff 340f7a39160SGleb Smirnoff if (ifp == NULL) 341f7a39160SGleb Smirnoff return (EADDRNOTAVAIL); 34271212473SGleb Smirnoff 34371212473SGleb Smirnoff /* 344f7a39160SGleb Smirnoff * Filter out 4 ioctls we implement directly. Forward the rest 345f7a39160SGleb Smirnoff * to specific functions and ifp->if_ioctl(). 346bbb3fb61SRobert Watson */ 3476a800098SYoshinobu Inoue switch (cmd) { 348bbb3fb61SRobert Watson case SIOCGIFADDR: 349bbb3fb61SRobert Watson case SIOCGIFBRDADDR: 350bbb3fb61SRobert Watson case SIOCGIFDSTADDR: 351bbb3fb61SRobert Watson case SIOCGIFNETMASK: 352f7a39160SGleb Smirnoff break; 3536952c3e1SAndrey V. Elsukov case SIOCGIFALIAS: 3546952c3e1SAndrey V. Elsukov sx_xlock(&in_control_sx); 355f375bf0eSAlexander V. Chernikov error = in_gifaddr_ioctl(cmd, data, ifp, cred); 3566952c3e1SAndrey V. Elsukov sx_xunlock(&in_control_sx); 3576952c3e1SAndrey V. Elsukov return (error); 3586d00fd9cSGleb Smirnoff case SIOCDIFADDR: 359f7a39160SGleb Smirnoff sx_xlock(&in_control_sx); 360f375bf0eSAlexander V. Chernikov error = in_difaddr_ioctl(cmd, data, ifp, cred); 361f7a39160SGleb Smirnoff sx_xunlock(&in_control_sx); 362f7a39160SGleb Smirnoff return (error); 36377b89ad8SGleb Smirnoff case OSIOCAIFADDR: /* 9.x compat */ 3646d00fd9cSGleb Smirnoff case SIOCAIFADDR: 365f7a39160SGleb Smirnoff sx_xlock(&in_control_sx); 366f375bf0eSAlexander V. Chernikov error = in_aifaddr_ioctl(cmd, data, ifp, cred); 367f7a39160SGleb Smirnoff sx_xunlock(&in_control_sx); 368f7a39160SGleb Smirnoff return (error); 369bbb3fb61SRobert Watson case SIOCSIFADDR: 370bbb3fb61SRobert Watson case SIOCSIFBRDADDR: 371bbb3fb61SRobert Watson case SIOCSIFDSTADDR: 372bbb3fb61SRobert Watson case SIOCSIFNETMASK: 37356cf9dc1SGleb Smirnoff /* We no longer support that old commands. */ 3746d00fd9cSGleb Smirnoff return (EINVAL); 375bbb3fb61SRobert Watson default: 376f7a39160SGleb Smirnoff if (ifp->if_ioctl == NULL) 377bbb3fb61SRobert Watson return (EOPNOTSUPP); 378bbb3fb61SRobert Watson return ((*ifp->if_ioctl)(ifp, cmd, data)); 3796a800098SYoshinobu Inoue } 3806a800098SYoshinobu Inoue 381821b5cafSGleb Smirnoff if (addr->sin_addr.s_addr != INADDR_ANY && 382f375bf0eSAlexander V. Chernikov prison_check_ip4(cred, &addr->sin_addr) != 0) 383821b5cafSGleb Smirnoff return (EADDRNOTAVAIL); 384821b5cafSGleb Smirnoff 385cf7b18f1SRobert Watson /* 386a7f77a39SXin LI * Find address for this interface, if it exists. If an 387a7f77a39SXin LI * address was specified, find that one instead of the 388a7f77a39SXin LI * first one on the interface, if possible. 389df8bae1dSRodney W. Grimes */ 390a68cc388SGleb Smirnoff NET_EPOCH_ENTER(et); 391d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 3929706c950SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 3939706c950SGleb Smirnoff continue; 394821b5cafSGleb Smirnoff ia = (struct in_ifaddr *)ifa; 395821b5cafSGleb Smirnoff if (ia->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr) 396df8bae1dSRodney W. Grimes break; 397ca925d9cSJonathan Lemon } 398a7f77a39SXin LI if (ifa == NULL) 399d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) 400a7f77a39SXin LI if (ifa->ifa_addr->sa_family == AF_INET) { 401a7f77a39SXin LI ia = (struct in_ifaddr *)ifa; 402f375bf0eSAlexander V. Chernikov if (prison_check_ip4(cred, 403a7f77a39SXin LI &ia->ia_addr.sin_addr) == 0) 404a7f77a39SXin LI break; 405a7f77a39SXin LI } 406f7a39160SGleb Smirnoff 407821b5cafSGleb Smirnoff if (ifa == NULL) { 408a68cc388SGleb Smirnoff NET_EPOCH_EXIT(et); 409f7a39160SGleb Smirnoff return (EADDRNOTAVAIL); 410ac0aa473SBill Fenner } 411df8bae1dSRodney W. Grimes 412588885f2SRobert Watson error = 0; 413df8bae1dSRodney W. Grimes switch (cmd) { 414f7a39160SGleb Smirnoff case SIOCGIFADDR: 415f7a39160SGleb Smirnoff *addr = ia->ia_addr; 416f7a39160SGleb Smirnoff break; 4178c0fec80SRobert Watson 418f7a39160SGleb Smirnoff case SIOCGIFBRDADDR: 419f7a39160SGleb Smirnoff if ((ifp->if_flags & IFF_BROADCAST) == 0) { 420f7a39160SGleb Smirnoff error = EINVAL; 421df8bae1dSRodney W. Grimes break; 422df8bae1dSRodney W. Grimes } 423f7a39160SGleb Smirnoff *addr = ia->ia_broadaddr; 424f7a39160SGleb Smirnoff break; 425f7a39160SGleb Smirnoff 426f7a39160SGleb Smirnoff case SIOCGIFDSTADDR: 427f7a39160SGleb Smirnoff if ((ifp->if_flags & IFF_POINTOPOINT) == 0) { 428f7a39160SGleb Smirnoff error = EINVAL; 429f7a39160SGleb Smirnoff break; 430f7a39160SGleb Smirnoff } 431f7a39160SGleb Smirnoff *addr = ia->ia_dstaddr; 432f7a39160SGleb Smirnoff break; 433f7a39160SGleb Smirnoff 434f7a39160SGleb Smirnoff case SIOCGIFNETMASK: 435f7a39160SGleb Smirnoff *addr = ia->ia_sockmask; 436f7a39160SGleb Smirnoff break; 437f7a39160SGleb Smirnoff } 438f7a39160SGleb Smirnoff 439a68cc388SGleb Smirnoff NET_EPOCH_EXIT(et); 440f7a39160SGleb Smirnoff 441f7a39160SGleb Smirnoff return (error); 4421067217dSGarrett Wollman } 443f7a39160SGleb Smirnoff 444bb06a80cSAlexander V. Chernikov int 445bb06a80cSAlexander V. Chernikov in_control(struct socket *so, u_long cmd, void *data, struct ifnet *ifp, 446bb06a80cSAlexander V. Chernikov struct thread *td) 447bb06a80cSAlexander V. Chernikov { 448bb06a80cSAlexander V. Chernikov return (in_control_ioctl(cmd, data, ifp, td ? td->td_ucred : NULL)); 449bb06a80cSAlexander V. Chernikov } 450bb06a80cSAlexander V. Chernikov 451f7a39160SGleb Smirnoff static int 452f375bf0eSAlexander V. Chernikov in_aifaddr_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp, struct ucred *cred) 453f7a39160SGleb Smirnoff { 454f7a39160SGleb Smirnoff const struct in_aliasreq *ifra = (struct in_aliasreq *)data; 455f7a39160SGleb Smirnoff const struct sockaddr_in *addr = &ifra->ifra_addr; 456f7a39160SGleb Smirnoff const struct sockaddr_in *broadaddr = &ifra->ifra_broadaddr; 457f7a39160SGleb Smirnoff const struct sockaddr_in *mask = &ifra->ifra_mask; 458f7a39160SGleb Smirnoff const struct sockaddr_in *dstaddr = &ifra->ifra_dstaddr; 45977b89ad8SGleb Smirnoff const int vhid = (cmd == SIOCAIFADDR) ? ifra->ifra_vhid : 0; 460a68cc388SGleb Smirnoff struct epoch_tracker et; 461f7a39160SGleb Smirnoff struct ifaddr *ifa; 462f7a39160SGleb Smirnoff struct in_ifaddr *ia; 463f7a39160SGleb Smirnoff bool iaIsFirst; 464f7a39160SGleb Smirnoff int error = 0; 465f7a39160SGleb Smirnoff 466f375bf0eSAlexander V. Chernikov error = priv_check_cred(cred, PRIV_NET_ADDIFADDR); 467f7a39160SGleb Smirnoff if (error) 468f7a39160SGleb Smirnoff return (error); 469f7a39160SGleb Smirnoff 470f7a39160SGleb Smirnoff /* 471f7a39160SGleb Smirnoff * ifra_addr must be present and be of INET family. 472f7a39160SGleb Smirnoff * ifra_broadaddr/ifra_dstaddr and ifra_mask are optional. 473f7a39160SGleb Smirnoff */ 474f7a39160SGleb Smirnoff if (addr->sin_len != sizeof(struct sockaddr_in) || 475f7a39160SGleb Smirnoff addr->sin_family != AF_INET) 476f7a39160SGleb Smirnoff return (EINVAL); 477f7a39160SGleb Smirnoff if (broadaddr->sin_len != 0 && 478f7a39160SGleb Smirnoff (broadaddr->sin_len != sizeof(struct sockaddr_in) || 479f7a39160SGleb Smirnoff broadaddr->sin_family != AF_INET)) 480f7a39160SGleb Smirnoff return (EINVAL); 481f7a39160SGleb Smirnoff if (mask->sin_len != 0 && 482f7a39160SGleb Smirnoff (mask->sin_len != sizeof(struct sockaddr_in) || 483f7a39160SGleb Smirnoff mask->sin_family != AF_INET)) 484f7a39160SGleb Smirnoff return (EINVAL); 485f7a39160SGleb Smirnoff if ((ifp->if_flags & IFF_POINTOPOINT) && 486f7a39160SGleb Smirnoff (dstaddr->sin_len != sizeof(struct sockaddr_in) || 487f7a39160SGleb Smirnoff dstaddr->sin_addr.s_addr == INADDR_ANY)) 488f7a39160SGleb Smirnoff return (EDESTADDRREQ); 489620cf65cSArtem Khramov if (vhid != 0 && carp_attach_p == NULL) 490f7a39160SGleb Smirnoff return (EPROTONOSUPPORT); 491f7a39160SGleb Smirnoff 492215bab79SShivank Garg #ifdef MAC 493215bab79SShivank Garg /* Check if a MAC policy disallows setting the IPv4 address. */ 494215bab79SShivank Garg error = mac_inet_check_add_addr(cred, &addr->sin_addr, ifp); 495215bab79SShivank Garg if (error != 0) 496215bab79SShivank Garg return (error); 497215bab79SShivank Garg #endif 498215bab79SShivank Garg 499f7a39160SGleb Smirnoff /* 500f7a39160SGleb Smirnoff * See whether address already exist. 501f7a39160SGleb Smirnoff */ 502f7a39160SGleb Smirnoff iaIsFirst = true; 503f7a39160SGleb Smirnoff ia = NULL; 504a68cc388SGleb Smirnoff NET_EPOCH_ENTER(et); 505d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 5069706c950SGleb Smirnoff struct in_ifaddr *it; 507f7a39160SGleb Smirnoff 5089706c950SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 509f7a39160SGleb Smirnoff continue; 510f7a39160SGleb Smirnoff 5119706c950SGleb Smirnoff it = (struct in_ifaddr *)ifa; 512f7a39160SGleb Smirnoff if (it->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr && 513f375bf0eSAlexander V. Chernikov prison_check_ip4(cred, &addr->sin_addr) == 0) 514f7a39160SGleb Smirnoff ia = it; 5153f740d43SAndrey V. Elsukov else 5163f740d43SAndrey V. Elsukov iaIsFirst = false; 5171067217dSGarrett Wollman } 518a68cc388SGleb Smirnoff NET_EPOCH_EXIT(et); 519f7a39160SGleb Smirnoff 520f7a39160SGleb Smirnoff if (ia != NULL) 521f375bf0eSAlexander V. Chernikov (void )in_difaddr_ioctl(cmd, data, ifp, cred); 522f7a39160SGleb Smirnoff 52346758960SGleb Smirnoff ifa = ifa_alloc(sizeof(struct in_ifaddr), M_WAITOK); 52446758960SGleb Smirnoff ia = (struct in_ifaddr *)ifa; 52559562606SGarrett Wollman ifa->ifa_addr = (struct sockaddr *)&ia->ia_addr; 52659562606SGarrett Wollman ifa->ifa_dstaddr = (struct sockaddr *)&ia->ia_dstaddr; 52759562606SGarrett Wollman ifa->ifa_netmask = (struct sockaddr *)&ia->ia_sockmask; 5282d9db0bcSEric van Gyzen callout_init_rw(&ia->ia_garp_timer, &ifp->if_addr_lock, 5292d9db0bcSEric van Gyzen CALLOUT_RETURNUNLOCKED); 53019fc74fbSJeffrey Hsu 531f7a39160SGleb Smirnoff ia->ia_ifp = ifp; 532f7a39160SGleb Smirnoff ia->ia_addr = *addr; 533f7a39160SGleb Smirnoff if (mask->sin_len != 0) { 534f7a39160SGleb Smirnoff ia->ia_sockmask = *mask; 535f7a39160SGleb Smirnoff ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr); 536f7a39160SGleb Smirnoff } else { 5372f35e7d9SMike Karels in_addr_t i = ntohl(addr->sin_addr.s_addr); 5382f35e7d9SMike Karels 539f7a39160SGleb Smirnoff /* 5402f35e7d9SMike Karels * If netmask isn't supplied, use historical default. 54120d59403SMike Karels * This is deprecated for interfaces other than loopback 54220d59403SMike Karels * or point-to-point; warn in other cases. In the future 54320d59403SMike Karels * we should return an error rather than warning. 544f7a39160SGleb Smirnoff */ 54520d59403SMike Karels if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) == 0) 54620d59403SMike Karels printf("%s: set address: WARNING: network mask " 5472f35e7d9SMike Karels "should be specified; using historical default\n", 54820d59403SMike Karels ifp->if_xname); 5492f35e7d9SMike Karels if (IN_CLASSA(i)) 5502f35e7d9SMike Karels ia->ia_subnetmask = IN_CLASSA_NET; 5512f35e7d9SMike Karels else if (IN_CLASSB(i)) 5522f35e7d9SMike Karels ia->ia_subnetmask = IN_CLASSB_NET; 5532f35e7d9SMike Karels else 5542f35e7d9SMike Karels ia->ia_subnetmask = IN_CLASSC_NET; 555f7a39160SGleb Smirnoff ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask); 556f7a39160SGleb Smirnoff } 557f7a39160SGleb Smirnoff ia->ia_subnet = ntohl(addr->sin_addr.s_addr) & ia->ia_subnetmask; 558f7a39160SGleb Smirnoff in_socktrim(&ia->ia_sockmask); 559f7a39160SGleb Smirnoff 560df8bae1dSRodney W. Grimes if (ifp->if_flags & IFF_BROADCAST) { 561f7a39160SGleb Smirnoff if (broadaddr->sin_len != 0) { 562f7a39160SGleb Smirnoff ia->ia_broadaddr = *broadaddr; 563f7a39160SGleb Smirnoff } else if (ia->ia_subnetmask == IN_RFC3021_MASK) { 564f7a39160SGleb Smirnoff ia->ia_broadaddr.sin_addr.s_addr = INADDR_BROADCAST; 565f7a39160SGleb Smirnoff ia->ia_broadaddr.sin_len = sizeof(struct sockaddr_in); 566f7a39160SGleb Smirnoff ia->ia_broadaddr.sin_family = AF_INET; 567f7a39160SGleb Smirnoff } else { 568f7a39160SGleb Smirnoff ia->ia_broadaddr.sin_addr.s_addr = 569f7a39160SGleb Smirnoff htonl(ia->ia_subnet | ~ia->ia_subnetmask); 570f7a39160SGleb Smirnoff ia->ia_broadaddr.sin_len = sizeof(struct sockaddr_in); 571df8bae1dSRodney W. Grimes ia->ia_broadaddr.sin_family = AF_INET; 572df8bae1dSRodney W. Grimes } 573f7a39160SGleb Smirnoff } 574f7a39160SGleb Smirnoff 575f7a39160SGleb Smirnoff if (ifp->if_flags & IFF_POINTOPOINT) 576f7a39160SGleb Smirnoff ia->ia_dstaddr = *dstaddr; 577f7a39160SGleb Smirnoff 5785af464bbSSteven Hartland if (vhid != 0) { 5795af464bbSSteven Hartland error = (*carp_attach_p)(&ia->ia_ifa, vhid); 5805af464bbSSteven Hartland if (error) 5815af464bbSSteven Hartland return (error); 5825af464bbSSteven Hartland } 5835af464bbSSteven Hartland 584a49b317cSAlexander V. Chernikov /* if_addrhead is already referenced by ifa_alloc() */ 585137f91e8SJohn Baldwin IF_ADDR_WLOCK(ifp); 586d7c5a620SMatt Macy CK_STAILQ_INSERT_TAIL(&ifp->if_addrhead, ifa, ifa_link); 587137f91e8SJohn Baldwin IF_ADDR_WUNLOCK(ifp); 588f7a39160SGleb Smirnoff 5898c0fec80SRobert Watson ifa_ref(ifa); /* in_ifaddrhead */ 590c8ee75f2SGleb Smirnoff sx_assert(&in_control_sx, SA_XLOCKED); 591d7c5a620SMatt Macy CK_STAILQ_INSERT_TAIL(&V_in_ifaddrhead, ia, ia_link); 592c8ee75f2SGleb Smirnoff CK_LIST_INSERT_HEAD(INADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, 593c8ee75f2SGleb Smirnoff ia_hash); 594df8bae1dSRodney W. Grimes 595f7a39160SGleb Smirnoff /* 596f7a39160SGleb Smirnoff * Give the interface a chance to initialize 597f7a39160SGleb Smirnoff * if this is its first address, 598f7a39160SGleb Smirnoff * and to validate the address if necessary. 599f7a39160SGleb Smirnoff */ 600d34165f7SSteven Hartland if (ifp->if_ioctl != NULL) { 601f7a39160SGleb Smirnoff error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia); 602f7a39160SGleb Smirnoff if (error) 6035af464bbSSteven Hartland goto fail1; 604d34165f7SSteven Hartland } 605f7a39160SGleb Smirnoff 606f7a39160SGleb Smirnoff /* 607f7a39160SGleb Smirnoff * Add route for the network. 608f7a39160SGleb Smirnoff */ 609f7a39160SGleb Smirnoff if (vhid == 0) { 610130aebbaSAlexander V. Chernikov error = in_addprefix(ia); 611f7a39160SGleb Smirnoff if (error) 6125af464bbSSteven Hartland goto fail1; 613df8bae1dSRodney W. Grimes } 614df8bae1dSRodney W. Grimes 615588885f2SRobert Watson /* 616f7a39160SGleb Smirnoff * Add a loopback route to self. 617588885f2SRobert Watson */ 618130aebbaSAlexander V. Chernikov if (vhid == 0 && ia_need_loopback_route(ia)) { 619f7a39160SGleb Smirnoff struct in_ifaddr *eia; 620df8bae1dSRodney W. Grimes 621f7a39160SGleb Smirnoff eia = in_localip_more(ia); 622f7a39160SGleb Smirnoff 623f7a39160SGleb Smirnoff if (eia == NULL) { 624f7a39160SGleb Smirnoff error = ifa_add_loopback_route((struct ifaddr *)ia, 625f7a39160SGleb Smirnoff (struct sockaddr *)&ia->ia_addr); 626f7a39160SGleb Smirnoff if (error) 6275af464bbSSteven Hartland goto fail2; 628f7a39160SGleb Smirnoff } else 629f7a39160SGleb Smirnoff ifa_free(&eia->ia_ifa); 630588885f2SRobert Watson } 631df8bae1dSRodney W. Grimes 632f7a39160SGleb Smirnoff if (iaIsFirst && (ifp->if_flags & IFF_MULTICAST)) { 633f7a39160SGleb Smirnoff struct in_addr allhosts_addr; 634f7a39160SGleb Smirnoff struct in_ifinfo *ii; 635df8bae1dSRodney W. Grimes 636c75aa354SBruce M Simpson ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]); 637f7a39160SGleb Smirnoff allhosts_addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP); 638df8bae1dSRodney W. Grimes 639f7a39160SGleb Smirnoff error = in_joingroup(ifp, &allhosts_addr, NULL, 640f7a39160SGleb Smirnoff &ii->ii_allhosts); 641f7a39160SGleb Smirnoff } 642f7a39160SGleb Smirnoff 64364d63b1eSAndrey V. Elsukov /* 64464d63b1eSAndrey V. Elsukov * Note: we don't need extra reference for ifa, since we called 64564d63b1eSAndrey V. Elsukov * with sx lock held, and ifaddr can not be deleted in concurrent 64664d63b1eSAndrey V. Elsukov * thread. 64764d63b1eSAndrey V. Elsukov */ 64864d63b1eSAndrey V. Elsukov EVENTHANDLER_INVOKE(ifaddr_event_ext, ifp, ifa, IFADDR_EVENT_ADD); 649f7a39160SGleb Smirnoff 650f7a39160SGleb Smirnoff return (error); 651f7a39160SGleb Smirnoff 6525af464bbSSteven Hartland fail2: 653f7a39160SGleb Smirnoff if (vhid == 0) 654f7a39160SGleb Smirnoff (void )in_scrubprefix(ia, LLE_STATIC); 655f7a39160SGleb Smirnoff 6565af464bbSSteven Hartland fail1: 657f7a39160SGleb Smirnoff if (ia->ia_ifa.ifa_carp) 658338e227aSLuiz Otavio O Souza (*carp_detach_p)(&ia->ia_ifa, false); 659f7a39160SGleb Smirnoff 660f7a39160SGleb Smirnoff IF_ADDR_WLOCK(ifp); 661d7c5a620SMatt Macy CK_STAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifaddr, ifa_link); 662f7a39160SGleb Smirnoff IF_ADDR_WUNLOCK(ifp); 663a49b317cSAlexander V. Chernikov ifa_free(&ia->ia_ifa); /* if_addrhead */ 664f7a39160SGleb Smirnoff 665c8ee75f2SGleb Smirnoff sx_assert(&in_control_sx, SA_XLOCKED); 666d7c5a620SMatt Macy CK_STAILQ_REMOVE(&V_in_ifaddrhead, ia, in_ifaddr, ia_link); 667c8ee75f2SGleb Smirnoff CK_LIST_REMOVE(ia, ia_hash); 668a49b317cSAlexander V. Chernikov ifa_free(&ia->ia_ifa); /* in_ifaddrhead */ 669f7a39160SGleb Smirnoff 670f7a39160SGleb Smirnoff return (error); 671f7a39160SGleb Smirnoff } 672f7a39160SGleb Smirnoff 673f7a39160SGleb Smirnoff static int 674f375bf0eSAlexander V. Chernikov in_difaddr_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp, struct ucred *cred) 675f7a39160SGleb Smirnoff { 676f7a39160SGleb Smirnoff const struct ifreq *ifr = (struct ifreq *)data; 6776224cd89SNathan Whitehorn const struct sockaddr_in *addr = (const struct sockaddr_in *) 6786224cd89SNathan Whitehorn &ifr->ifr_addr; 679f7a39160SGleb Smirnoff struct ifaddr *ifa; 680f7a39160SGleb Smirnoff struct in_ifaddr *ia; 681f7a39160SGleb Smirnoff bool deleteAny, iaIsLast; 682f7a39160SGleb Smirnoff int error; 683f7a39160SGleb Smirnoff 684f375bf0eSAlexander V. Chernikov if (cred != NULL) { 685f375bf0eSAlexander V. Chernikov error = priv_check_cred(cred, PRIV_NET_DELIFADDR); 686f7a39160SGleb Smirnoff if (error) 687f7a39160SGleb Smirnoff return (error); 688f7a39160SGleb Smirnoff } 689f7a39160SGleb Smirnoff 690f7a39160SGleb Smirnoff if (addr->sin_len != sizeof(struct sockaddr_in) || 691f7a39160SGleb Smirnoff addr->sin_family != AF_INET) 692f7a39160SGleb Smirnoff deleteAny = true; 693f7a39160SGleb Smirnoff else 694f7a39160SGleb Smirnoff deleteAny = false; 695f7a39160SGleb Smirnoff 696f7a39160SGleb Smirnoff iaIsLast = true; 697f7a39160SGleb Smirnoff ia = NULL; 698f7a39160SGleb Smirnoff IF_ADDR_WLOCK(ifp); 699d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 7009706c950SGleb Smirnoff struct in_ifaddr *it; 701f7a39160SGleb Smirnoff 7029706c950SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 703f7a39160SGleb Smirnoff continue; 704f7a39160SGleb Smirnoff 7059706c950SGleb Smirnoff it = (struct in_ifaddr *)ifa; 706f375bf0eSAlexander V. Chernikov if (deleteAny && ia == NULL && (cred == NULL || 707f375bf0eSAlexander V. Chernikov prison_check_ip4(cred, &it->ia_addr.sin_addr) == 0)) 708f7a39160SGleb Smirnoff ia = it; 709f7a39160SGleb Smirnoff 710f7a39160SGleb Smirnoff if (it->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr && 711f375bf0eSAlexander V. Chernikov (cred == NULL || prison_check_ip4(cred, 712f7a39160SGleb Smirnoff &addr->sin_addr) == 0)) 713f7a39160SGleb Smirnoff ia = it; 714f7a39160SGleb Smirnoff 715f7a39160SGleb Smirnoff if (it != ia) 716f7a39160SGleb Smirnoff iaIsLast = false; 717f7a39160SGleb Smirnoff } 718f7a39160SGleb Smirnoff 719f7a39160SGleb Smirnoff if (ia == NULL) { 720f7a39160SGleb Smirnoff IF_ADDR_WUNLOCK(ifp); 721f7a39160SGleb Smirnoff return (EADDRNOTAVAIL); 722f7a39160SGleb Smirnoff } 723f7a39160SGleb Smirnoff 724d7c5a620SMatt Macy CK_STAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifaddr, ifa_link); 725f7a39160SGleb Smirnoff IF_ADDR_WUNLOCK(ifp); 726f7a39160SGleb Smirnoff ifa_free(&ia->ia_ifa); /* if_addrhead */ 727f7a39160SGleb Smirnoff 728c8ee75f2SGleb Smirnoff sx_assert(&in_control_sx, SA_XLOCKED); 729d7c5a620SMatt Macy CK_STAILQ_REMOVE(&V_in_ifaddrhead, ia, in_ifaddr, ia_link); 730c8ee75f2SGleb Smirnoff CK_LIST_REMOVE(ia, ia_hash); 731f7a39160SGleb Smirnoff 732089cdfadSRuslan Ermilov /* 733237bf7f7SGleb Smirnoff * in_scrubprefix() kills the interface route. 734089cdfadSRuslan Ermilov */ 735237bf7f7SGleb Smirnoff in_scrubprefix(ia, LLE_STATIC); 736588885f2SRobert Watson 737c655b7c4SDavid Greenman /* 738089cdfadSRuslan Ermilov * in_ifadown gets rid of all the rest of 739089cdfadSRuslan Ermilov * the routes. This is not quite the right 740089cdfadSRuslan Ermilov * thing to do, but at least if we are running 741089cdfadSRuslan Ermilov * a routing process they will come back. 742089cdfadSRuslan Ermilov */ 74391854268SRuslan Ermilov in_ifadown(&ia->ia_ifa, 1); 7440f02fdacSBrian Somers 74508b68b0eSGleb Smirnoff if (ia->ia_ifa.ifa_carp) 74659b2022fSLuiz Otavio O Souza (*carp_detach_p)(&ia->ia_ifa, cmd == SIOCAIFADDR); 74708b68b0eSGleb Smirnoff 748f7e083afSBruce M Simpson /* 749f7e083afSBruce M Simpson * If this is the last IPv4 address configured on this 750f7e083afSBruce M Simpson * interface, leave the all-hosts group. 751d10910e6SBruce M Simpson * No state-change report need be transmitted. 752f7e083afSBruce M Simpson */ 753f7a39160SGleb Smirnoff if (iaIsLast && (ifp->if_flags & IFF_MULTICAST)) { 754f7a39160SGleb Smirnoff struct in_ifinfo *ii; 755f7a39160SGleb Smirnoff 756c75aa354SBruce M Simpson ii = ((struct in_ifinfo *)ifp->if_afdata[AF_INET]); 757d10910e6SBruce M Simpson if (ii->ii_allhosts) { 758f3e1324bSStephen Hurd (void)in_leavegroup(ii->ii_allhosts, NULL); 759d10910e6SBruce M Simpson ii->ii_allhosts = NULL; 760d10910e6SBruce M Simpson } 761f7a39160SGleb Smirnoff } 7626d00fd9cSGleb Smirnoff 7632d9db0bcSEric van Gyzen IF_ADDR_WLOCK(ifp); 7642d9db0bcSEric van Gyzen if (callout_stop(&ia->ia_garp_timer) == 1) { 7652d9db0bcSEric van Gyzen ifa_free(&ia->ia_ifa); 7662d9db0bcSEric van Gyzen } 7672d9db0bcSEric van Gyzen IF_ADDR_WUNLOCK(ifp); 7682d9db0bcSEric van Gyzen 76964d63b1eSAndrey V. Elsukov EVENTHANDLER_INVOKE(ifaddr_event_ext, ifp, &ia->ia_ifa, 77064d63b1eSAndrey V. Elsukov IFADDR_EVENT_DEL); 771a49b317cSAlexander V. Chernikov ifa_free(&ia->ia_ifa); /* in_ifaddrhead */ 772f7a39160SGleb Smirnoff 773f7a39160SGleb Smirnoff return (0); 774df8bae1dSRodney W. Grimes } 775df8bae1dSRodney W. Grimes 7766952c3e1SAndrey V. Elsukov static int 777f375bf0eSAlexander V. Chernikov in_gifaddr_ioctl(u_long cmd, caddr_t data, struct ifnet *ifp, struct ucred *cred) 7786952c3e1SAndrey V. Elsukov { 7796952c3e1SAndrey V. Elsukov struct in_aliasreq *ifra = (struct in_aliasreq *)data; 7806952c3e1SAndrey V. Elsukov const struct sockaddr_in *addr = &ifra->ifra_addr; 7816952c3e1SAndrey V. Elsukov struct epoch_tracker et; 7826952c3e1SAndrey V. Elsukov struct ifaddr *ifa; 7836952c3e1SAndrey V. Elsukov struct in_ifaddr *ia; 7846952c3e1SAndrey V. Elsukov 7856952c3e1SAndrey V. Elsukov /* 7866952c3e1SAndrey V. Elsukov * ifra_addr must be present and be of INET family. 7876952c3e1SAndrey V. Elsukov */ 7886952c3e1SAndrey V. Elsukov if (addr->sin_len != sizeof(struct sockaddr_in) || 7896952c3e1SAndrey V. Elsukov addr->sin_family != AF_INET) 7906952c3e1SAndrey V. Elsukov return (EINVAL); 7916952c3e1SAndrey V. Elsukov 7926952c3e1SAndrey V. Elsukov /* 7936952c3e1SAndrey V. Elsukov * See whether address exist. 7946952c3e1SAndrey V. Elsukov */ 7956952c3e1SAndrey V. Elsukov ia = NULL; 7966952c3e1SAndrey V. Elsukov NET_EPOCH_ENTER(et); 7976952c3e1SAndrey V. Elsukov CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 7986952c3e1SAndrey V. Elsukov struct in_ifaddr *it; 7996952c3e1SAndrey V. Elsukov 8006952c3e1SAndrey V. Elsukov if (ifa->ifa_addr->sa_family != AF_INET) 8016952c3e1SAndrey V. Elsukov continue; 8026952c3e1SAndrey V. Elsukov 8036952c3e1SAndrey V. Elsukov it = (struct in_ifaddr *)ifa; 8046952c3e1SAndrey V. Elsukov if (it->ia_addr.sin_addr.s_addr == addr->sin_addr.s_addr && 805f375bf0eSAlexander V. Chernikov prison_check_ip4(cred, &addr->sin_addr) == 0) { 8066952c3e1SAndrey V. Elsukov ia = it; 8076952c3e1SAndrey V. Elsukov break; 8086952c3e1SAndrey V. Elsukov } 8096952c3e1SAndrey V. Elsukov } 8106952c3e1SAndrey V. Elsukov if (ia == NULL) { 8116952c3e1SAndrey V. Elsukov NET_EPOCH_EXIT(et); 8126952c3e1SAndrey V. Elsukov return (EADDRNOTAVAIL); 8136952c3e1SAndrey V. Elsukov } 8146952c3e1SAndrey V. Elsukov 8156952c3e1SAndrey V. Elsukov ifra->ifra_mask = ia->ia_sockmask; 8166952c3e1SAndrey V. Elsukov if ((ifp->if_flags & IFF_POINTOPOINT) && 8176952c3e1SAndrey V. Elsukov ia->ia_dstaddr.sin_family == AF_INET) 8186952c3e1SAndrey V. Elsukov ifra->ifra_dstaddr = ia->ia_dstaddr; 8196952c3e1SAndrey V. Elsukov else if ((ifp->if_flags & IFF_BROADCAST) && 8206952c3e1SAndrey V. Elsukov ia->ia_broadaddr.sin_family == AF_INET) 8216952c3e1SAndrey V. Elsukov ifra->ifra_broadaddr = ia->ia_broadaddr; 8226952c3e1SAndrey V. Elsukov else 8236952c3e1SAndrey V. Elsukov memset(&ifra->ifra_broadaddr, 0, 8246952c3e1SAndrey V. Elsukov sizeof(ifra->ifra_broadaddr)); 8256952c3e1SAndrey V. Elsukov 8266952c3e1SAndrey V. Elsukov NET_EPOCH_EXIT(et); 8276952c3e1SAndrey V. Elsukov return (0); 8286952c3e1SAndrey V. Elsukov } 8296952c3e1SAndrey V. Elsukov 83081728a53SAlexander V. Chernikov static int 83181728a53SAlexander V. Chernikov in_match_ifaddr(const struct rtentry *rt, const struct nhop_object *nh, void *arg) 83281728a53SAlexander V. Chernikov { 83381728a53SAlexander V. Chernikov 83481728a53SAlexander V. Chernikov if (nh->nh_ifa == (struct ifaddr *)arg) 83581728a53SAlexander V. Chernikov return (1); 83681728a53SAlexander V. Chernikov 83781728a53SAlexander V. Chernikov return (0); 83881728a53SAlexander V. Chernikov } 83981728a53SAlexander V. Chernikov 84081728a53SAlexander V. Chernikov static int 8417b3440fcSAlexander V. Chernikov in_handle_prefix_route(uint32_t fibnum, int cmd, 8427b3440fcSAlexander V. Chernikov struct sockaddr_in *dst, struct sockaddr_in *netmask, struct ifaddr *ifa, 8437b3440fcSAlexander V. Chernikov struct ifnet *ifp) 84481728a53SAlexander V. Chernikov { 84581728a53SAlexander V. Chernikov 84681728a53SAlexander V. Chernikov NET_EPOCH_ASSERT(); 84781728a53SAlexander V. Chernikov 8487b3440fcSAlexander V. Chernikov /* Prepare gateway */ 8497b3440fcSAlexander V. Chernikov struct sockaddr_dl_short sdl = { 8507b3440fcSAlexander V. Chernikov .sdl_family = AF_LINK, 8517b3440fcSAlexander V. Chernikov .sdl_len = sizeof(struct sockaddr_dl_short), 8527b3440fcSAlexander V. Chernikov .sdl_type = ifa->ifa_ifp->if_type, 8537b3440fcSAlexander V. Chernikov .sdl_index = ifa->ifa_ifp->if_index, 8547b3440fcSAlexander V. Chernikov }; 85581728a53SAlexander V. Chernikov 8567b3440fcSAlexander V. Chernikov struct rt_addrinfo info = { 8577b3440fcSAlexander V. Chernikov .rti_ifa = ifa, 8587b3440fcSAlexander V. Chernikov .rti_ifp = ifp, 8597b3440fcSAlexander V. Chernikov .rti_flags = RTF_PINNED | ((netmask != NULL) ? 0 : RTF_HOST), 8607b3440fcSAlexander V. Chernikov .rti_info = { 8617b3440fcSAlexander V. Chernikov [RTAX_DST] = (struct sockaddr *)dst, 8627b3440fcSAlexander V. Chernikov [RTAX_NETMASK] = (struct sockaddr *)netmask, 8637b3440fcSAlexander V. Chernikov [RTAX_GATEWAY] = (struct sockaddr *)&sdl, 8647b3440fcSAlexander V. Chernikov }, 8657b3440fcSAlexander V. Chernikov /* Ensure we delete the prefix IFF prefix ifa matches */ 8667b3440fcSAlexander V. Chernikov .rti_filter = in_match_ifaddr, 8677b3440fcSAlexander V. Chernikov .rti_filterdata = ifa, 8687b3440fcSAlexander V. Chernikov }; 8697b3440fcSAlexander V. Chernikov 8707b3440fcSAlexander V. Chernikov return (rib_handle_ifaddr_info(fibnum, cmd, &info)); 87181728a53SAlexander V. Chernikov } 87281728a53SAlexander V. Chernikov 87381728a53SAlexander V. Chernikov /* 874130aebbaSAlexander V. Chernikov * Routing table interaction with interface addresses. 875130aebbaSAlexander V. Chernikov * 876130aebbaSAlexander V. Chernikov * In general, two types of routes needs to be installed: 877130aebbaSAlexander V. Chernikov * a) "interface" or "prefix" route, telling user that the addresses 878130aebbaSAlexander V. Chernikov * behind the ifa prefix are reached directly. 879130aebbaSAlexander V. Chernikov * b) "loopback" route installed for the ifa address, telling user that 880130aebbaSAlexander V. Chernikov * the address belongs to local system. 881130aebbaSAlexander V. Chernikov * 882130aebbaSAlexander V. Chernikov * Handling for (a) and (b) differs in multi-fib aspects, hence they 883130aebbaSAlexander V. Chernikov * are implemented in different functions below. 884130aebbaSAlexander V. Chernikov * 885130aebbaSAlexander V. Chernikov * The cases above may intersect - /32 interface aliases results in 886130aebbaSAlexander V. Chernikov * the same prefix produced by (a) and (b). This blurs the definition 887130aebbaSAlexander V. Chernikov * of the "loopback" route and complicate interactions. The interaction 888130aebbaSAlexander V. Chernikov * table is defined below. The case numbers are used in the multiple 889130aebbaSAlexander V. Chernikov * functions below to refer to the particular test case. 890130aebbaSAlexander V. Chernikov * 89181728a53SAlexander V. Chernikov * There can be multiple options: 892130aebbaSAlexander V. Chernikov * 1) Adding address with prefix on non-p2p/non-loopback interface. 893130aebbaSAlexander V. Chernikov * Example: 192.0.2.1/24. Action: 894130aebbaSAlexander V. Chernikov * * add "prefix" route towards 192.0.2.0/24 via @ia interface, 895130aebbaSAlexander V. Chernikov * using @ia as an address source. 896130aebbaSAlexander V. Chernikov * * add "loopback" route towards 192.0.2.1 via V_loif, saving 897130aebbaSAlexander V. Chernikov * @ia ifp in the gateway and using @ia as an address source. 898130aebbaSAlexander V. Chernikov * 899130aebbaSAlexander V. Chernikov * 2) Adding address with /32 mask to non-p2p/non-loopback interface. 900130aebbaSAlexander V. Chernikov * Example: 192.0.2.2/32. Action: 901130aebbaSAlexander V. Chernikov * * add "prefix" host route via V_loif, using @ia as an address source. 902130aebbaSAlexander V. Chernikov * 90381728a53SAlexander V. Chernikov * 3) Adding address with or without prefix to p2p interface. 904130aebbaSAlexander V. Chernikov * Example: 10.0.0.1/24->10.0.0.2. Action: 905130aebbaSAlexander V. Chernikov * * add "prefix" host route towards 10.0.0.2 via this interface, using @ia 906130aebbaSAlexander V. Chernikov * as an address source. Note: no sense in installing full /24 as the interface 907130aebbaSAlexander V. Chernikov * is point-to-point. 908130aebbaSAlexander V. Chernikov * * add "loopback" route towards 10.0.9.1 via V_loif, saving 909130aebbaSAlexander V. Chernikov * @ia ifp in the gateway and using @ia as an address source. 910130aebbaSAlexander V. Chernikov * 91181728a53SAlexander V. Chernikov * 4) Adding address with or without prefix to loopback interface. 912130aebbaSAlexander V. Chernikov * Example: 192.0.2.1/24. Action: 913130aebbaSAlexander V. Chernikov * * add "prefix" host route via @ia interface, using @ia as an address source. 914130aebbaSAlexander V. Chernikov * Note: Skip installing /24 prefix as it would introduce TTL loop 915130aebbaSAlexander V. Chernikov * for the traffic destined to these addresses. 916130aebbaSAlexander V. Chernikov */ 917130aebbaSAlexander V. Chernikov 918130aebbaSAlexander V. Chernikov /* 919130aebbaSAlexander V. Chernikov * Checks if @ia needs to install loopback route to @ia address via 920130aebbaSAlexander V. Chernikov * ifa_maintain_loopback_route(). 921130aebbaSAlexander V. Chernikov * 922130aebbaSAlexander V. Chernikov * Return true on success. 923130aebbaSAlexander V. Chernikov */ 924130aebbaSAlexander V. Chernikov static bool 925130aebbaSAlexander V. Chernikov ia_need_loopback_route(const struct in_ifaddr *ia) 926130aebbaSAlexander V. Chernikov { 927130aebbaSAlexander V. Chernikov struct ifnet *ifp = ia->ia_ifp; 928130aebbaSAlexander V. Chernikov 929130aebbaSAlexander V. Chernikov /* Case 4: Skip loopback interfaces */ 930130aebbaSAlexander V. Chernikov if ((ifp->if_flags & IFF_LOOPBACK) || 931130aebbaSAlexander V. Chernikov (ia->ia_addr.sin_addr.s_addr == INADDR_ANY)) 932130aebbaSAlexander V. Chernikov return (false); 933130aebbaSAlexander V. Chernikov 934130aebbaSAlexander V. Chernikov /* Clash avoidance: Skip p2p interfaces with both addresses are equal */ 935130aebbaSAlexander V. Chernikov if ((ifp->if_flags & IFF_POINTOPOINT) && 936130aebbaSAlexander V. Chernikov ia->ia_dstaddr.sin_addr.s_addr == ia->ia_addr.sin_addr.s_addr) 937130aebbaSAlexander V. Chernikov return (false); 938130aebbaSAlexander V. Chernikov 939130aebbaSAlexander V. Chernikov /* Case 2: skip /32 prefixes */ 940130aebbaSAlexander V. Chernikov if (!(ifp->if_flags & IFF_POINTOPOINT) && 941130aebbaSAlexander V. Chernikov (ia->ia_sockmask.sin_addr.s_addr == INADDR_BROADCAST)) 942130aebbaSAlexander V. Chernikov return (false); 943130aebbaSAlexander V. Chernikov 944130aebbaSAlexander V. Chernikov return (true); 945130aebbaSAlexander V. Chernikov } 946130aebbaSAlexander V. Chernikov 947130aebbaSAlexander V. Chernikov /* 948130aebbaSAlexander V. Chernikov * Calculate "prefix" route corresponding to @ia. 949130aebbaSAlexander V. Chernikov */ 950130aebbaSAlexander V. Chernikov static void 951130aebbaSAlexander V. Chernikov ia_getrtprefix(const struct in_ifaddr *ia, struct in_addr *prefix, struct in_addr *mask) 952130aebbaSAlexander V. Chernikov { 953130aebbaSAlexander V. Chernikov 954130aebbaSAlexander V. Chernikov if (ia->ia_ifp->if_flags & IFF_POINTOPOINT) { 955130aebbaSAlexander V. Chernikov /* Case 3: return host route for dstaddr */ 956130aebbaSAlexander V. Chernikov *prefix = ia->ia_dstaddr.sin_addr; 957130aebbaSAlexander V. Chernikov mask->s_addr = INADDR_BROADCAST; 958130aebbaSAlexander V. Chernikov } else if (ia->ia_ifp->if_flags & IFF_LOOPBACK) { 959130aebbaSAlexander V. Chernikov /* Case 4: return host route for ifaddr */ 960130aebbaSAlexander V. Chernikov *prefix = ia->ia_addr.sin_addr; 961130aebbaSAlexander V. Chernikov mask->s_addr = INADDR_BROADCAST; 962130aebbaSAlexander V. Chernikov } else { 963130aebbaSAlexander V. Chernikov /* Cases 1,2: return actual ia prefix */ 964130aebbaSAlexander V. Chernikov *prefix = ia->ia_addr.sin_addr; 965130aebbaSAlexander V. Chernikov *mask = ia->ia_sockmask.sin_addr; 966130aebbaSAlexander V. Chernikov prefix->s_addr &= mask->s_addr; 967130aebbaSAlexander V. Chernikov } 968130aebbaSAlexander V. Chernikov } 969130aebbaSAlexander V. Chernikov 970130aebbaSAlexander V. Chernikov /* 971130aebbaSAlexander V. Chernikov * Adds or delete interface "prefix" route corresponding to @ifa. 972130aebbaSAlexander V. Chernikov * Returns 0 on success or errno. 97381728a53SAlexander V. Chernikov */ 974b8103ca7SGleb Smirnoff static int 97581728a53SAlexander V. Chernikov in_handle_ifaddr_route(int cmd, struct in_ifaddr *ia) 97681728a53SAlexander V. Chernikov { 97781728a53SAlexander V. Chernikov struct ifaddr *ifa = &ia->ia_ifa; 97881728a53SAlexander V. Chernikov struct in_addr daddr, maddr; 9797b3440fcSAlexander V. Chernikov struct sockaddr_in *pmask; 98081728a53SAlexander V. Chernikov struct epoch_tracker et; 98181728a53SAlexander V. Chernikov int error; 98281728a53SAlexander V. Chernikov 983130aebbaSAlexander V. Chernikov ia_getrtprefix(ia, &daddr, &maddr); 98481728a53SAlexander V. Chernikov 9857b3440fcSAlexander V. Chernikov struct sockaddr_in mask = { 9867b3440fcSAlexander V. Chernikov .sin_family = AF_INET, 9877b3440fcSAlexander V. Chernikov .sin_len = sizeof(struct sockaddr_in), 9887b3440fcSAlexander V. Chernikov .sin_addr = maddr, 9897b3440fcSAlexander V. Chernikov }; 9907b3440fcSAlexander V. Chernikov 9917b3440fcSAlexander V. Chernikov pmask = (maddr.s_addr != INADDR_BROADCAST) ? &mask : NULL; 99281728a53SAlexander V. Chernikov 99381728a53SAlexander V. Chernikov struct sockaddr_in dst = { 99481728a53SAlexander V. Chernikov .sin_family = AF_INET, 99581728a53SAlexander V. Chernikov .sin_len = sizeof(struct sockaddr_in), 99681728a53SAlexander V. Chernikov .sin_addr.s_addr = daddr.s_addr & maddr.s_addr, 99781728a53SAlexander V. Chernikov }; 99881728a53SAlexander V. Chernikov 999130aebbaSAlexander V. Chernikov struct ifnet *ifp = ia->ia_ifp; 1000130aebbaSAlexander V. Chernikov 1001130aebbaSAlexander V. Chernikov if ((maddr.s_addr == INADDR_BROADCAST) && 1002130aebbaSAlexander V. Chernikov (!(ia->ia_ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)))) { 1003130aebbaSAlexander V. Chernikov /* Case 2: host route on broadcast interface */ 1004130aebbaSAlexander V. Chernikov ifp = V_loif; 1005130aebbaSAlexander V. Chernikov } 1006130aebbaSAlexander V. Chernikov 100781728a53SAlexander V. Chernikov uint32_t fibnum = ifa->ifa_ifp->if_fib; 100881728a53SAlexander V. Chernikov NET_EPOCH_ENTER(et); 10097b3440fcSAlexander V. Chernikov error = in_handle_prefix_route(fibnum, cmd, &dst, pmask, ifa, ifp); 101081728a53SAlexander V. Chernikov NET_EPOCH_EXIT(et); 101181728a53SAlexander V. Chernikov 101281728a53SAlexander V. Chernikov return (error); 101381728a53SAlexander V. Chernikov } 101481728a53SAlexander V. Chernikov 1015ccbb9c35SQing Li /* 1016d68cf57bSAlexander V. Chernikov * Check if we have a route for the given prefix already. 101748321abeSMax Laier */ 1018d68cf57bSAlexander V. Chernikov static bool 1019130aebbaSAlexander V. Chernikov in_hasrtprefix(struct in_ifaddr *target) 102048321abeSMax Laier { 10212144431cSGleb Smirnoff struct epoch_tracker et; 102248321abeSMax Laier struct in_ifaddr *ia; 1023bfb26eecSGleb Smirnoff struct in_addr prefix, mask, p, m; 1024d68cf57bSAlexander V. Chernikov bool result = false; 102548321abeSMax Laier 1026130aebbaSAlexander V. Chernikov ia_getrtprefix(target, &prefix, &mask); 102748321abeSMax Laier 10280cfee0c2SAlan Somers /* Look for an existing address with the same prefix, mask, and fib */ 10292144431cSGleb Smirnoff NET_EPOCH_ENTER(et); 1030d7c5a620SMatt Macy CK_STAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) { 1031130aebbaSAlexander V. Chernikov ia_getrtprefix(ia, &p, &m); 1032bfb26eecSGleb Smirnoff 1033bfb26eecSGleb Smirnoff if (prefix.s_addr != p.s_addr || 1034bfb26eecSGleb Smirnoff mask.s_addr != m.s_addr) 1035bfb26eecSGleb Smirnoff continue; 1036130aebbaSAlexander V. Chernikov 10370cfee0c2SAlan Somers if (target->ia_ifp->if_fib != ia->ia_ifp->if_fib) 10380cfee0c2SAlan Somers continue; 103948321abeSMax Laier 104048321abeSMax Laier /* 104148321abeSMax Laier * If we got a matching prefix route inserted by other 104248321abeSMax Laier * interface address, we are done here. 104348321abeSMax Laier */ 10441ae95409SGleb Smirnoff if (ia->ia_flags & IFA_ROUTE) { 1045d68cf57bSAlexander V. Chernikov result = true; 1046d68cf57bSAlexander V. Chernikov break; 1047d68cf57bSAlexander V. Chernikov } 1048d68cf57bSAlexander V. Chernikov } 10492144431cSGleb Smirnoff NET_EPOCH_EXIT(et); 10500cfee0c2SAlan Somers 1051d68cf57bSAlexander V. Chernikov return (result); 1052d68cf57bSAlexander V. Chernikov } 1053d68cf57bSAlexander V. Chernikov 1054d68cf57bSAlexander V. Chernikov int 1055130aebbaSAlexander V. Chernikov in_addprefix(struct in_ifaddr *target) 1056d68cf57bSAlexander V. Chernikov { 1057d68cf57bSAlexander V. Chernikov int error; 1058d68cf57bSAlexander V. Chernikov 1059130aebbaSAlexander V. Chernikov if (in_hasrtprefix(target)) { 1060d68cf57bSAlexander V. Chernikov if (V_nosameprefix) 1061d68cf57bSAlexander V. Chernikov return (EEXIST); 1062d68cf57bSAlexander V. Chernikov else { 1063d68cf57bSAlexander V. Chernikov rt_addrmsg(RTM_ADD, &target->ia_ifa, 1064d68cf57bSAlexander V. Chernikov target->ia_ifp->if_fib); 10651ae95409SGleb Smirnoff return (0); 10661ae95409SGleb Smirnoff } 106748321abeSMax Laier } 106848321abeSMax Laier 106948321abeSMax Laier /* 107048321abeSMax Laier * No-one seem to have this prefix route, so we try to insert it. 107148321abeSMax Laier */ 107281728a53SAlexander V. Chernikov rt_addrmsg(RTM_ADD, &target->ia_ifa, target->ia_ifp->if_fib); 107381728a53SAlexander V. Chernikov error = in_handle_ifaddr_route(RTM_ADD, target); 107448321abeSMax Laier if (!error) 107548321abeSMax Laier target->ia_flags |= IFA_ROUTE; 1076460473a0SBjoern A. Zeeb return (error); 107748321abeSMax Laier } 107848321abeSMax Laier 107948321abeSMax Laier /* 10803e7a2321SAlexander V. Chernikov * Removes either all lle entries for given @ia, or lle 10813e7a2321SAlexander V. Chernikov * corresponding to @ia address. 10823e7a2321SAlexander V. Chernikov */ 10833e7a2321SAlexander V. Chernikov static void 10843e7a2321SAlexander V. Chernikov in_scrubprefixlle(struct in_ifaddr *ia, int all, u_int flags) 10853e7a2321SAlexander V. Chernikov { 10863e7a2321SAlexander V. Chernikov struct sockaddr_in addr, mask; 10873e7a2321SAlexander V. Chernikov struct sockaddr *saddr, *smask; 10883e7a2321SAlexander V. Chernikov struct ifnet *ifp; 10893e7a2321SAlexander V. Chernikov 10903e7a2321SAlexander V. Chernikov saddr = (struct sockaddr *)&addr; 10913e7a2321SAlexander V. Chernikov bzero(&addr, sizeof(addr)); 10923e7a2321SAlexander V. Chernikov addr.sin_len = sizeof(addr); 10933e7a2321SAlexander V. Chernikov addr.sin_family = AF_INET; 10943e7a2321SAlexander V. Chernikov smask = (struct sockaddr *)&mask; 10953e7a2321SAlexander V. Chernikov bzero(&mask, sizeof(mask)); 10963e7a2321SAlexander V. Chernikov mask.sin_len = sizeof(mask); 10973e7a2321SAlexander V. Chernikov mask.sin_family = AF_INET; 10983e7a2321SAlexander V. Chernikov mask.sin_addr.s_addr = ia->ia_subnetmask; 10993e7a2321SAlexander V. Chernikov ifp = ia->ia_ifp; 11003e7a2321SAlexander V. Chernikov 110126a60575SAlexander V. Chernikov if (all) { 110226a60575SAlexander V. Chernikov /* 110326a60575SAlexander V. Chernikov * Remove all L2 entries matching given prefix. 110426a60575SAlexander V. Chernikov * Convert address to host representation to avoid 110526a60575SAlexander V. Chernikov * doing this on every callback. ia_subnetmask is already 110626a60575SAlexander V. Chernikov * stored in host representation. 110726a60575SAlexander V. Chernikov */ 110826a60575SAlexander V. Chernikov addr.sin_addr.s_addr = ntohl(ia->ia_addr.sin_addr.s_addr); 11093e7a2321SAlexander V. Chernikov lltable_prefix_free(AF_INET, saddr, smask, flags); 111026a60575SAlexander V. Chernikov } else { 111126a60575SAlexander V. Chernikov /* Remove interface address only */ 111226a60575SAlexander V. Chernikov addr.sin_addr.s_addr = ia->ia_addr.sin_addr.s_addr; 11133e7a2321SAlexander V. Chernikov lltable_delete_addr(LLTABLE(ifp), LLE_IFADDR, saddr); 11143e7a2321SAlexander V. Chernikov } 111526a60575SAlexander V. Chernikov } 11163e7a2321SAlexander V. Chernikov 11173e7a2321SAlexander V. Chernikov /* 111848321abeSMax Laier * If there is no other address in the system that can serve a route to the 111948321abeSMax Laier * same prefix, remove the route. Hand over the route to the new address 112048321abeSMax Laier * otherwise. 112148321abeSMax Laier */ 112208b68b0eSGleb Smirnoff int 11235b84dc78SQing Li in_scrubprefix(struct in_ifaddr *target, u_int flags) 112448321abeSMax Laier { 11252144431cSGleb Smirnoff struct epoch_tracker et; 112648321abeSMax Laier struct in_ifaddr *ia; 112755174c34SGleb Smirnoff struct in_addr prefix, mask, p, m; 11287278b62aSAlan Somers int error = 0; 112948321abeSMax Laier 1130df813b7eSQing Li /* 1131df813b7eSQing Li * Remove the loopback route to the interface address. 1132df813b7eSQing Li */ 1133130aebbaSAlexander V. Chernikov if (ia_need_loopback_route(target) && (flags & LLE_STATIC)) { 1134f7a39160SGleb Smirnoff struct in_ifaddr *eia; 1135c7ab6602SQing Li 1136f7a39160SGleb Smirnoff eia = in_localip_more(target); 1137f7a39160SGleb Smirnoff 1138f7a39160SGleb Smirnoff if (eia != NULL) { 1139f7a39160SGleb Smirnoff error = ifa_switch_loopback_route((struct ifaddr *)eia, 114059c180c3SAlexander V. Chernikov (struct sockaddr *)&target->ia_addr); 1141f7a39160SGleb Smirnoff ifa_free(&eia->ia_ifa); 1142f7a39160SGleb Smirnoff } else { 11439bb7d0f4SQing Li error = ifa_del_loopback_route((struct ifaddr *)target, 11449bb7d0f4SQing Li (struct sockaddr *)&target->ia_addr); 11455b84dc78SQing Li } 1146ebc90701SQing Li } 1147ebc90701SQing Li 1148130aebbaSAlexander V. Chernikov ia_getrtprefix(target, &prefix, &mask); 114948321abeSMax Laier 1150ccbb9c35SQing Li if ((target->ia_flags & IFA_ROUTE) == 0) { 1151d68cf57bSAlexander V. Chernikov rt_addrmsg(RTM_DELETE, &target->ia_ifa, target->ia_ifp->if_fib); 115226a60575SAlexander V. Chernikov 115326a60575SAlexander V. Chernikov /* 115426a60575SAlexander V. Chernikov * Removing address from !IFF_UP interface or 115526a60575SAlexander V. Chernikov * prefix which exists on other interface (along with route). 115626a60575SAlexander V. Chernikov * No entries should exist here except target addr. 115726a60575SAlexander V. Chernikov * Given that, delete this entry only. 115826a60575SAlexander V. Chernikov */ 115926a60575SAlexander V. Chernikov in_scrubprefixlle(target, 0, flags); 1160ccbb9c35SQing Li return (0); 1161ccbb9c35SQing Li } 1162ccbb9c35SQing Li 11632144431cSGleb Smirnoff NET_EPOCH_ENTER(et); 1164d7c5a620SMatt Macy CK_STAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) { 1165130aebbaSAlexander V. Chernikov ia_getrtprefix(ia, &p, &m); 116655174c34SGleb Smirnoff 116755174c34SGleb Smirnoff if (prefix.s_addr != p.s_addr || 116855174c34SGleb Smirnoff mask.s_addr != m.s_addr) 116955174c34SGleb Smirnoff continue; 117048321abeSMax Laier 117155174c34SGleb Smirnoff if ((ia->ia_ifp->if_flags & IFF_UP) == 0) 117248321abeSMax Laier continue; 117348321abeSMax Laier 117448321abeSMax Laier /* 117548321abeSMax Laier * If we got a matching prefix address, move IFA_ROUTE and 117648321abeSMax Laier * the route itself to it. Make sure that routing daemons 117748321abeSMax Laier * get a heads-up. 117848321abeSMax Laier */ 117908b68b0eSGleb Smirnoff if ((ia->ia_flags & IFA_ROUTE) == 0) { 118079d51435SSergey Kandaurov ifa_ref(&ia->ia_ifa); 11812144431cSGleb Smirnoff NET_EPOCH_EXIT(et); 118281728a53SAlexander V. Chernikov error = in_handle_ifaddr_route(RTM_DELETE, target); 118392322284SQing Li if (error == 0) 118448321abeSMax Laier target->ia_flags &= ~IFA_ROUTE; 118592322284SQing Li else 118692322284SQing Li log(LOG_INFO, "in_scrubprefix: err=%d, old prefix delete failed\n", 118792322284SQing Li error); 11883e7a2321SAlexander V. Chernikov /* Scrub all entries IFF interface is different */ 11893e7a2321SAlexander V. Chernikov in_scrubprefixlle(target, target->ia_ifp != ia->ia_ifp, 11903e7a2321SAlexander V. Chernikov flags); 119181728a53SAlexander V. Chernikov error = in_handle_ifaddr_route(RTM_ADD, ia); 119248321abeSMax Laier if (error == 0) 119348321abeSMax Laier ia->ia_flags |= IFA_ROUTE; 119492322284SQing Li else 119592322284SQing Li log(LOG_INFO, "in_scrubprefix: err=%d, new prefix add failed\n", 119692322284SQing Li error); 119779d51435SSergey Kandaurov ifa_free(&ia->ia_ifa); 1198460473a0SBjoern A. Zeeb return (error); 119948321abeSMax Laier } 120048321abeSMax Laier } 12012144431cSGleb Smirnoff NET_EPOCH_EXIT(et); 120248321abeSMax Laier 120348321abeSMax Laier /* 1204c9d763bfSQing Li * remove all L2 entries on the given prefix 1205c9d763bfSQing Li */ 12063e7a2321SAlexander V. Chernikov in_scrubprefixlle(target, 1, flags); 1207c9d763bfSQing Li 1208c9d763bfSQing Li /* 120948321abeSMax Laier * As no-one seem to have this prefix, we can remove the route. 121048321abeSMax Laier */ 121181728a53SAlexander V. Chernikov rt_addrmsg(RTM_DELETE, &target->ia_ifa, target->ia_ifp->if_fib); 121281728a53SAlexander V. Chernikov error = in_handle_ifaddr_route(RTM_DELETE, target); 121392322284SQing Li if (error == 0) 121448321abeSMax Laier target->ia_flags &= ~IFA_ROUTE; 121592322284SQing Li else 121692322284SQing Li log(LOG_INFO, "in_scrubprefix: err=%d, prefix delete failed\n", error); 121792322284SQing Li return (error); 121848321abeSMax Laier } 121948321abeSMax Laier 122089856f7eSBjoern A. Zeeb void 122189856f7eSBjoern A. Zeeb in_ifscrub_all(void) 122289856f7eSBjoern A. Zeeb { 122389856f7eSBjoern A. Zeeb struct ifnet *ifp; 122489856f7eSBjoern A. Zeeb struct ifaddr *ifa, *nifa; 1225*bc06c514SKonrad Witaszczyk struct ifreq ifr; 122689856f7eSBjoern A. Zeeb 122789856f7eSBjoern A. Zeeb IFNET_RLOCK(); 12284f6c66ccSMatt Macy CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) { 122989856f7eSBjoern A. Zeeb /* Cannot lock here - lock recursion. */ 1230a68cc388SGleb Smirnoff /* NET_EPOCH_ENTER(et); */ 1231d7c5a620SMatt Macy CK_STAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, nifa) { 123289856f7eSBjoern A. Zeeb if (ifa->ifa_addr->sa_family != AF_INET) 123389856f7eSBjoern A. Zeeb continue; 123489856f7eSBjoern A. Zeeb 123589856f7eSBjoern A. Zeeb /* 123689856f7eSBjoern A. Zeeb * This is ugly but the only way for legacy IP to 123789856f7eSBjoern A. Zeeb * cleanly remove addresses and everything attached. 123889856f7eSBjoern A. Zeeb */ 123989856f7eSBjoern A. Zeeb bzero(&ifr, sizeof(ifr)); 1240*bc06c514SKonrad Witaszczyk ifr.ifr_addr = *ifa->ifa_addr; 124189856f7eSBjoern A. Zeeb (void)in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, 124289856f7eSBjoern A. Zeeb ifp, NULL); 124389856f7eSBjoern A. Zeeb } 1244a68cc388SGleb Smirnoff /* NET_EPOCH_EXIT(et); */ 124589856f7eSBjoern A. Zeeb in_purgemaddrs(ifp); 124689856f7eSBjoern A. Zeeb igmp_domifdetach(ifp); 124789856f7eSBjoern A. Zeeb } 124889856f7eSBjoern A. Zeeb IFNET_RUNLOCK(); 124989856f7eSBjoern A. Zeeb } 125089856f7eSBjoern A. Zeeb 125190cc51a1SRyan Stone int 125290cc51a1SRyan Stone in_ifaddr_broadcast(struct in_addr in, struct in_ifaddr *ia) 125390cc51a1SRyan Stone { 125490cc51a1SRyan Stone 125590cc51a1SRyan Stone return ((in.s_addr == ia->ia_broadaddr.sin_addr.s_addr || 125690cc51a1SRyan Stone /* 1257fd076593SMike Karels * Optionally check for old-style (host 0) broadcast, but 125890cc51a1SRyan Stone * taking into account that RFC 3021 obsoletes it. 125990cc51a1SRyan Stone */ 1260fd076593SMike Karels (V_broadcast_lowest && ia->ia_subnetmask != IN_RFC3021_MASK && 126190cc51a1SRyan Stone ntohl(in.s_addr) == ia->ia_subnet)) && 126290cc51a1SRyan Stone /* 126390cc51a1SRyan Stone * Check for an all one subnetmask. These 126490cc51a1SRyan Stone * only exist when an interface gets a secondary 126590cc51a1SRyan Stone * address. 126690cc51a1SRyan Stone */ 126790cc51a1SRyan Stone ia->ia_subnetmask != (u_long)0xffffffff); 126890cc51a1SRyan Stone } 126990cc51a1SRyan Stone 1270df8bae1dSRodney W. Grimes /* 1271df8bae1dSRodney W. Grimes * Return 1 if the address might be a local broadcast address. 1272df8bae1dSRodney W. Grimes */ 127326f9a767SRodney W. Grimes int 1274f2565d68SRobert Watson in_broadcast(struct in_addr in, struct ifnet *ifp) 1275df8bae1dSRodney W. Grimes { 12763e85b721SEd Maste struct ifaddr *ifa; 127711f2a7cdSRyan Stone int found; 1278df8bae1dSRodney W. Grimes 1279b8a6e03fSGleb Smirnoff NET_EPOCH_ASSERT(); 1280b8a6e03fSGleb Smirnoff 1281df8bae1dSRodney W. Grimes if (in.s_addr == INADDR_BROADCAST || 1282df8bae1dSRodney W. Grimes in.s_addr == INADDR_ANY) 1283460473a0SBjoern A. Zeeb return (1); 1284df8bae1dSRodney W. Grimes if ((ifp->if_flags & IFF_BROADCAST) == 0) 1285460473a0SBjoern A. Zeeb return (0); 128611f2a7cdSRyan Stone found = 0; 1287df8bae1dSRodney W. Grimes /* 1288df8bae1dSRodney W. Grimes * Look through the list of addresses for a match 1289df8bae1dSRodney W. Grimes * with a broadcast address. 1290df8bae1dSRodney W. Grimes */ 1291d7c5a620SMatt Macy CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) 1292df8bae1dSRodney W. Grimes if (ifa->ifa_addr->sa_family == AF_INET && 129311f2a7cdSRyan Stone in_ifaddr_broadcast(in, (struct in_ifaddr *)ifa)) { 129411f2a7cdSRyan Stone found = 1; 129511f2a7cdSRyan Stone break; 129611f2a7cdSRyan Stone } 129711f2a7cdSRyan Stone return (found); 1298df8bae1dSRodney W. Grimes } 1299ec002feeSBruce M Simpson 1300df8bae1dSRodney W. Grimes /* 1301b1c53bc9SRobert Watson * On interface removal, clean up IPv4 data structures hung off of the ifnet. 1302b1c53bc9SRobert Watson */ 1303b1c53bc9SRobert Watson void 1304f2565d68SRobert Watson in_ifdetach(struct ifnet *ifp) 1305b1c53bc9SRobert Watson { 1306f3e1324bSStephen Hurd IN_MULTI_LOCK(); 1307603724d3SBjoern A. Zeeb in_pcbpurgeif0(&V_ripcbinfo, ifp); 1308603724d3SBjoern A. Zeeb in_pcbpurgeif0(&V_udbinfo, ifp); 1309e06e816fSKevin Lo in_pcbpurgeif0(&V_ulitecbinfo, ifp); 1310ec002feeSBruce M Simpson in_purgemaddrs(ifp); 1311f3e1324bSStephen Hurd IN_MULTI_UNLOCK(); 13123689652cSHans Petter Selasky 13133689652cSHans Petter Selasky /* 13143689652cSHans Petter Selasky * Make sure all multicast deletions invoking if_ioctl() are 13153689652cSHans Petter Selasky * completed before returning. Else we risk accessing a freed 13163689652cSHans Petter Selasky * ifnet structure pointer. 13173689652cSHans Petter Selasky */ 13183689652cSHans Petter Selasky inm_release_wait(NULL); 1319b1c53bc9SRobert Watson } 13206e6b3f7cSQing Li 1321b8103ca7SGleb Smirnoff static void 1322b8103ca7SGleb Smirnoff in_ifnet_event(void *arg __unused, struct ifnet *ifp, int event) 1323b8103ca7SGleb Smirnoff { 1324b8103ca7SGleb Smirnoff struct epoch_tracker et; 1325b8103ca7SGleb Smirnoff struct ifaddr *ifa; 1326b8103ca7SGleb Smirnoff struct in_ifaddr *ia; 1327b8103ca7SGleb Smirnoff int error; 1328b8103ca7SGleb Smirnoff 1329b8103ca7SGleb Smirnoff NET_EPOCH_ENTER(et); 1330b8103ca7SGleb Smirnoff switch (event) { 1331b8103ca7SGleb Smirnoff case IFNET_EVENT_DOWN: 1332b8103ca7SGleb Smirnoff CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 1333b8103ca7SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 1334b8103ca7SGleb Smirnoff continue; 1335b8103ca7SGleb Smirnoff ia = (struct in_ifaddr *)ifa; 1336b8103ca7SGleb Smirnoff if ((ia->ia_flags & IFA_ROUTE) == 0) 1337b8103ca7SGleb Smirnoff continue; 1338b8103ca7SGleb Smirnoff ifa_ref(ifa); 1339b8103ca7SGleb Smirnoff /* 1340b8103ca7SGleb Smirnoff * in_scrubprefix() kills the interface route. 1341b8103ca7SGleb Smirnoff */ 1342b8103ca7SGleb Smirnoff in_scrubprefix(ia, 0); 1343b8103ca7SGleb Smirnoff /* 1344b8103ca7SGleb Smirnoff * in_ifadown gets rid of all the rest of the 1345b8103ca7SGleb Smirnoff * routes. This is not quite the right thing 1346b8103ca7SGleb Smirnoff * to do, but at least if we are running a 1347b8103ca7SGleb Smirnoff * routing process they will come back. 1348b8103ca7SGleb Smirnoff */ 1349b8103ca7SGleb Smirnoff in_ifadown(ifa, 0); 1350b8103ca7SGleb Smirnoff ifa_free(ifa); 1351b8103ca7SGleb Smirnoff } 1352b8103ca7SGleb Smirnoff break; 1353b8103ca7SGleb Smirnoff 1354b8103ca7SGleb Smirnoff case IFNET_EVENT_UP: 1355b8103ca7SGleb Smirnoff CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 1356b8103ca7SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 1357b8103ca7SGleb Smirnoff continue; 1358b8103ca7SGleb Smirnoff ia = (struct in_ifaddr *)ifa; 1359b8103ca7SGleb Smirnoff if (ia->ia_flags & IFA_ROUTE) 1360b8103ca7SGleb Smirnoff continue; 1361b8103ca7SGleb Smirnoff ifa_ref(ifa); 1362b8103ca7SGleb Smirnoff error = ifa_del_loopback_route(ifa, ifa->ifa_addr); 1363b8103ca7SGleb Smirnoff rt_addrmsg(RTM_ADD, ifa, ifa->ifa_ifp->if_fib); 1364b8103ca7SGleb Smirnoff error = in_handle_ifaddr_route(RTM_ADD, ia); 1365b8103ca7SGleb Smirnoff if (error == 0) 1366b8103ca7SGleb Smirnoff ia->ia_flags |= IFA_ROUTE; 1367b8103ca7SGleb Smirnoff error = ifa_add_loopback_route(ifa, ifa->ifa_addr); 1368b8103ca7SGleb Smirnoff ifa_free(ifa); 1369b8103ca7SGleb Smirnoff } 1370b8103ca7SGleb Smirnoff break; 1371b8103ca7SGleb Smirnoff } 1372b8103ca7SGleb Smirnoff NET_EPOCH_EXIT(et); 1373b8103ca7SGleb Smirnoff } 1374b8103ca7SGleb Smirnoff EVENTHANDLER_DEFINE(ifnet_event, in_ifnet_event, NULL, EVENTHANDLER_PRI_ANY); 1375b8103ca7SGleb Smirnoff 1376d10910e6SBruce M Simpson /* 1377d10910e6SBruce M Simpson * Delete all IPv4 multicast address records, and associated link-layer 1378d10910e6SBruce M Simpson * multicast address records, associated with ifp. 1379d10910e6SBruce M Simpson * XXX It looks like domifdetach runs AFTER the link layer cleanup. 138056663a40SBruce M Simpson * XXX This should not race with ifma_protospec being set during 138156663a40SBruce M Simpson * a new allocation, if it does, we have bigger problems. 1382d10910e6SBruce M Simpson */ 1383d10910e6SBruce M Simpson static void 1384d10910e6SBruce M Simpson in_purgemaddrs(struct ifnet *ifp) 1385d10910e6SBruce M Simpson { 13861e9482f4SAlexander Motin struct epoch_tracker et; 1387f3e1324bSStephen Hurd struct in_multi_head purgeinms; 1388f3e1324bSStephen Hurd struct in_multi *inm; 13891e9482f4SAlexander Motin struct ifmultiaddr *ifma; 1390d10910e6SBruce M Simpson 1391f3e1324bSStephen Hurd SLIST_INIT(&purgeinms); 1392f3e1324bSStephen Hurd IN_MULTI_LIST_LOCK(); 1393d10910e6SBruce M Simpson 1394d10910e6SBruce M Simpson /* 1395d10910e6SBruce M Simpson * Extract list of in_multi associated with the detaching ifp 1396d10910e6SBruce M Simpson * which the PF_INET layer is about to release. 1397d10910e6SBruce M Simpson * We need to do this as IF_ADDR_LOCK() may be re-acquired 1398d10910e6SBruce M Simpson * by code further down. 1399d10910e6SBruce M Simpson */ 1400b6f6f880SMatt Macy IF_ADDR_WLOCK(ifp); 14011e9482f4SAlexander Motin NET_EPOCH_ENTER(et); 14021e9482f4SAlexander Motin CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 14031e9482f4SAlexander Motin inm = inm_ifmultiaddr_get_inm(ifma); 14041e9482f4SAlexander Motin if (inm == NULL) 1405d10910e6SBruce M Simpson continue; 1406f3e1324bSStephen Hurd inm_rele_locked(&purgeinms, inm); 1407d10910e6SBruce M Simpson } 14081e9482f4SAlexander Motin NET_EPOCH_EXIT(et); 1409b6f6f880SMatt Macy IF_ADDR_WUNLOCK(ifp); 1410d10910e6SBruce M Simpson 1411f3e1324bSStephen Hurd inm_release_list_deferred(&purgeinms); 1412d10910e6SBruce M Simpson igmp_ifdetach(ifp); 1413f3e1324bSStephen Hurd IN_MULTI_LIST_UNLOCK(); 1414d10910e6SBruce M Simpson } 1415d10910e6SBruce M Simpson 14166e6b3f7cSQing Li struct in_llentry { 14176e6b3f7cSQing Li struct llentry base; 14186e6b3f7cSQing Li }; 14196e6b3f7cSQing Li 142011cdad98SAlexander V. Chernikov #define IN_LLTBL_DEFAULT_HSIZE 32 142111cdad98SAlexander V. Chernikov #define IN_LLTBL_HASH(k, h) \ 142211cdad98SAlexander V. Chernikov (((((((k >> 8) ^ k) >> 8) ^ k) >> 8) ^ k) & ((h) - 1)) 142311cdad98SAlexander V. Chernikov 1424a93cda78SKip Macy /* 142511cdad98SAlexander V. Chernikov * Do actual deallocation of @lle. 14262769d062SConrad Meyer */ 14272769d062SConrad Meyer static void 14284f6c66ccSMatt Macy in_lltable_destroy_lle_unlocked(epoch_context_t ctx) 14292769d062SConrad Meyer { 14304f6c66ccSMatt Macy struct llentry *lle; 14312769d062SConrad Meyer 14324f6c66ccSMatt Macy lle = __containerof(ctx, struct llentry, lle_epoch_ctx); 14332769d062SConrad Meyer LLE_LOCK_DESTROY(lle); 14342769d062SConrad Meyer LLE_REQ_DESTROY(lle); 14352769d062SConrad Meyer free(lle, M_LLTABLE); 14362769d062SConrad Meyer } 14372769d062SConrad Meyer 14382769d062SConrad Meyer /* 143911cdad98SAlexander V. Chernikov * Called by LLE_FREE_LOCKED when number of references 144011cdad98SAlexander V. Chernikov * drops to zero. 1441a93cda78SKip Macy */ 1442a93cda78SKip Macy static void 144311cdad98SAlexander V. Chernikov in_lltable_destroy_lle(struct llentry *lle) 1444a93cda78SKip Macy { 144511cdad98SAlexander V. Chernikov 1446a93cda78SKip Macy LLE_WUNLOCK(lle); 14472a4bd982SGleb Smirnoff NET_EPOCH_CALL(in_lltable_destroy_lle_unlocked, &lle->lle_epoch_ctx); 1448a93cda78SKip Macy } 1449a93cda78SKip Macy 14506e6b3f7cSQing Li static struct llentry * 1451314294deSAlexander V. Chernikov in_lltable_new(struct in_addr addr4, u_int flags) 14526e6b3f7cSQing Li { 14536e6b3f7cSQing Li struct in_llentry *lle; 14546e6b3f7cSQing Li 145590b357f6SGleb Smirnoff lle = malloc(sizeof(struct in_llentry), M_LLTABLE, M_NOWAIT | M_ZERO); 14566e6b3f7cSQing Li if (lle == NULL) /* NB: caller generates msg */ 14576e6b3f7cSQing Li return NULL; 14586e6b3f7cSQing Li 14596e6b3f7cSQing Li /* 14606e6b3f7cSQing Li * For IPv4 this will trigger "arpresolve" to generate 14616e6b3f7cSQing Li * an ARP request. 14626e6b3f7cSQing Li */ 1463a98c06f1SGleb Smirnoff lle->base.la_expire = time_uptime; /* mark expired */ 1464314294deSAlexander V. Chernikov lle->base.r_l3addr.addr4 = addr4; 14656e6b3f7cSQing Li lle->base.lle_refcnt = 1; 146611cdad98SAlexander V. Chernikov lle->base.lle_free = in_lltable_destroy_lle; 14676e6b3f7cSQing Li LLE_LOCK_INIT(&lle->base); 1468f8aee88fSAlexander V. Chernikov LLE_REQ_INIT(&lle->base); 14690447c136SAlexander V. Chernikov callout_init(&lle->base.lle_timer, 1); 1470ea537929SGleb Smirnoff 1471ea537929SGleb Smirnoff return (&lle->base); 14726e6b3f7cSQing Li } 14736e6b3f7cSQing Li 147411cdad98SAlexander V. Chernikov static int 14753e7a2321SAlexander V. Chernikov in_lltable_match_prefix(const struct sockaddr *saddr, 14763e7a2321SAlexander V. Chernikov const struct sockaddr *smask, u_int flags, struct llentry *lle) 1477c9d763bfSQing Li { 14783e7a2321SAlexander V. Chernikov struct in_addr addr, mask, lle_addr; 14793e7a2321SAlexander V. Chernikov 14803e7a2321SAlexander V. Chernikov addr = ((const struct sockaddr_in *)saddr)->sin_addr; 14813e7a2321SAlexander V. Chernikov mask = ((const struct sockaddr_in *)smask)->sin_addr; 14823e7a2321SAlexander V. Chernikov lle_addr.s_addr = ntohl(lle->r_l3addr.addr4.s_addr); 14833e7a2321SAlexander V. Chernikov 14843e7a2321SAlexander V. Chernikov if (IN_ARE_MASKED_ADDR_EQUAL(lle_addr, addr, mask) == 0) 14853e7a2321SAlexander V. Chernikov return (0); 14863e7a2321SAlexander V. Chernikov 14873e7a2321SAlexander V. Chernikov if (lle->la_flags & LLE_IFADDR) { 14885b84dc78SQing Li /* 14893e7a2321SAlexander V. Chernikov * Delete LLE_IFADDR records IFF address & flag matches. 14903e7a2321SAlexander V. Chernikov * Note that addr is the interface address within prefix 14913e7a2321SAlexander V. Chernikov * being matched. 14923e7a2321SAlexander V. Chernikov * Note also we should handle 'ifdown' cases without removing 14933e7a2321SAlexander V. Chernikov * ifaddr macs. 14945b84dc78SQing Li */ 14953e7a2321SAlexander V. Chernikov if (addr.s_addr == lle_addr.s_addr && (flags & LLE_STATIC) != 0) 14963e7a2321SAlexander V. Chernikov return (1); 14973e7a2321SAlexander V. Chernikov return (0); 14983e7a2321SAlexander V. Chernikov } 14993e7a2321SAlexander V. Chernikov 15003e7a2321SAlexander V. Chernikov /* flags & LLE_STATIC means deleting both dynamic and static entries */ 15013e7a2321SAlexander V. Chernikov if ((flags & LLE_STATIC) || !(lle->la_flags & LLE_STATIC)) 150211cdad98SAlexander V. Chernikov return (1); 150311cdad98SAlexander V. Chernikov 150411cdad98SAlexander V. Chernikov return (0); 150511cdad98SAlexander V. Chernikov } 150611cdad98SAlexander V. Chernikov 150711cdad98SAlexander V. Chernikov static void 150811cdad98SAlexander V. Chernikov in_lltable_free_entry(struct lltable *llt, struct llentry *lle) 150911cdad98SAlexander V. Chernikov { 151011cdad98SAlexander V. Chernikov size_t pkts_dropped; 151111cdad98SAlexander V. Chernikov 151211cdad98SAlexander V. Chernikov LLE_WLOCK_ASSERT(lle); 151311cdad98SAlexander V. Chernikov KASSERT(llt != NULL, ("lltable is NULL")); 151411cdad98SAlexander V. Chernikov 151511cdad98SAlexander V. Chernikov /* Unlink entry from table if not already */ 151611cdad98SAlexander V. Chernikov if ((lle->la_flags & LLE_LINKED) != 0) { 1517f6960e20SMatt Macy IF_AFDATA_WLOCK_ASSERT(llt->llt_ifp); 151811cdad98SAlexander V. Chernikov lltable_unlink_entry(llt, lle); 151911cdad98SAlexander V. Chernikov } 152011cdad98SAlexander V. Chernikov 152111cdad98SAlexander V. Chernikov /* Drop hold queue */ 1522e162ea60SGeorge V. Neville-Neil pkts_dropped = llentry_free(lle); 1523e162ea60SGeorge V. Neville-Neil ARPSTAT_ADD(dropped, pkts_dropped); 1524c9d763bfSQing Li } 1525c9d763bfSQing Li 15266e6b3f7cSQing Li static int 1527c7ab6602SQing Li in_lltable_rtcheck(struct ifnet *ifp, u_int flags, const struct sockaddr *l3addr) 15286e6b3f7cSQing Li { 1529936f4a42SAlexander V. Chernikov struct nhop_object *nh; 1530936f4a42SAlexander V. Chernikov struct in_addr addr; 15316e6b3f7cSQing Li 15326e6b3f7cSQing Li KASSERT(l3addr->sa_family == AF_INET, 15336e6b3f7cSQing Li ("sin_family %d", l3addr->sa_family)); 15346e6b3f7cSQing Li 1535936f4a42SAlexander V. Chernikov addr = ((const struct sockaddr_in *)l3addr)->sin_addr; 153613e255faSMarko Zec 1537936f4a42SAlexander V. Chernikov nh = fib4_lookup(ifp->if_fib, addr, 0, NHR_NONE, 0); 1538936f4a42SAlexander V. Chernikov if (nh == NULL) 15396cf8e330SQing Li return (EINVAL); 15406cf8e330SQing Li 154113e255faSMarko Zec /* 154213e255faSMarko Zec * If the gateway for an existing host route matches the target L3 15436cf8e330SQing Li * address, which is a special route inserted by some implementation 15446cf8e330SQing Li * such as MANET, and the interface is of the correct type, then 15456cf8e330SQing Li * allow for ARP to proceed. 154613e255faSMarko Zec */ 1547936f4a42SAlexander V. Chernikov if (nh->nh_flags & NHF_GATEWAY) { 1548936f4a42SAlexander V. Chernikov if (!(nh->nh_flags & NHF_HOST) || nh->nh_ifp->if_type != IFT_ETHER || 1549936f4a42SAlexander V. Chernikov (nh->nh_ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) != 0 || 1550936f4a42SAlexander V. Chernikov memcmp(nh->gw_sa.sa_data, l3addr->sa_data, 155115d25219SQing Li sizeof(in_addr_t)) != 0) { 1552db92413eSQing Li return (EINVAL); 1553db92413eSQing Li } 155415d25219SQing Li } 1555db92413eSQing Li 1556db92413eSQing Li /* 1557db92413eSQing Li * Make sure that at least the destination address is covered 1558db92413eSQing Li * by the route. This is for handling the case where 2 or more 1559db92413eSQing Li * interfaces have the same prefix. An incoming packet arrives 1560db92413eSQing Li * on one interface and the corresponding outgoing packet leaves 1561db92413eSQing Li * another interface. 1562db92413eSQing Li */ 1563936f4a42SAlexander V. Chernikov if ((nh->nh_ifp != ifp) && (nh->nh_flags & NHF_HOST) == 0) { 1564936f4a42SAlexander V. Chernikov struct in_ifaddr *ia = (struct in_ifaddr *)ifaof_ifpforaddr(l3addr, ifp); 1565936f4a42SAlexander V. Chernikov struct in_addr dst_addr, mask_addr; 1566db92413eSQing Li 1567936f4a42SAlexander V. Chernikov if (ia == NULL) 1568936f4a42SAlexander V. Chernikov return (EINVAL); 1569936f4a42SAlexander V. Chernikov 1570b3664a14SQing Li /* 1571936f4a42SAlexander V. Chernikov * ifaof_ifpforaddr() returns _best matching_ IFA. 1572936f4a42SAlexander V. Chernikov * It is possible that ifa prefix does not cover our address. 1573936f4a42SAlexander V. Chernikov * Explicitly verify and fail if that's the case. 1574b3664a14SQing Li */ 1575936f4a42SAlexander V. Chernikov dst_addr = IA_SIN(ia)->sin_addr; 1576936f4a42SAlexander V. Chernikov mask_addr.s_addr = htonl(ia->ia_subnetmask); 1577936f4a42SAlexander V. Chernikov 1578936f4a42SAlexander V. Chernikov if (!IN_ARE_MASKED_ADDR_EQUAL(dst_addr, addr, mask_addr)) 1579b3664a14SQing Li return (EINVAL); 1580db92413eSQing Li } 1581db92413eSQing Li 158215d25219SQing Li return (0); 15836e6b3f7cSQing Li } 15846e6b3f7cSQing Li 158511cdad98SAlexander V. Chernikov static inline uint32_t 158611cdad98SAlexander V. Chernikov in_lltable_hash_dst(const struct in_addr dst, uint32_t hsize) 158711cdad98SAlexander V. Chernikov { 158811cdad98SAlexander V. Chernikov 158911cdad98SAlexander V. Chernikov return (IN_LLTBL_HASH(dst.s_addr, hsize)); 159011cdad98SAlexander V. Chernikov } 159111cdad98SAlexander V. Chernikov 159211cdad98SAlexander V. Chernikov static uint32_t 159311cdad98SAlexander V. Chernikov in_lltable_hash(const struct llentry *lle, uint32_t hsize) 159411cdad98SAlexander V. Chernikov { 159511cdad98SAlexander V. Chernikov 1596314294deSAlexander V. Chernikov return (in_lltable_hash_dst(lle->r_l3addr.addr4, hsize)); 159711cdad98SAlexander V. Chernikov } 159811cdad98SAlexander V. Chernikov 159911cdad98SAlexander V. Chernikov static void 160011cdad98SAlexander V. Chernikov in_lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) 160111cdad98SAlexander V. Chernikov { 160211cdad98SAlexander V. Chernikov struct sockaddr_in *sin; 160311cdad98SAlexander V. Chernikov 160411cdad98SAlexander V. Chernikov sin = (struct sockaddr_in *)sa; 160511cdad98SAlexander V. Chernikov bzero(sin, sizeof(*sin)); 160611cdad98SAlexander V. Chernikov sin->sin_family = AF_INET; 160711cdad98SAlexander V. Chernikov sin->sin_len = sizeof(*sin); 1608314294deSAlexander V. Chernikov sin->sin_addr = lle->r_l3addr.addr4; 160911cdad98SAlexander V. Chernikov } 161011cdad98SAlexander V. Chernikov 1611b4b1367aSAlexander V. Chernikov static inline struct llentry * 1612b4b1367aSAlexander V. Chernikov in_lltable_find_dst(struct lltable *llt, struct in_addr dst) 1613b4b1367aSAlexander V. Chernikov { 1614b4b1367aSAlexander V. Chernikov struct llentry *lle; 1615b4b1367aSAlexander V. Chernikov struct llentries *lleh; 161611cdad98SAlexander V. Chernikov u_int hashidx; 1617b4b1367aSAlexander V. Chernikov 16183a749863SAlexander V. Chernikov hashidx = in_lltable_hash_dst(dst, llt->llt_hsize); 161911cdad98SAlexander V. Chernikov lleh = &llt->lle_head[hashidx]; 16204f6c66ccSMatt Macy CK_LIST_FOREACH(lle, lleh, lle_next) { 1621b4b1367aSAlexander V. Chernikov if (lle->la_flags & LLE_DELETED) 1622b4b1367aSAlexander V. Chernikov continue; 1623314294deSAlexander V. Chernikov if (lle->r_l3addr.addr4.s_addr == dst.s_addr) 1624b4b1367aSAlexander V. Chernikov break; 1625b4b1367aSAlexander V. Chernikov } 1626b4b1367aSAlexander V. Chernikov 1627b4b1367aSAlexander V. Chernikov return (lle); 1628b4b1367aSAlexander V. Chernikov } 1629b4b1367aSAlexander V. Chernikov 16303e7a2321SAlexander V. Chernikov static void 16313e7a2321SAlexander V. Chernikov in_lltable_delete_entry(struct lltable *llt, struct llentry *lle) 1632b4b1367aSAlexander V. Chernikov { 1633b4b1367aSAlexander V. Chernikov 1634b4b1367aSAlexander V. Chernikov lle->la_flags |= LLE_DELETED; 1635b4b1367aSAlexander V. Chernikov EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_DELETED); 1636b4b1367aSAlexander V. Chernikov #ifdef DIAGNOSTIC 1637b4b1367aSAlexander V. Chernikov log(LOG_INFO, "ifaddr cache = %p is deleted\n", lle); 1638b4b1367aSAlexander V. Chernikov #endif 1639b4b1367aSAlexander V. Chernikov llentry_free(lle); 1640b4b1367aSAlexander V. Chernikov } 1641b4b1367aSAlexander V. Chernikov 1642b4b1367aSAlexander V. Chernikov static struct llentry * 16435a255516SAlexander V. Chernikov in_lltable_alloc(struct lltable *llt, u_int flags, const struct sockaddr *l3addr) 1644b4b1367aSAlexander V. Chernikov { 1645b4b1367aSAlexander V. Chernikov const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr; 1646b4b1367aSAlexander V. Chernikov struct ifnet *ifp = llt->llt_ifp; 1647b4b1367aSAlexander V. Chernikov struct llentry *lle; 16484fb3a820SAlexander V. Chernikov char linkhdr[LLE_MAX_LINKHDR]; 16494fb3a820SAlexander V. Chernikov size_t linkhdrsize; 16504fb3a820SAlexander V. Chernikov int lladdr_off; 1651b4b1367aSAlexander V. Chernikov 1652b4b1367aSAlexander V. Chernikov KASSERT(l3addr->sa_family == AF_INET, 1653b4b1367aSAlexander V. Chernikov ("sin_family %d", l3addr->sa_family)); 1654b4b1367aSAlexander V. Chernikov 1655b4b1367aSAlexander V. Chernikov /* 1656b4b1367aSAlexander V. Chernikov * A route that covers the given address must have 1657b4b1367aSAlexander V. Chernikov * been installed 1st because we are doing a resolution, 1658b4b1367aSAlexander V. Chernikov * verify this. 1659b4b1367aSAlexander V. Chernikov */ 1660b4b1367aSAlexander V. Chernikov if (!(flags & LLE_IFADDR) && 1661b4b1367aSAlexander V. Chernikov in_lltable_rtcheck(ifp, flags, l3addr) != 0) 1662b4b1367aSAlexander V. Chernikov return (NULL); 1663b4b1367aSAlexander V. Chernikov 1664314294deSAlexander V. Chernikov lle = in_lltable_new(sin->sin_addr, flags); 1665b4b1367aSAlexander V. Chernikov if (lle == NULL) { 1666b4b1367aSAlexander V. Chernikov log(LOG_INFO, "lla_lookup: new lle malloc failed\n"); 1667b4b1367aSAlexander V. Chernikov return (NULL); 1668b4b1367aSAlexander V. Chernikov } 1669b4b1367aSAlexander V. Chernikov lle->la_flags = flags; 1670f8aee88fSAlexander V. Chernikov if (flags & LLE_STATIC) 1671f8aee88fSAlexander V. Chernikov lle->r_flags |= RLLE_VALID; 1672b4b1367aSAlexander V. Chernikov if ((flags & LLE_IFADDR) == LLE_IFADDR) { 16734fb3a820SAlexander V. Chernikov linkhdrsize = LLE_MAX_LINKHDR; 16744fb3a820SAlexander V. Chernikov if (lltable_calc_llheader(ifp, AF_INET, IF_LLADDR(ifp), 16752769d062SConrad Meyer linkhdr, &linkhdrsize, &lladdr_off) != 0) { 1676990a6d18SMark Johnston in_lltable_free_entry(llt, lle); 16774fb3a820SAlexander V. Chernikov return (NULL); 16782769d062SConrad Meyer } 16794fb3a820SAlexander V. Chernikov lltable_set_entry_addr(ifp, lle, linkhdr, linkhdrsize, 16804fb3a820SAlexander V. Chernikov lladdr_off); 1681ddd208f7SAlexander V. Chernikov lle->la_flags |= LLE_STATIC; 1682f8aee88fSAlexander V. Chernikov lle->r_flags |= (RLLE_VALID | RLLE_IFADDR); 1683ca185047SAlexander V. Chernikov lle->la_expire = 0; 1684b4b1367aSAlexander V. Chernikov } 1685b4b1367aSAlexander V. Chernikov 1686b4b1367aSAlexander V. Chernikov return (lle); 1687b4b1367aSAlexander V. Chernikov } 1688b4b1367aSAlexander V. Chernikov 16896e6b3f7cSQing Li /* 16906e6b3f7cSQing Li * Return NULL if not found or marked for deletion. 16916e6b3f7cSQing Li * If found return lle read locked. 16926e6b3f7cSQing Li */ 16936e6b3f7cSQing Li static struct llentry * 16946e6b3f7cSQing Li in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr) 16956e6b3f7cSQing Li { 16966e6b3f7cSQing Li const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr; 16976e6b3f7cSQing Li struct llentry *lle; 16986e6b3f7cSQing Li 16996e4cd746SMarius Strobl IF_AFDATA_LOCK_ASSERT(llt->llt_ifp); 17006e6b3f7cSQing Li KASSERT(l3addr->sa_family == AF_INET, 17016e6b3f7cSQing Li ("sin_family %d", l3addr->sa_family)); 170249cf58e5SMark Johnston KASSERT((flags & (LLE_UNLOCKED | LLE_EXCLUSIVE)) != 170349cf58e5SMark Johnston (LLE_UNLOCKED | LLE_EXCLUSIVE), 170449cf58e5SMark Johnston ("wrong lle request flags: %#x", flags)); 1705b4b1367aSAlexander V. Chernikov 170649cf58e5SMark Johnston lle = in_lltable_find_dst(llt, sin->sin_addr); 1707b4b1367aSAlexander V. Chernikov if (lle == NULL) 17086e6b3f7cSQing Li return (NULL); 1709f8aee88fSAlexander V. Chernikov if (flags & LLE_UNLOCKED) 1710f8aee88fSAlexander V. Chernikov return (lle); 1711f8aee88fSAlexander V. Chernikov 17126e6b3f7cSQing Li if (flags & LLE_EXCLUSIVE) 17136e6b3f7cSQing Li LLE_WLOCK(lle); 17146e6b3f7cSQing Li else 17156e6b3f7cSQing Li LLE_RLOCK(lle); 1716b4b1367aSAlexander V. Chernikov 1717c06cc56eSMark Johnston /* 1718c06cc56eSMark Johnston * If the afdata lock is not held, the LLE may have been unlinked while 1719c06cc56eSMark Johnston * we were blocked on the LLE lock. Check for this case. 1720c06cc56eSMark Johnston */ 1721c06cc56eSMark Johnston if (__predict_false((lle->la_flags & LLE_LINKED) == 0)) { 1722c06cc56eSMark Johnston if (flags & LLE_EXCLUSIVE) 1723c06cc56eSMark Johnston LLE_WUNLOCK(lle); 1724c06cc56eSMark Johnston else 1725c06cc56eSMark Johnston LLE_RUNLOCK(lle); 1726c06cc56eSMark Johnston return (NULL); 1727c06cc56eSMark Johnston } 17286e6b3f7cSQing Li return (lle); 17296e6b3f7cSQing Li } 17306e6b3f7cSQing Li 17316e6b3f7cSQing Li static int 173211cdad98SAlexander V. Chernikov in_lltable_dump_entry(struct lltable *llt, struct llentry *lle, 173311cdad98SAlexander V. Chernikov struct sysctl_req *wr) 17346e6b3f7cSQing Li { 17356e6b3f7cSQing Li struct ifnet *ifp = llt->llt_ifp; 17366e6b3f7cSQing Li /* XXX stack use */ 17376e6b3f7cSQing Li struct { 17386e6b3f7cSQing Li struct rt_msghdr rtm; 17399711a168SGleb Smirnoff struct sockaddr_in sin; 17406e6b3f7cSQing Li struct sockaddr_dl sdl; 17416e6b3f7cSQing Li } arpc; 17426e6b3f7cSQing Li struct sockaddr_dl *sdl; 174311cdad98SAlexander V. Chernikov int error; 17446e6b3f7cSQing Li 174511cdad98SAlexander V. Chernikov bzero(&arpc, sizeof(arpc)); 17466e6b3f7cSQing Li /* skip deleted entries */ 174793704ac5SQing Li if ((lle->la_flags & LLE_DELETED) == LLE_DELETED) 174811cdad98SAlexander V. Chernikov return (0); 1749813dd6aeSBjoern A. Zeeb /* Skip if jailed and not a valid IP of the prison. */ 175011cdad98SAlexander V. Chernikov lltable_fill_sa_entry(lle,(struct sockaddr *)&arpc.sin); 1751514ef08cSBrooks Davis if (prison_if(wr->td->td_ucred, (struct sockaddr *)&arpc.sin) != 0) 175211cdad98SAlexander V. Chernikov return (0); 17536e6b3f7cSQing Li /* 17546e6b3f7cSQing Li * produce a msg made of: 17556e6b3f7cSQing Li * struct rt_msghdr; 17569711a168SGleb Smirnoff * struct sockaddr_in; (IPv4) 17576e6b3f7cSQing Li * struct sockaddr_dl; 17586e6b3f7cSQing Li */ 17596e6b3f7cSQing Li arpc.rtm.rtm_msglen = sizeof(arpc); 1760c0e9a8a1SHartmut Brandt arpc.rtm.rtm_version = RTM_VERSION; 1761c0e9a8a1SHartmut Brandt arpc.rtm.rtm_type = RTM_GET; 1762c0e9a8a1SHartmut Brandt arpc.rtm.rtm_flags = RTF_UP; 1763c0e9a8a1SHartmut Brandt arpc.rtm.rtm_addrs = RTA_DST | RTA_GATEWAY; 17646e6b3f7cSQing Li 17656e6b3f7cSQing Li /* publish */ 17669711a168SGleb Smirnoff if (lle->la_flags & LLE_PUB) 17676e6b3f7cSQing Li arpc.rtm.rtm_flags |= RTF_ANNOUNCE; 17686e6b3f7cSQing Li 17696e6b3f7cSQing Li sdl = &arpc.sdl; 17706e6b3f7cSQing Li sdl->sdl_family = AF_LINK; 17716e6b3f7cSQing Li sdl->sdl_len = sizeof(*sdl); 17726e6b3f7cSQing Li sdl->sdl_index = ifp->if_index; 17736e6b3f7cSQing Li sdl->sdl_type = ifp->if_type; 177493704ac5SQing Li if ((lle->la_flags & LLE_VALID) == LLE_VALID) { 177593704ac5SQing Li sdl->sdl_alen = ifp->if_addrlen; 17764fb3a820SAlexander V. Chernikov bcopy(lle->ll_addr, LLADDR(sdl), ifp->if_addrlen); 177793704ac5SQing Li } else { 177893704ac5SQing Li sdl->sdl_alen = 0; 177993704ac5SQing Li bzero(LLADDR(sdl), ifp->if_addrlen); 178093704ac5SQing Li } 17816e6b3f7cSQing Li 17826e6b3f7cSQing Li arpc.rtm.rtm_rmx.rmx_expire = 17836e6b3f7cSQing Li lle->la_flags & LLE_STATIC ? 0 : lle->la_expire; 17848eca593cSQing Li arpc.rtm.rtm_flags |= (RTF_HOST | RTF_LLDATA); 17856e6b3f7cSQing Li if (lle->la_flags & LLE_STATIC) 17866e6b3f7cSQing Li arpc.rtm.rtm_flags |= RTF_STATIC; 17874a336ef4SAlexander V. Chernikov if (lle->la_flags & LLE_IFADDR) 17884a336ef4SAlexander V. Chernikov arpc.rtm.rtm_flags |= RTF_PINNED; 17896e6b3f7cSQing Li arpc.rtm.rtm_index = ifp->if_index; 17906e6b3f7cSQing Li error = SYSCTL_OUT(wr, &arpc, sizeof(arpc)); 179111cdad98SAlexander V. Chernikov 179211cdad98SAlexander V. Chernikov return (error); 17936e6b3f7cSQing Li } 17946e6b3f7cSQing Li 179577001f9bSKUROSAWA Takahiro static void 179677001f9bSKUROSAWA Takahiro in_lltable_post_resolved(struct lltable *llt, struct llentry *lle) 179777001f9bSKUROSAWA Takahiro { 179877001f9bSKUROSAWA Takahiro struct ifnet *ifp = llt->llt_ifp; 179977001f9bSKUROSAWA Takahiro 180077001f9bSKUROSAWA Takahiro /* gratuitous ARP */ 180177001f9bSKUROSAWA Takahiro if ((lle->la_flags & LLE_PUB) != 0) 180277001f9bSKUROSAWA Takahiro arprequest(ifp, &lle->r_l3addr.addr4, &lle->r_l3addr.addr4, 180377001f9bSKUROSAWA Takahiro lle->ll_addr); 180477001f9bSKUROSAWA Takahiro } 180577001f9bSKUROSAWA Takahiro 18063a749863SAlexander V. Chernikov static struct lltable * 18073a749863SAlexander V. Chernikov in_lltattach(struct ifnet *ifp) 18086e6b3f7cSQing Li { 1809d10910e6SBruce M Simpson struct lltable *llt; 18106e6b3f7cSQing Li 18113a749863SAlexander V. Chernikov llt = lltable_allocate_htbl(IN_LLTBL_DEFAULT_HSIZE); 1812721cd2e0SAlexander V. Chernikov llt->llt_af = AF_INET; 1813721cd2e0SAlexander V. Chernikov llt->llt_ifp = ifp; 1814d10910e6SBruce M Simpson 18156e6b3f7cSQing Li llt->llt_lookup = in_lltable_lookup; 18165a255516SAlexander V. Chernikov llt->llt_alloc_entry = in_lltable_alloc; 18173e7a2321SAlexander V. Chernikov llt->llt_delete_entry = in_lltable_delete_entry; 181811cdad98SAlexander V. Chernikov llt->llt_dump_entry = in_lltable_dump_entry; 181911cdad98SAlexander V. Chernikov llt->llt_hash = in_lltable_hash; 182011cdad98SAlexander V. Chernikov llt->llt_fill_sa_entry = in_lltable_fill_sa_entry; 182111cdad98SAlexander V. Chernikov llt->llt_free_entry = in_lltable_free_entry; 182211cdad98SAlexander V. Chernikov llt->llt_match_prefix = in_lltable_match_prefix; 1823f3a3b061SAlexander V. Chernikov llt->llt_mark_used = llentry_mark_used; 182477001f9bSKUROSAWA Takahiro llt->llt_post_resolved = in_lltable_post_resolved; 1825721cd2e0SAlexander V. Chernikov lltable_link(llt); 1826d10910e6SBruce M Simpson 18273a749863SAlexander V. Chernikov return (llt); 18283a749863SAlexander V. Chernikov } 18293a749863SAlexander V. Chernikov 1830ff3a85d3SAlexander V. Chernikov struct lltable * 1831ff3a85d3SAlexander V. Chernikov in_lltable_get(struct ifnet *ifp) 1832ff3a85d3SAlexander V. Chernikov { 1833ff3a85d3SAlexander V. Chernikov struct lltable *llt = NULL; 1834ff3a85d3SAlexander V. Chernikov 1835ff3a85d3SAlexander V. Chernikov void *afdata_ptr = ifp->if_afdata[AF_INET]; 1836ff3a85d3SAlexander V. Chernikov if (afdata_ptr != NULL) 1837ff3a85d3SAlexander V. Chernikov llt = ((struct in_ifinfo *)afdata_ptr)->ii_llt; 1838ff3a85d3SAlexander V. Chernikov return (llt); 1839ff3a85d3SAlexander V. Chernikov } 1840ff3a85d3SAlexander V. Chernikov 18413a749863SAlexander V. Chernikov void * 18423a749863SAlexander V. Chernikov in_domifattach(struct ifnet *ifp) 18433a749863SAlexander V. Chernikov { 18443a749863SAlexander V. Chernikov struct in_ifinfo *ii; 18453a749863SAlexander V. Chernikov 1846721cd2e0SAlexander V. Chernikov ii = malloc(sizeof(struct in_ifinfo), M_IFADDR, M_WAITOK|M_ZERO); 184741cb42a6SAlexander V. Chernikov 18483a749863SAlexander V. Chernikov ii->ii_llt = in_lltattach(ifp); 1849d10910e6SBruce M Simpson ii->ii_igmp = igmp_domifattach(ifp); 1850d10910e6SBruce M Simpson 185141cb42a6SAlexander V. Chernikov return (ii); 18526e6b3f7cSQing Li } 18536e6b3f7cSQing Li 18546e6b3f7cSQing Li void 1855d10910e6SBruce M Simpson in_domifdetach(struct ifnet *ifp, void *aux) 18566e6b3f7cSQing Li { 1857d10910e6SBruce M Simpson struct in_ifinfo *ii = (struct in_ifinfo *)aux; 18586e6b3f7cSQing Li 1859d10910e6SBruce M Simpson igmp_domifdetach(ifp); 1860d10910e6SBruce M Simpson lltable_free(ii->ii_llt); 1861d10910e6SBruce M Simpson free(ii, M_IFADDR); 18626e6b3f7cSQing Li } 1863