1a9771948SGleb Smirnoff /* $FreeBSD$ */ 2a9771948SGleb Smirnoff 3a9771948SGleb Smirnoff /* 4a9771948SGleb Smirnoff * Copyright (c) 2002 Michael Shalayeff. All rights reserved. 5a9771948SGleb Smirnoff * Copyright (c) 2003 Ryan McBride. All rights reserved. 6a9771948SGleb Smirnoff * 7a9771948SGleb Smirnoff * Redistribution and use in source and binary forms, with or without 8a9771948SGleb Smirnoff * modification, are permitted provided that the following conditions 9a9771948SGleb Smirnoff * are met: 10a9771948SGleb Smirnoff * 1. Redistributions of source code must retain the above copyright 11a9771948SGleb Smirnoff * notice, this list of conditions and the following disclaimer. 12a9771948SGleb Smirnoff * 2. Redistributions in binary form must reproduce the above copyright 13a9771948SGleb Smirnoff * notice, this list of conditions and the following disclaimer in the 14a9771948SGleb Smirnoff * documentation and/or other materials provided with the distribution. 15a9771948SGleb Smirnoff * 16a9771948SGleb Smirnoff * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17a9771948SGleb Smirnoff * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18a9771948SGleb Smirnoff * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19a9771948SGleb Smirnoff * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, 20a9771948SGleb Smirnoff * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21a9771948SGleb Smirnoff * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22a9771948SGleb Smirnoff * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23a9771948SGleb Smirnoff * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 24a9771948SGleb Smirnoff * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 25a9771948SGleb Smirnoff * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 26a9771948SGleb Smirnoff * THE POSSIBILITY OF SUCH DAMAGE. 27a9771948SGleb Smirnoff */ 28a9771948SGleb Smirnoff 29a9771948SGleb Smirnoff #include "opt_carp.h" 30a9771948SGleb Smirnoff #include "opt_bpf.h" 31a9771948SGleb Smirnoff #include "opt_inet.h" 32a9771948SGleb Smirnoff #include "opt_inet6.h" 33a9771948SGleb Smirnoff 34a9771948SGleb Smirnoff #include <sys/types.h> 35a9771948SGleb Smirnoff #include <sys/param.h> 36a9771948SGleb Smirnoff #include <sys/systm.h> 37a9771948SGleb Smirnoff #include <sys/conf.h> 38a9771948SGleb Smirnoff #include <sys/kernel.h> 39a9771948SGleb Smirnoff #include <sys/limits.h> 40a9771948SGleb Smirnoff #include <sys/malloc.h> 41a9771948SGleb Smirnoff #include <sys/mbuf.h> 42a9771948SGleb Smirnoff #include <sys/module.h> 43a9771948SGleb Smirnoff #include <sys/time.h> 44a9771948SGleb Smirnoff #include <sys/proc.h> 45a9771948SGleb Smirnoff #include <sys/sysctl.h> 46a9771948SGleb Smirnoff #include <sys/syslog.h> 47a9771948SGleb Smirnoff #include <sys/signalvar.h> 48a9771948SGleb Smirnoff #include <sys/filio.h> 49a9771948SGleb Smirnoff #include <sys/sockio.h> 50a9771948SGleb Smirnoff 51a9771948SGleb Smirnoff #include <sys/socket.h> 52a9771948SGleb Smirnoff #include <sys/vnode.h> 53a9771948SGleb Smirnoff 54a9771948SGleb Smirnoff #include <machine/stdarg.h> 55a9771948SGleb Smirnoff 56a9771948SGleb Smirnoff #include <net/bpf.h> 57a9771948SGleb Smirnoff #include <net/ethernet.h> 58a9771948SGleb Smirnoff #include <net/fddi.h> 59a9771948SGleb Smirnoff #include <net/iso88025.h> 60a9771948SGleb Smirnoff #include <net/if.h> 61a9771948SGleb Smirnoff #include <net/if_clone.h> 62a9771948SGleb Smirnoff #include <net/if_types.h> 63a9771948SGleb Smirnoff #include <net/route.h> 64a9771948SGleb Smirnoff 65a9771948SGleb Smirnoff #ifdef INET 66a9771948SGleb Smirnoff #include <netinet/in.h> 67a9771948SGleb Smirnoff #include <netinet/in_var.h> 68a9771948SGleb Smirnoff #include <netinet/in_systm.h> 69a9771948SGleb Smirnoff #include <netinet/ip.h> 70a9771948SGleb Smirnoff #include <netinet/ip_var.h> 71a9771948SGleb Smirnoff #include <netinet/if_ether.h> 72a9771948SGleb Smirnoff #include <machine/in_cksum.h> 73a9771948SGleb Smirnoff #endif 74a9771948SGleb Smirnoff 75a9771948SGleb Smirnoff #ifdef INET6 76a9771948SGleb Smirnoff #include <netinet/icmp6.h> 77a9771948SGleb Smirnoff #include <netinet/ip6.h> 78a9771948SGleb Smirnoff #include <netinet6/ip6_var.h> 79a9771948SGleb Smirnoff #include <netinet6/nd6.h> 80a9771948SGleb Smirnoff #include <net/if_dl.h> 81a9771948SGleb Smirnoff #endif 82a9771948SGleb Smirnoff 83a9771948SGleb Smirnoff #include <crypto/sha1.h> 84a9771948SGleb Smirnoff #include <netinet/ip_carp.h> 85a9771948SGleb Smirnoff 86a9771948SGleb Smirnoff #define CARP_IFNAME "carp" 87a9771948SGleb Smirnoff static MALLOC_DEFINE(M_CARP, "CARP", "CARP interfaces"); 88a9771948SGleb Smirnoff SYSCTL_DECL(_net_inet_carp); 89a9771948SGleb Smirnoff 90a9771948SGleb Smirnoff struct carp_softc { 91fc74a9f9SBrooks Davis struct ifnet *sc_ifp; /* Interface clue */ 923a84d72aSGleb Smirnoff struct ifnet *sc_carpdev; /* Pointer to parent interface */ 93a9771948SGleb Smirnoff struct in_ifaddr *sc_ia; /* primary iface address */ 94a9771948SGleb Smirnoff struct ip_moptions sc_imo; 95a9771948SGleb Smirnoff #ifdef INET6 96a9771948SGleb Smirnoff struct in6_ifaddr *sc_ia6; /* primary iface address v6 */ 97a9771948SGleb Smirnoff struct ip6_moptions sc_im6o; 98a9771948SGleb Smirnoff #endif /* INET6 */ 99a9771948SGleb Smirnoff TAILQ_ENTRY(carp_softc) sc_list; 100a9771948SGleb Smirnoff 101a9771948SGleb Smirnoff enum { INIT = 0, BACKUP, MASTER } sc_state; 102a9771948SGleb Smirnoff 103a9771948SGleb Smirnoff int sc_flags_backup; 104a9771948SGleb Smirnoff int sc_suppress; 105a9771948SGleb Smirnoff 106a9771948SGleb Smirnoff int sc_sendad_errors; 107a9771948SGleb Smirnoff #define CARP_SENDAD_MAX_ERRORS 3 108a9771948SGleb Smirnoff int sc_sendad_success; 109a9771948SGleb Smirnoff #define CARP_SENDAD_MIN_SUCCESS 3 110a9771948SGleb Smirnoff 111a9771948SGleb Smirnoff int sc_vhid; 112a9771948SGleb Smirnoff int sc_advskew; 113a9771948SGleb Smirnoff int sc_naddrs; 114a9771948SGleb Smirnoff int sc_naddrs6; 115a9771948SGleb Smirnoff int sc_advbase; /* seconds */ 116a9771948SGleb Smirnoff int sc_init_counter; 117a9771948SGleb Smirnoff u_int64_t sc_counter; 118a9771948SGleb Smirnoff 119a9771948SGleb Smirnoff /* authentication */ 120a9771948SGleb Smirnoff #define CARP_HMAC_PAD 64 121a9771948SGleb Smirnoff unsigned char sc_key[CARP_KEY_LEN]; 122a9771948SGleb Smirnoff unsigned char sc_pad[CARP_HMAC_PAD]; 123a9771948SGleb Smirnoff SHA1_CTX sc_sha1; 124a9771948SGleb Smirnoff 125a9771948SGleb Smirnoff struct callout sc_ad_tmo; /* advertisement timeout */ 126a9771948SGleb Smirnoff struct callout sc_md_tmo; /* master down timeout */ 127a9771948SGleb Smirnoff struct callout sc_md6_tmo; /* master down timeout */ 128a9771948SGleb Smirnoff 129a9771948SGleb Smirnoff LIST_ENTRY(carp_softc) sc_next; /* Interface clue */ 130a9771948SGleb Smirnoff }; 131fc74a9f9SBrooks Davis #define SC2IFP(sc) ((sc)->sc_ifp) 132a9771948SGleb Smirnoff 133a9771948SGleb Smirnoff int carp_suppress_preempt = 0; 134a9771948SGleb Smirnoff int carp_opts[CARPCTL_MAXID] = { 0, 1, 0, 1, 0, 0 }; /* XXX for now */ 135a9771948SGleb Smirnoff SYSCTL_INT(_net_inet_carp, CARPCTL_ALLOW, allow, CTLFLAG_RW, 136a9771948SGleb Smirnoff &carp_opts[CARPCTL_ALLOW], 0, "Accept incoming CARP packets"); 137a9771948SGleb Smirnoff SYSCTL_INT(_net_inet_carp, CARPCTL_PREEMPT, preempt, CTLFLAG_RW, 138a9771948SGleb Smirnoff &carp_opts[CARPCTL_PREEMPT], 0, "high-priority backup preemption mode"); 139a9771948SGleb Smirnoff SYSCTL_INT(_net_inet_carp, CARPCTL_LOG, log, CTLFLAG_RW, 140a9771948SGleb Smirnoff &carp_opts[CARPCTL_LOG], 0, "log bad carp packets"); 141a9771948SGleb Smirnoff SYSCTL_INT(_net_inet_carp, CARPCTL_ARPBALANCE, arpbalance, CTLFLAG_RW, 142a9771948SGleb Smirnoff &carp_opts[CARPCTL_ARPBALANCE], 0, "balance arp responses"); 14332247f86SGleb Smirnoff SYSCTL_INT(_net_inet_carp, OID_AUTO, suppress_preempt, CTLFLAG_RD, 14432247f86SGleb Smirnoff &carp_suppress_preempt, 0, "Preemption is suppressed"); 145a9771948SGleb Smirnoff 146a9771948SGleb Smirnoff struct carpstats carpstats; 147a9771948SGleb Smirnoff SYSCTL_STRUCT(_net_inet_carp, CARPCTL_STATS, stats, CTLFLAG_RW, 148a9771948SGleb Smirnoff &carpstats, carpstats, 149a9771948SGleb Smirnoff "CARP statistics (struct carpstats, netinet/ip_carp.h)"); 150a9771948SGleb Smirnoff 151a9771948SGleb Smirnoff struct carp_if { 152a9771948SGleb Smirnoff TAILQ_HEAD(, carp_softc) vhif_vrs; 153a9771948SGleb Smirnoff int vhif_nvrs; 154a9771948SGleb Smirnoff 155a9771948SGleb Smirnoff struct ifnet *vhif_ifp; 156a9771948SGleb Smirnoff struct mtx vhif_mtx; 157a9771948SGleb Smirnoff }; 158d220759bSGleb Smirnoff 159d220759bSGleb Smirnoff /* Get carp_if from softc. Valid after carp_set_addr{,6}. */ 160d220759bSGleb Smirnoff #define SC2CIF(sc) ((struct carp_if *)(sc)->sc_carpdev->if_carp) 161d220759bSGleb Smirnoff 162a9771948SGleb Smirnoff /* lock per carp_if queue */ 163d220759bSGleb Smirnoff #define CARP_LOCK_INIT(cif) mtx_init(&(cif)->vhif_mtx, "carp_if", \ 164a9771948SGleb Smirnoff NULL, MTX_DEF) 165d220759bSGleb Smirnoff #define CARP_LOCK_DESTROY(cif) mtx_destroy(&(cif)->vhif_mtx) 166a9771948SGleb Smirnoff #define CARP_LOCK_ASSERT(cif) mtx_assert(&(cif)->vhif_mtx, MA_OWNED) 167a9771948SGleb Smirnoff #define CARP_LOCK(cif) mtx_lock(&(cif)->vhif_mtx) 168a9771948SGleb Smirnoff #define CARP_UNLOCK(cif) mtx_unlock(&(cif)->vhif_mtx) 169a9771948SGleb Smirnoff 170d220759bSGleb Smirnoff #define CARP_SCLOCK(sc) mtx_lock(&SC2CIF(sc)->vhif_mtx) 171d220759bSGleb Smirnoff #define CARP_SCUNLOCK(sc) mtx_unlock(&SC2CIF(sc)->vhif_mtx) 172d220759bSGleb Smirnoff #define CARP_SCLOCK_ASSERT(sc) mtx_assert(&SC2CIF(sc)->vhif_mtx, MA_OWNED) 173d220759bSGleb Smirnoff 174947b7cf3SGleb Smirnoff #define CARP_LOG(...) do { \ 1751e9e6572SGleb Smirnoff if (carp_opts[CARPCTL_LOG] > 0) \ 1761e9e6572SGleb Smirnoff log(LOG_INFO, __VA_ARGS__); \ 177947b7cf3SGleb Smirnoff } while (0) 1781e9e6572SGleb Smirnoff 179947b7cf3SGleb Smirnoff #define CARP_DEBUG(...) do { \ 1801e9e6572SGleb Smirnoff if (carp_opts[CARPCTL_LOG] > 1) \ 1811e9e6572SGleb Smirnoff log(LOG_DEBUG, __VA_ARGS__); \ 182947b7cf3SGleb Smirnoff } while (0) 183a9771948SGleb Smirnoff 1845c1f0f6dSGleb Smirnoff static void carp_hmac_prepare(struct carp_softc *); 1855c1f0f6dSGleb Smirnoff static void carp_hmac_generate(struct carp_softc *, u_int32_t *, 186a9771948SGleb Smirnoff unsigned char *); 1875c1f0f6dSGleb Smirnoff static int carp_hmac_verify(struct carp_softc *, u_int32_t *, 188a9771948SGleb Smirnoff unsigned char *); 1895c1f0f6dSGleb Smirnoff static void carp_setroute(struct carp_softc *, int); 1905c1f0f6dSGleb Smirnoff static void carp_input_c(struct mbuf *, struct carp_header *, sa_family_t); 1915c1f0f6dSGleb Smirnoff static int carp_clone_create(struct if_clone *, int); 1925c1f0f6dSGleb Smirnoff static void carp_clone_destroy(struct ifnet *); 1935c1f0f6dSGleb Smirnoff static void carpdetach(struct carp_softc *); 1945c1f0f6dSGleb Smirnoff static int carp_prepare_ad(struct mbuf *, struct carp_softc *, 195a9771948SGleb Smirnoff struct carp_header *); 1965c1f0f6dSGleb Smirnoff static void carp_send_ad_all(void); 1975c1f0f6dSGleb Smirnoff static void carp_send_ad(void *); 198d220759bSGleb Smirnoff static void carp_send_ad_locked(struct carp_softc *); 1995c1f0f6dSGleb Smirnoff static void carp_send_arp(struct carp_softc *); 2005c1f0f6dSGleb Smirnoff static void carp_master_down(void *); 201d220759bSGleb Smirnoff static void carp_master_down_locked(struct carp_softc *); 2025c1f0f6dSGleb Smirnoff static int carp_ioctl(struct ifnet *, u_long, caddr_t); 203a9771948SGleb Smirnoff static int carp_looutput(struct ifnet *, struct mbuf *, struct sockaddr *, 204a9771948SGleb Smirnoff struct rtentry *); 2055c1f0f6dSGleb Smirnoff static void carp_start(struct ifnet *); 2065c1f0f6dSGleb Smirnoff static void carp_setrun(struct carp_softc *, sa_family_t); 2075c1f0f6dSGleb Smirnoff static void carp_set_state(struct carp_softc *, int); 2085c1f0f6dSGleb Smirnoff static int carp_addrcount(struct carp_if *, struct in_ifaddr *, int); 209a9771948SGleb Smirnoff enum { CARP_COUNT_MASTER, CARP_COUNT_RUNNING }; 210a9771948SGleb Smirnoff 2115c1f0f6dSGleb Smirnoff static int carp_set_addr(struct carp_softc *, struct sockaddr_in *); 2125c1f0f6dSGleb Smirnoff static int carp_del_addr(struct carp_softc *, struct sockaddr_in *); 213d220759bSGleb Smirnoff static void carp_carpdev_state_locked(struct carp_if *); 2144cb39345SGleb Smirnoff static void carp_sc_state_locked(struct carp_softc *); 215a9771948SGleb Smirnoff #ifdef INET6 2165c1f0f6dSGleb Smirnoff static void carp_send_na(struct carp_softc *); 2175c1f0f6dSGleb Smirnoff static int carp_set_addr6(struct carp_softc *, struct sockaddr_in6 *); 2185c1f0f6dSGleb Smirnoff static int carp_del_addr6(struct carp_softc *, struct sockaddr_in6 *); 219a9771948SGleb Smirnoff #endif 220a9771948SGleb Smirnoff 221a9771948SGleb Smirnoff static LIST_HEAD(, carp_softc) carpif_list; 222d92d54d5SGleb Smirnoff static struct mtx carp_mtx; 223a9771948SGleb Smirnoff IFC_SIMPLE_DECLARE(carp, 0); 224a9771948SGleb Smirnoff 225a9771948SGleb Smirnoff static __inline u_int16_t 226a9771948SGleb Smirnoff carp_cksum(struct mbuf *m, int len) 227a9771948SGleb Smirnoff { 228a9771948SGleb Smirnoff return (in_cksum(m, len)); 229a9771948SGleb Smirnoff } 230a9771948SGleb Smirnoff 2315c1f0f6dSGleb Smirnoff static void 232a9771948SGleb Smirnoff carp_hmac_prepare(struct carp_softc *sc) 233a9771948SGleb Smirnoff { 234a9771948SGleb Smirnoff u_int8_t version = CARP_VERSION, type = CARP_ADVERTISEMENT; 235a9771948SGleb Smirnoff u_int8_t vhid = sc->sc_vhid & 0xff; 236a9771948SGleb Smirnoff struct ifaddr *ifa; 237a9771948SGleb Smirnoff int i; 238a9771948SGleb Smirnoff #ifdef INET6 239a9771948SGleb Smirnoff struct in6_addr in6; 240a9771948SGleb Smirnoff #endif 241a9771948SGleb Smirnoff 242d220759bSGleb Smirnoff if (sc->sc_carpdev) 243d220759bSGleb Smirnoff CARP_SCLOCK(sc); 244d220759bSGleb Smirnoff 245d220759bSGleb Smirnoff /* XXX: possible race here */ 246d220759bSGleb Smirnoff 247a9771948SGleb Smirnoff /* compute ipad from key */ 248a9771948SGleb Smirnoff bzero(sc->sc_pad, sizeof(sc->sc_pad)); 249a9771948SGleb Smirnoff bcopy(sc->sc_key, sc->sc_pad, sizeof(sc->sc_key)); 250a9771948SGleb Smirnoff for (i = 0; i < sizeof(sc->sc_pad); i++) 251a9771948SGleb Smirnoff sc->sc_pad[i] ^= 0x36; 252a9771948SGleb Smirnoff 253a9771948SGleb Smirnoff /* precompute first part of inner hash */ 254a9771948SGleb Smirnoff SHA1Init(&sc->sc_sha1); 255a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, sc->sc_pad, sizeof(sc->sc_pad)); 256a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, (void *)&version, sizeof(version)); 257a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, (void *)&type, sizeof(type)); 258a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, (void *)&vhid, sizeof(vhid)); 259a9771948SGleb Smirnoff #ifdef INET 260fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 261a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET) 262a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, 263a9771948SGleb Smirnoff (void *)&ifatoia(ifa)->ia_addr.sin_addr.s_addr, 264a9771948SGleb Smirnoff sizeof(struct in_addr)); 265a9771948SGleb Smirnoff } 266a9771948SGleb Smirnoff #endif /* INET */ 267a9771948SGleb Smirnoff #ifdef INET6 268fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 269a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET6) { 270a9771948SGleb Smirnoff in6 = ifatoia6(ifa)->ia_addr.sin6_addr; 271a1f7e5f8SHajimu UMEMOTO in6_clearscope(&in6); 272a9771948SGleb Smirnoff SHA1Update(&sc->sc_sha1, (void *)&in6, sizeof(in6)); 273a9771948SGleb Smirnoff } 274a9771948SGleb Smirnoff } 275a9771948SGleb Smirnoff #endif /* INET6 */ 276a9771948SGleb Smirnoff 277a9771948SGleb Smirnoff /* convert ipad to opad */ 278a9771948SGleb Smirnoff for (i = 0; i < sizeof(sc->sc_pad); i++) 279a9771948SGleb Smirnoff sc->sc_pad[i] ^= 0x36 ^ 0x5c; 280d220759bSGleb Smirnoff 281d220759bSGleb Smirnoff if (sc->sc_carpdev) 282d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 283a9771948SGleb Smirnoff } 284a9771948SGleb Smirnoff 2855c1f0f6dSGleb Smirnoff static void 286a9771948SGleb Smirnoff carp_hmac_generate(struct carp_softc *sc, u_int32_t counter[2], 287a9771948SGleb Smirnoff unsigned char md[20]) 288a9771948SGleb Smirnoff { 289a9771948SGleb Smirnoff SHA1_CTX sha1ctx; 290a9771948SGleb Smirnoff 291a9771948SGleb Smirnoff /* fetch first half of inner hash */ 292a9771948SGleb Smirnoff bcopy(&sc->sc_sha1, &sha1ctx, sizeof(sha1ctx)); 293a9771948SGleb Smirnoff 294a9771948SGleb Smirnoff SHA1Update(&sha1ctx, (void *)counter, sizeof(sc->sc_counter)); 295a9771948SGleb Smirnoff SHA1Final(md, &sha1ctx); 296a9771948SGleb Smirnoff 297a9771948SGleb Smirnoff /* outer hash */ 298a9771948SGleb Smirnoff SHA1Init(&sha1ctx); 299a9771948SGleb Smirnoff SHA1Update(&sha1ctx, sc->sc_pad, sizeof(sc->sc_pad)); 300a9771948SGleb Smirnoff SHA1Update(&sha1ctx, md, 20); 301a9771948SGleb Smirnoff SHA1Final(md, &sha1ctx); 302a9771948SGleb Smirnoff } 303a9771948SGleb Smirnoff 3045c1f0f6dSGleb Smirnoff static int 305a9771948SGleb Smirnoff carp_hmac_verify(struct carp_softc *sc, u_int32_t counter[2], 306a9771948SGleb Smirnoff unsigned char md[20]) 307a9771948SGleb Smirnoff { 308a9771948SGleb Smirnoff unsigned char md2[20]; 309a9771948SGleb Smirnoff 310d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 311d220759bSGleb Smirnoff 312a9771948SGleb Smirnoff carp_hmac_generate(sc, counter, md2); 313a9771948SGleb Smirnoff 314a9771948SGleb Smirnoff return (bcmp(md, md2, sizeof(md2))); 315a9771948SGleb Smirnoff } 316a9771948SGleb Smirnoff 3175c1f0f6dSGleb Smirnoff static void 318a9771948SGleb Smirnoff carp_setroute(struct carp_softc *sc, int cmd) 319a9771948SGleb Smirnoff { 320a9771948SGleb Smirnoff struct ifaddr *ifa; 321a9771948SGleb Smirnoff int s; 322a9771948SGleb Smirnoff 323d220759bSGleb Smirnoff if (sc->sc_carpdev) 324d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 325d220759bSGleb Smirnoff 326a9771948SGleb Smirnoff s = splnet(); 327fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 328d220759bSGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET && 329d220759bSGleb Smirnoff sc->sc_carpdev != NULL) { 330a9771948SGleb Smirnoff int count = carp_addrcount( 331e8c34a71SGleb Smirnoff (struct carp_if *)sc->sc_carpdev->if_carp, 332a9771948SGleb Smirnoff ifatoia(ifa), CARP_COUNT_MASTER); 333a9771948SGleb Smirnoff 334a9771948SGleb Smirnoff if ((cmd == RTM_ADD && count == 1) || 335a9771948SGleb Smirnoff (cmd == RTM_DELETE && count == 0)) 336a9771948SGleb Smirnoff rtinit(ifa, cmd, RTF_UP | RTF_HOST); 337a9771948SGleb Smirnoff } 338a9771948SGleb Smirnoff #ifdef INET6 339a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET6) { 340a9771948SGleb Smirnoff if (cmd == RTM_ADD) 341a9771948SGleb Smirnoff in6_ifaddloop(ifa); 342a9771948SGleb Smirnoff else 343a9771948SGleb Smirnoff in6_ifremloop(ifa); 344a9771948SGleb Smirnoff } 345a9771948SGleb Smirnoff #endif /* INET6 */ 346a9771948SGleb Smirnoff } 347a9771948SGleb Smirnoff splx(s); 348a9771948SGleb Smirnoff } 349a9771948SGleb Smirnoff 3505c1f0f6dSGleb Smirnoff static int 351a9771948SGleb Smirnoff carp_clone_create(struct if_clone *ifc, int unit) 352a9771948SGleb Smirnoff { 353a9771948SGleb Smirnoff 354a9771948SGleb Smirnoff struct carp_softc *sc; 355a9771948SGleb Smirnoff struct ifnet *ifp; 356a9771948SGleb Smirnoff 357a9771948SGleb Smirnoff MALLOC(sc, struct carp_softc *, sizeof(*sc), M_CARP, M_WAITOK|M_ZERO); 358fc74a9f9SBrooks Davis ifp = SC2IFP(sc) = if_alloc(IFT_ETHER); 359fc74a9f9SBrooks Davis if (ifp == NULL) { 360fc74a9f9SBrooks Davis FREE(sc, M_CARP); 361fc74a9f9SBrooks Davis return (ENOSPC); 362fc74a9f9SBrooks Davis } 363a9771948SGleb Smirnoff 364a9771948SGleb Smirnoff sc->sc_flags_backup = 0; 365a9771948SGleb Smirnoff sc->sc_suppress = 0; 366a9771948SGleb Smirnoff sc->sc_advbase = CARP_DFLTINTV; 367a9771948SGleb Smirnoff sc->sc_vhid = -1; /* required setting */ 368a9771948SGleb Smirnoff sc->sc_advskew = 0; 369a9771948SGleb Smirnoff sc->sc_init_counter = 1; 370a9771948SGleb Smirnoff sc->sc_naddrs = sc->sc_naddrs6 = 0; /* M_ZERO? */ 371a9771948SGleb Smirnoff #ifdef INET6 372a9771948SGleb Smirnoff sc->sc_im6o.im6o_multicast_hlim = CARP_DFLTTL; 373a9771948SGleb Smirnoff #endif 374a9771948SGleb Smirnoff 375d220759bSGleb Smirnoff callout_init(&sc->sc_ad_tmo, NET_CALLOUT_MPSAFE); 376d220759bSGleb Smirnoff callout_init(&sc->sc_md_tmo, NET_CALLOUT_MPSAFE); 377d220759bSGleb Smirnoff callout_init(&sc->sc_md6_tmo, NET_CALLOUT_MPSAFE); 378a9771948SGleb Smirnoff 379a9771948SGleb Smirnoff ifp->if_softc = sc; 380a9771948SGleb Smirnoff if_initname(ifp, CARP_IFNAME, unit); 381a9771948SGleb Smirnoff ifp->if_mtu = ETHERMTU; 382a9771948SGleb Smirnoff ifp->if_flags = 0; 383a9771948SGleb Smirnoff ifp->if_ioctl = carp_ioctl; 384a9771948SGleb Smirnoff ifp->if_output = carp_looutput; 385a9771948SGleb Smirnoff ifp->if_start = carp_start; 386a9771948SGleb Smirnoff ifp->if_type = IFT_CARP; 387a9771948SGleb Smirnoff ifp->if_snd.ifq_maxlen = ifqmaxlen; 388a9771948SGleb Smirnoff ifp->if_hdrlen = 0; 389a9771948SGleb Smirnoff if_attach(ifp); 390fc74a9f9SBrooks Davis bpfattach(SC2IFP(sc), DLT_NULL, sizeof(u_int32_t)); 391d92d54d5SGleb Smirnoff mtx_lock(&carp_mtx); 392d92d54d5SGleb Smirnoff LIST_INSERT_HEAD(&carpif_list, sc, sc_next); 393d92d54d5SGleb Smirnoff mtx_unlock(&carp_mtx); 394a9771948SGleb Smirnoff return (0); 395a9771948SGleb Smirnoff } 396a9771948SGleb Smirnoff 3975c1f0f6dSGleb Smirnoff static void 398a9771948SGleb Smirnoff carp_clone_destroy(struct ifnet *ifp) 399a9771948SGleb Smirnoff { 400a9771948SGleb Smirnoff struct carp_softc *sc = ifp->if_softc; 401a9771948SGleb Smirnoff struct carp_if *cif; 402a9771948SGleb Smirnoff struct ip_moptions *imo = &sc->sc_imo; 403a9771948SGleb Smirnoff #ifdef INET6 404a9771948SGleb Smirnoff struct ip6_moptions *im6o = &sc->sc_im6o; 405a9771948SGleb Smirnoff #endif 406a9771948SGleb Smirnoff 407a9771948SGleb Smirnoff /* carpdetach(sc); */ 408a9771948SGleb Smirnoff 40932247f86SGleb Smirnoff /* 41032247f86SGleb Smirnoff * If an interface is destroyed which is suppressing the preemption, 41132247f86SGleb Smirnoff * decrease the global counter, otherwise the host will never get 41232247f86SGleb Smirnoff * out of the carp supressing state. 41332247f86SGleb Smirnoff */ 41432247f86SGleb Smirnoff if (sc->sc_suppress) 41532247f86SGleb Smirnoff carp_suppress_preempt--; 41632247f86SGleb Smirnoff sc->sc_suppress = 0; 41732247f86SGleb Smirnoff 418a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 419a9771948SGleb Smirnoff callout_stop(&sc->sc_md_tmo); 420a9771948SGleb Smirnoff callout_stop(&sc->sc_md6_tmo); 421a9771948SGleb Smirnoff 422a9771948SGleb Smirnoff if (imo->imo_num_memberships) { 423a9771948SGleb Smirnoff in_delmulti(imo->imo_membership[--imo->imo_num_memberships]); 424a9771948SGleb Smirnoff imo->imo_multicast_ifp = NULL; 425a9771948SGleb Smirnoff } 426a9771948SGleb Smirnoff #ifdef INET6 427a9771948SGleb Smirnoff while (!LIST_EMPTY(&im6o->im6o_memberships)) { 428a9771948SGleb Smirnoff struct in6_multi_mship *imm = 429a9771948SGleb Smirnoff LIST_FIRST(&im6o->im6o_memberships); 430a9771948SGleb Smirnoff LIST_REMOVE(imm, i6mm_chain); 431a9771948SGleb Smirnoff in6_leavegroup(imm); 432a9771948SGleb Smirnoff } 433a9771948SGleb Smirnoff im6o->im6o_multicast_ifp = NULL; 434a9771948SGleb Smirnoff #endif 435a9771948SGleb Smirnoff 436a9771948SGleb Smirnoff /* Remove ourself from parents if_carp queue */ 437e8c34a71SGleb Smirnoff if (sc->sc_carpdev && (cif = sc->sc_carpdev->if_carp)) { 438a9771948SGleb Smirnoff CARP_LOCK(cif); 439a9771948SGleb Smirnoff TAILQ_REMOVE(&cif->vhif_vrs, sc, sc_list); 440a9771948SGleb Smirnoff if (!--cif->vhif_nvrs) { 441e8c34a71SGleb Smirnoff sc->sc_carpdev->if_carp = NULL; 442a9771948SGleb Smirnoff CARP_LOCK_DESTROY(cif); 443a9771948SGleb Smirnoff FREE(cif, M_CARP); 444e8c34a71SGleb Smirnoff ifpromisc(sc->sc_carpdev, 0); 445a9771948SGleb Smirnoff } else { 446a9771948SGleb Smirnoff CARP_UNLOCK(cif); 447a9771948SGleb Smirnoff } 448a9771948SGleb Smirnoff } 449a9771948SGleb Smirnoff 450d92d54d5SGleb Smirnoff mtx_lock(&carp_mtx); 451d92d54d5SGleb Smirnoff LIST_REMOVE(sc, sc_next); 452d92d54d5SGleb Smirnoff mtx_unlock(&carp_mtx); 453a9771948SGleb Smirnoff bpfdetach(ifp); 454a9771948SGleb Smirnoff if_detach(ifp); 455fc74a9f9SBrooks Davis if_free_type(ifp, IFT_ETHER); 456a9771948SGleb Smirnoff free(sc, M_CARP); 457a9771948SGleb Smirnoff } 458a9771948SGleb Smirnoff 459a9771948SGleb Smirnoff /* 460a9771948SGleb Smirnoff * process input packet. 461a9771948SGleb Smirnoff * we have rearranged checks order compared to the rfc, 462a9771948SGleb Smirnoff * but it seems more efficient this way or not possible otherwise. 463a9771948SGleb Smirnoff */ 464a9771948SGleb Smirnoff void 465a9771948SGleb Smirnoff carp_input(struct mbuf *m, int hlen) 466a9771948SGleb Smirnoff { 467a9771948SGleb Smirnoff struct ip *ip = mtod(m, struct ip *); 468a9771948SGleb Smirnoff struct carp_header *ch; 469a9771948SGleb Smirnoff int iplen, len; 470a9771948SGleb Smirnoff 471a9771948SGleb Smirnoff carpstats.carps_ipackets++; 472a9771948SGleb Smirnoff 473a9771948SGleb Smirnoff if (!carp_opts[CARPCTL_ALLOW]) { 474a9771948SGleb Smirnoff m_freem(m); 475a9771948SGleb Smirnoff return; 476a9771948SGleb Smirnoff } 477a9771948SGleb Smirnoff 478a9771948SGleb Smirnoff /* check if received on a valid carp interface */ 479a9771948SGleb Smirnoff if (m->m_pkthdr.rcvif->if_carp == NULL) { 480a9771948SGleb Smirnoff carpstats.carps_badif++; 48188bf82a6SGleb Smirnoff CARP_LOG("carp_input: packet received on non-carp " 48288bf82a6SGleb Smirnoff "interface: %s\n", 4831e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 484a9771948SGleb Smirnoff m_freem(m); 485a9771948SGleb Smirnoff return; 486a9771948SGleb Smirnoff } 487a9771948SGleb Smirnoff 488a9771948SGleb Smirnoff /* verify that the IP TTL is 255. */ 489a9771948SGleb Smirnoff if (ip->ip_ttl != CARP_DFLTTL) { 490a9771948SGleb Smirnoff carpstats.carps_badttl++; 49188bf82a6SGleb Smirnoff CARP_LOG("carp_input: received ttl %d != 255i on %s\n", 4921e9e6572SGleb Smirnoff ip->ip_ttl, 4931e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 494a9771948SGleb Smirnoff m_freem(m); 495a9771948SGleb Smirnoff return; 496a9771948SGleb Smirnoff } 497a9771948SGleb Smirnoff 498a9771948SGleb Smirnoff iplen = ip->ip_hl << 2; 499a9771948SGleb Smirnoff 500a9771948SGleb Smirnoff if (m->m_pkthdr.len < iplen + sizeof(*ch)) { 501a9771948SGleb Smirnoff carpstats.carps_badlen++; 5021e9e6572SGleb Smirnoff CARP_LOG("carp_input: received len %zd < " 50388bf82a6SGleb Smirnoff "sizeof(struct carp_header)\n", 5041e9e6572SGleb Smirnoff m->m_len - sizeof(struct ip)); 505a9771948SGleb Smirnoff m_freem(m); 506a9771948SGleb Smirnoff return; 507a9771948SGleb Smirnoff } 508a9771948SGleb Smirnoff 509a9771948SGleb Smirnoff if (iplen + sizeof(*ch) < m->m_len) { 510a9771948SGleb Smirnoff if ((m = m_pullup(m, iplen + sizeof(*ch))) == NULL) { 511a9771948SGleb Smirnoff carpstats.carps_hdrops++; 51288bf82a6SGleb Smirnoff CARP_LOG("carp_input: pullup failed\n"); 513a9771948SGleb Smirnoff return; 514a9771948SGleb Smirnoff } 515a9771948SGleb Smirnoff ip = mtod(m, struct ip *); 516a9771948SGleb Smirnoff } 517a9771948SGleb Smirnoff ch = (struct carp_header *)((char *)ip + iplen); 518a9771948SGleb Smirnoff 519a9771948SGleb Smirnoff /* 520a9771948SGleb Smirnoff * verify that the received packet length is 521a9771948SGleb Smirnoff * equal to the CARP header 522a9771948SGleb Smirnoff */ 523a9771948SGleb Smirnoff len = iplen + sizeof(*ch); 524a9771948SGleb Smirnoff if (len > m->m_pkthdr.len) { 525a9771948SGleb Smirnoff carpstats.carps_badlen++; 52688bf82a6SGleb Smirnoff CARP_LOG("carp_input: packet too short %d on %s\n", 5271e9e6572SGleb Smirnoff m->m_pkthdr.len, 5281e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 529a9771948SGleb Smirnoff m_freem(m); 530a9771948SGleb Smirnoff return; 531a9771948SGleb Smirnoff } 532a9771948SGleb Smirnoff 533a9771948SGleb Smirnoff if ((m = m_pullup(m, len)) == NULL) { 534a9771948SGleb Smirnoff carpstats.carps_hdrops++; 535a9771948SGleb Smirnoff return; 536a9771948SGleb Smirnoff } 537a9771948SGleb Smirnoff ip = mtod(m, struct ip *); 538a9771948SGleb Smirnoff ch = (struct carp_header *)((char *)ip + iplen); 539a9771948SGleb Smirnoff 540a9771948SGleb Smirnoff /* verify the CARP checksum */ 541a9771948SGleb Smirnoff m->m_data += iplen; 542a9771948SGleb Smirnoff if (carp_cksum(m, len - iplen)) { 543a9771948SGleb Smirnoff carpstats.carps_badsum++; 54488bf82a6SGleb Smirnoff CARP_LOG("carp_input: checksum failed on %s\n", 5451e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 546a9771948SGleb Smirnoff m_freem(m); 547a9771948SGleb Smirnoff return; 548a9771948SGleb Smirnoff } 549a9771948SGleb Smirnoff m->m_data -= iplen; 550a9771948SGleb Smirnoff 5511e9e6572SGleb Smirnoff carp_input_c(m, ch, AF_INET); 552a9771948SGleb Smirnoff } 553a9771948SGleb Smirnoff 554a9771948SGleb Smirnoff #ifdef INET6 555a9771948SGleb Smirnoff int 556a9771948SGleb Smirnoff carp6_input(struct mbuf **mp, int *offp, int proto) 557a9771948SGleb Smirnoff { 558a9771948SGleb Smirnoff struct mbuf *m = *mp; 559a9771948SGleb Smirnoff struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); 560a9771948SGleb Smirnoff struct carp_header *ch; 561a9771948SGleb Smirnoff u_int len; 562a9771948SGleb Smirnoff 563a9771948SGleb Smirnoff carpstats.carps_ipackets6++; 564a9771948SGleb Smirnoff 565a9771948SGleb Smirnoff if (!carp_opts[CARPCTL_ALLOW]) { 566a9771948SGleb Smirnoff m_freem(m); 567a9771948SGleb Smirnoff return (IPPROTO_DONE); 568a9771948SGleb Smirnoff } 569a9771948SGleb Smirnoff 570a9771948SGleb Smirnoff /* check if received on a valid carp interface */ 571a9771948SGleb Smirnoff if (m->m_pkthdr.rcvif->if_carp == NULL) { 572a9771948SGleb Smirnoff carpstats.carps_badif++; 5731e9e6572SGleb Smirnoff CARP_LOG("carp6_input: packet received on non-carp " 57488bf82a6SGleb Smirnoff "interface: %s\n", 5751e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 576a9771948SGleb Smirnoff m_freem(m); 577a9771948SGleb Smirnoff return (IPPROTO_DONE); 578a9771948SGleb Smirnoff } 579a9771948SGleb Smirnoff 580a9771948SGleb Smirnoff /* verify that the IP TTL is 255 */ 581a9771948SGleb Smirnoff if (ip6->ip6_hlim != CARP_DFLTTL) { 582a9771948SGleb Smirnoff carpstats.carps_badttl++; 58388bf82a6SGleb Smirnoff CARP_LOG("carp6_input: received ttl %d != 255 on %s\n", 5841e9e6572SGleb Smirnoff ip6->ip6_hlim, 5851e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 586a9771948SGleb Smirnoff m_freem(m); 587a9771948SGleb Smirnoff return (IPPROTO_DONE); 588a9771948SGleb Smirnoff } 589a9771948SGleb Smirnoff 590a9771948SGleb Smirnoff /* verify that we have a complete carp packet */ 591a9771948SGleb Smirnoff len = m->m_len; 592a9771948SGleb Smirnoff IP6_EXTHDR_GET(ch, struct carp_header *, m, *offp, sizeof(*ch)); 593a9771948SGleb Smirnoff if (ch == NULL) { 594a9771948SGleb Smirnoff carpstats.carps_badlen++; 5959860bab3SGleb Smirnoff CARP_LOG("carp6_input: packet size %u too small\n", len); 596a9771948SGleb Smirnoff return (IPPROTO_DONE); 597a9771948SGleb Smirnoff } 598a9771948SGleb Smirnoff 599a9771948SGleb Smirnoff 600a9771948SGleb Smirnoff /* verify the CARP checksum */ 601a9771948SGleb Smirnoff m->m_data += *offp; 602a9771948SGleb Smirnoff if (carp_cksum(m, sizeof(*ch))) { 603a9771948SGleb Smirnoff carpstats.carps_badsum++; 60488bf82a6SGleb Smirnoff CARP_LOG("carp6_input: checksum failed, on %s\n", 6051e9e6572SGleb Smirnoff m->m_pkthdr.rcvif->if_xname); 606a9771948SGleb Smirnoff m_freem(m); 607a9771948SGleb Smirnoff return (IPPROTO_DONE); 608a9771948SGleb Smirnoff } 609a9771948SGleb Smirnoff m->m_data -= *offp; 610a9771948SGleb Smirnoff 6111e9e6572SGleb Smirnoff carp_input_c(m, ch, AF_INET6); 612a9771948SGleb Smirnoff return (IPPROTO_DONE); 613a9771948SGleb Smirnoff } 614a9771948SGleb Smirnoff #endif /* INET6 */ 615a9771948SGleb Smirnoff 6165c1f0f6dSGleb Smirnoff static void 6171e9e6572SGleb Smirnoff carp_input_c(struct mbuf *m, struct carp_header *ch, sa_family_t af) 618a9771948SGleb Smirnoff { 619a9771948SGleb Smirnoff struct ifnet *ifp = m->m_pkthdr.rcvif; 6201e9e6572SGleb Smirnoff struct carp_softc *sc; 621a9771948SGleb Smirnoff u_int64_t tmp_counter; 622a9771948SGleb Smirnoff struct timeval sc_tv, ch_tv; 623a9771948SGleb Smirnoff 624a9771948SGleb Smirnoff /* verify that the VHID is valid on the receiving interface */ 625a9771948SGleb Smirnoff CARP_LOCK(ifp->if_carp); 626a9771948SGleb Smirnoff TAILQ_FOREACH(sc, &((struct carp_if *)ifp->if_carp)->vhif_vrs, sc_list) 627a9771948SGleb Smirnoff if (sc->sc_vhid == ch->carp_vhid) 628a9771948SGleb Smirnoff break; 629d220759bSGleb Smirnoff 630fc74a9f9SBrooks Davis if (!sc || (SC2IFP(sc)->if_flags & (IFF_UP|IFF_RUNNING)) != 631a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) { 632a9771948SGleb Smirnoff carpstats.carps_badvhid++; 633d220759bSGleb Smirnoff CARP_UNLOCK(ifp->if_carp); 634a9771948SGleb Smirnoff m_freem(m); 635a9771948SGleb Smirnoff return; 636a9771948SGleb Smirnoff } 637a9771948SGleb Smirnoff 638fc74a9f9SBrooks Davis getmicrotime(&SC2IFP(sc)->if_lastchange); 639fc74a9f9SBrooks Davis SC2IFP(sc)->if_ipackets++; 640fc74a9f9SBrooks Davis SC2IFP(sc)->if_ibytes += m->m_pkthdr.len; 641a9771948SGleb Smirnoff 642fc74a9f9SBrooks Davis if (SC2IFP(sc)->if_bpf) { 643a9771948SGleb Smirnoff struct ip *ip = mtod(m, struct ip *); 6443e07def4SGleb Smirnoff uint32_t af1 = af; 645a9771948SGleb Smirnoff 646a9771948SGleb Smirnoff /* BPF wants net byte order */ 6473e07def4SGleb Smirnoff ip->ip_len = htons(ip->ip_len + (ip->ip_hl << 2)); 6483e07def4SGleb Smirnoff ip->ip_off = htons(ip->ip_off); 649fc74a9f9SBrooks Davis bpf_mtap2(SC2IFP(sc)->if_bpf, &af1, sizeof(af1), m); 650a9771948SGleb Smirnoff } 651a9771948SGleb Smirnoff 652a9771948SGleb Smirnoff /* verify the CARP version. */ 653a9771948SGleb Smirnoff if (ch->carp_version != CARP_VERSION) { 654a9771948SGleb Smirnoff carpstats.carps_badver++; 655fc74a9f9SBrooks Davis SC2IFP(sc)->if_ierrors++; 656d220759bSGleb Smirnoff CARP_UNLOCK(ifp->if_carp); 65788bf82a6SGleb Smirnoff CARP_LOG("%s; invalid version %d\n", 658fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname, 6591e9e6572SGleb Smirnoff ch->carp_version); 660a9771948SGleb Smirnoff m_freem(m); 661a9771948SGleb Smirnoff return; 662a9771948SGleb Smirnoff } 663a9771948SGleb Smirnoff 664a9771948SGleb Smirnoff /* verify the hash */ 665a9771948SGleb Smirnoff if (carp_hmac_verify(sc, ch->carp_counter, ch->carp_md)) { 666a9771948SGleb Smirnoff carpstats.carps_badauth++; 667fc74a9f9SBrooks Davis SC2IFP(sc)->if_ierrors++; 668d220759bSGleb Smirnoff CARP_UNLOCK(ifp->if_carp); 669fc74a9f9SBrooks Davis CARP_LOG("%s: incorrect hash\n", SC2IFP(sc)->if_xname); 670a9771948SGleb Smirnoff m_freem(m); 671a9771948SGleb Smirnoff return; 672a9771948SGleb Smirnoff } 673a9771948SGleb Smirnoff 674a9771948SGleb Smirnoff tmp_counter = ntohl(ch->carp_counter[0]); 675a9771948SGleb Smirnoff tmp_counter = tmp_counter<<32; 676a9771948SGleb Smirnoff tmp_counter += ntohl(ch->carp_counter[1]); 677a9771948SGleb Smirnoff 678a9771948SGleb Smirnoff /* XXX Replay protection goes here */ 679a9771948SGleb Smirnoff 680a9771948SGleb Smirnoff sc->sc_init_counter = 0; 681a9771948SGleb Smirnoff sc->sc_counter = tmp_counter; 682a9771948SGleb Smirnoff 683a9771948SGleb Smirnoff sc_tv.tv_sec = sc->sc_advbase; 684a9771948SGleb Smirnoff if (carp_suppress_preempt && sc->sc_advskew < 240) 685a9771948SGleb Smirnoff sc_tv.tv_usec = 240 * 1000000 / 256; 686a9771948SGleb Smirnoff else 687a9771948SGleb Smirnoff sc_tv.tv_usec = sc->sc_advskew * 1000000 / 256; 688a9771948SGleb Smirnoff ch_tv.tv_sec = ch->carp_advbase; 689a9771948SGleb Smirnoff ch_tv.tv_usec = ch->carp_advskew * 1000000 / 256; 690a9771948SGleb Smirnoff 691a9771948SGleb Smirnoff switch (sc->sc_state) { 692a9771948SGleb Smirnoff case INIT: 693a9771948SGleb Smirnoff break; 694a9771948SGleb Smirnoff case MASTER: 695a9771948SGleb Smirnoff /* 696a9771948SGleb Smirnoff * If we receive an advertisement from a master who's going to 697a9771948SGleb Smirnoff * be more frequent than us, go into BACKUP state. 698a9771948SGleb Smirnoff */ 699a9771948SGleb Smirnoff if (timevalcmp(&sc_tv, &ch_tv, >) || 700a9771948SGleb Smirnoff timevalcmp(&sc_tv, &ch_tv, ==)) { 701a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 7021e9e6572SGleb Smirnoff CARP_DEBUG("%s: MASTER -> BACKUP " 70388bf82a6SGleb Smirnoff "(more frequent advertisement received)\n", 704fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname); 705a9771948SGleb Smirnoff carp_set_state(sc, BACKUP); 706a9771948SGleb Smirnoff carp_setrun(sc, 0); 707a9771948SGleb Smirnoff carp_setroute(sc, RTM_DELETE); 708a9771948SGleb Smirnoff } 709a9771948SGleb Smirnoff break; 710a9771948SGleb Smirnoff case BACKUP: 711a9771948SGleb Smirnoff /* 712a9771948SGleb Smirnoff * If we're pre-empting masters who advertise slower than us, 713a9771948SGleb Smirnoff * and this one claims to be slower, treat him as down. 714a9771948SGleb Smirnoff */ 715a9771948SGleb Smirnoff if (carp_opts[CARPCTL_PREEMPT] && 716a9771948SGleb Smirnoff timevalcmp(&sc_tv, &ch_tv, <)) { 7171e9e6572SGleb Smirnoff CARP_DEBUG("%s: BACKUP -> MASTER " 71888bf82a6SGleb Smirnoff "(preempting a slower master)\n", 719fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname); 720d220759bSGleb Smirnoff carp_master_down_locked(sc); 721a9771948SGleb Smirnoff break; 722a9771948SGleb Smirnoff } 723a9771948SGleb Smirnoff 724a9771948SGleb Smirnoff /* 725a9771948SGleb Smirnoff * If the master is going to advertise at such a low frequency 726a9771948SGleb Smirnoff * that he's guaranteed to time out, we'd might as well just 727a9771948SGleb Smirnoff * treat him as timed out now. 728a9771948SGleb Smirnoff */ 729a9771948SGleb Smirnoff sc_tv.tv_sec = sc->sc_advbase * 3; 730a9771948SGleb Smirnoff if (timevalcmp(&sc_tv, &ch_tv, <)) { 7311e9e6572SGleb Smirnoff CARP_DEBUG("%s: BACKUP -> MASTER " 73288bf82a6SGleb Smirnoff "(master timed out)\n", 733fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname); 734d220759bSGleb Smirnoff carp_master_down_locked(sc); 735a9771948SGleb Smirnoff break; 736a9771948SGleb Smirnoff } 737a9771948SGleb Smirnoff 738a9771948SGleb Smirnoff /* 739a9771948SGleb Smirnoff * Otherwise, we reset the counter and wait for the next 740a9771948SGleb Smirnoff * advertisement. 741a9771948SGleb Smirnoff */ 742a9771948SGleb Smirnoff carp_setrun(sc, af); 743a9771948SGleb Smirnoff break; 744a9771948SGleb Smirnoff } 745a9771948SGleb Smirnoff 746d220759bSGleb Smirnoff CARP_UNLOCK(ifp->if_carp); 747d220759bSGleb Smirnoff 748a9771948SGleb Smirnoff m_freem(m); 749a9771948SGleb Smirnoff return; 750a9771948SGleb Smirnoff } 751a9771948SGleb Smirnoff 7525c1f0f6dSGleb Smirnoff static void 753a9771948SGleb Smirnoff carpdetach(struct carp_softc *sc) 754a9771948SGleb Smirnoff { 755a9771948SGleb Smirnoff struct ifaddr *ifa; 756a9771948SGleb Smirnoff 757a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 758a9771948SGleb Smirnoff callout_stop(&sc->sc_md_tmo); 759a9771948SGleb Smirnoff callout_stop(&sc->sc_md6_tmo); 760a9771948SGleb Smirnoff 761fc74a9f9SBrooks Davis while ((ifa = TAILQ_FIRST(&SC2IFP(sc)->if_addrlist)) != NULL) 762a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET) { 763a9771948SGleb Smirnoff struct in_ifaddr *ia = ifatoia(ifa); 764a9771948SGleb Smirnoff 765a9771948SGleb Smirnoff carp_del_addr(sc, &ia->ia_addr); 766a9771948SGleb Smirnoff 767a9771948SGleb Smirnoff /* ripped screaming from in_control(SIOCDIFADDR) */ 768fc74a9f9SBrooks Davis in_ifscrub(SC2IFP(sc), ia); 769fc74a9f9SBrooks Davis TAILQ_REMOVE(&SC2IFP(sc)->if_addrlist, ifa, ifa_link); 770a9771948SGleb Smirnoff TAILQ_REMOVE(&in_ifaddrhead, ia, ia_link); 771a9771948SGleb Smirnoff IFAFREE((&ia->ia_ifa)); 772a9771948SGleb Smirnoff } 773a9771948SGleb Smirnoff } 774a9771948SGleb Smirnoff 775a9771948SGleb Smirnoff /* Detach an interface from the carp. */ 776a9771948SGleb Smirnoff void 777a9771948SGleb Smirnoff carp_ifdetach(struct ifnet *ifp) 778a9771948SGleb Smirnoff { 779a9771948SGleb Smirnoff struct carp_softc *sc; 780a9771948SGleb Smirnoff struct carp_if *cif = (struct carp_if *)ifp->if_carp; 781a9771948SGleb Smirnoff 782a9771948SGleb Smirnoff CARP_LOCK(cif); 783a9771948SGleb Smirnoff TAILQ_FOREACH(sc, &cif->vhif_vrs, sc_list) 784a9771948SGleb Smirnoff carpdetach(sc); 785a9771948SGleb Smirnoff CARP_UNLOCK(cif); 786a9771948SGleb Smirnoff } 787a9771948SGleb Smirnoff 7885c1f0f6dSGleb Smirnoff static int 789a9771948SGleb Smirnoff carp_prepare_ad(struct mbuf *m, struct carp_softc *sc, struct carp_header *ch) 790a9771948SGleb Smirnoff { 791a9771948SGleb Smirnoff struct m_tag *mtag; 792fc74a9f9SBrooks Davis struct ifnet *ifp = SC2IFP(sc); 793a9771948SGleb Smirnoff 794a9771948SGleb Smirnoff if (sc->sc_init_counter) { 795a9771948SGleb Smirnoff /* this could also be seconds since unix epoch */ 796a9771948SGleb Smirnoff sc->sc_counter = arc4random(); 797a9771948SGleb Smirnoff sc->sc_counter = sc->sc_counter << 32; 798a9771948SGleb Smirnoff sc->sc_counter += arc4random(); 799a9771948SGleb Smirnoff } else 800a9771948SGleb Smirnoff sc->sc_counter++; 801a9771948SGleb Smirnoff 802a9771948SGleb Smirnoff ch->carp_counter[0] = htonl((sc->sc_counter>>32)&0xffffffff); 803a9771948SGleb Smirnoff ch->carp_counter[1] = htonl(sc->sc_counter&0xffffffff); 804a9771948SGleb Smirnoff 805a9771948SGleb Smirnoff carp_hmac_generate(sc, ch->carp_counter, ch->carp_md); 806a9771948SGleb Smirnoff 807a9771948SGleb Smirnoff /* Tag packet for carp_output */ 808a9771948SGleb Smirnoff mtag = m_tag_get(PACKET_TAG_CARP, sizeof(struct ifnet *), M_NOWAIT); 809a9771948SGleb Smirnoff if (mtag == NULL) { 810a9771948SGleb Smirnoff m_freem(m); 811fc74a9f9SBrooks Davis SC2IFP(sc)->if_oerrors++; 812a9771948SGleb Smirnoff return (ENOMEM); 813a9771948SGleb Smirnoff } 814a9771948SGleb Smirnoff bcopy(&ifp, (caddr_t)(mtag + 1), sizeof(struct ifnet *)); 815a9771948SGleb Smirnoff m_tag_prepend(m, mtag); 816a9771948SGleb Smirnoff 817a9771948SGleb Smirnoff return (0); 818a9771948SGleb Smirnoff } 819a9771948SGleb Smirnoff 8205c1f0f6dSGleb Smirnoff static void 821a9771948SGleb Smirnoff carp_send_ad_all(void) 822a9771948SGleb Smirnoff { 823d92d54d5SGleb Smirnoff struct carp_softc *sc; 824a9771948SGleb Smirnoff 825d92d54d5SGleb Smirnoff mtx_lock(&carp_mtx); 826d92d54d5SGleb Smirnoff LIST_FOREACH(sc, &carpif_list, sc_next) { 827d92d54d5SGleb Smirnoff if (sc->sc_carpdev == NULL) 828a9771948SGleb Smirnoff continue; 829d92d54d5SGleb Smirnoff CARP_SCLOCK(sc); 830fc74a9f9SBrooks Davis if ((SC2IFP(sc)->if_flags & (IFF_UP|IFF_RUNNING)) && 831d92d54d5SGleb Smirnoff sc->sc_state == MASTER) 832d220759bSGleb Smirnoff carp_send_ad_locked(sc); 833d92d54d5SGleb Smirnoff CARP_SCUNLOCK(sc); 834a9771948SGleb Smirnoff } 835d92d54d5SGleb Smirnoff mtx_unlock(&carp_mtx); 836a9771948SGleb Smirnoff } 837a9771948SGleb Smirnoff 8385c1f0f6dSGleb Smirnoff static void 839a9771948SGleb Smirnoff carp_send_ad(void *v) 840a9771948SGleb Smirnoff { 841d220759bSGleb Smirnoff struct carp_softc *sc = v; 842d220759bSGleb Smirnoff 843d220759bSGleb Smirnoff CARP_SCLOCK(sc); 844d220759bSGleb Smirnoff carp_send_ad_locked(sc); 845d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 846d220759bSGleb Smirnoff } 847d220759bSGleb Smirnoff 848d220759bSGleb Smirnoff static void 849d220759bSGleb Smirnoff carp_send_ad_locked(struct carp_softc *sc) 850d220759bSGleb Smirnoff { 851a9771948SGleb Smirnoff struct carp_header ch; 852a9771948SGleb Smirnoff struct timeval tv; 853a9771948SGleb Smirnoff struct carp_header *ch_ptr; 854a9771948SGleb Smirnoff struct mbuf *m; 855a9771948SGleb Smirnoff int len, advbase, advskew; 856a9771948SGleb Smirnoff 857d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 858d220759bSGleb Smirnoff 859a9771948SGleb Smirnoff /* bow out if we've lost our UPness or RUNNINGuiness */ 860fc74a9f9SBrooks Davis if ((SC2IFP(sc)->if_flags & 861a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { 862a9771948SGleb Smirnoff advbase = 255; 863a9771948SGleb Smirnoff advskew = 255; 864a9771948SGleb Smirnoff } else { 865a9771948SGleb Smirnoff advbase = sc->sc_advbase; 866a9771948SGleb Smirnoff if (!carp_suppress_preempt || sc->sc_advskew > 240) 867a9771948SGleb Smirnoff advskew = sc->sc_advskew; 868a9771948SGleb Smirnoff else 869a9771948SGleb Smirnoff advskew = 240; 870a9771948SGleb Smirnoff tv.tv_sec = advbase; 871a9771948SGleb Smirnoff tv.tv_usec = advskew * 1000000 / 256; 872a9771948SGleb Smirnoff } 873a9771948SGleb Smirnoff 874a9771948SGleb Smirnoff ch.carp_version = CARP_VERSION; 875a9771948SGleb Smirnoff ch.carp_type = CARP_ADVERTISEMENT; 876a9771948SGleb Smirnoff ch.carp_vhid = sc->sc_vhid; 877a9771948SGleb Smirnoff ch.carp_advbase = advbase; 878a9771948SGleb Smirnoff ch.carp_advskew = advskew; 879a9771948SGleb Smirnoff ch.carp_authlen = 7; /* XXX DEFINE */ 880a9771948SGleb Smirnoff ch.carp_pad1 = 0; /* must be zero */ 881a9771948SGleb Smirnoff ch.carp_cksum = 0; 882a9771948SGleb Smirnoff 883a9771948SGleb Smirnoff #ifdef INET 884a9771948SGleb Smirnoff if (sc->sc_ia) { 885a9771948SGleb Smirnoff struct ip *ip; 886a9771948SGleb Smirnoff 887a9771948SGleb Smirnoff MGETHDR(m, M_DONTWAIT, MT_HEADER); 888a9771948SGleb Smirnoff if (m == NULL) { 889fc74a9f9SBrooks Davis SC2IFP(sc)->if_oerrors++; 890a9771948SGleb Smirnoff carpstats.carps_onomem++; 891a9771948SGleb Smirnoff /* XXX maybe less ? */ 892a9771948SGleb Smirnoff if (advbase != 255 || advskew != 255) 893a9771948SGleb Smirnoff callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 894a9771948SGleb Smirnoff carp_send_ad, sc); 895a9771948SGleb Smirnoff return; 896a9771948SGleb Smirnoff } 897a9771948SGleb Smirnoff len = sizeof(*ip) + sizeof(ch); 898a9771948SGleb Smirnoff m->m_pkthdr.len = len; 899a9771948SGleb Smirnoff m->m_pkthdr.rcvif = NULL; 900a9771948SGleb Smirnoff m->m_len = len; 901a9771948SGleb Smirnoff MH_ALIGN(m, m->m_len); 902a9771948SGleb Smirnoff m->m_flags |= M_MCAST; 903a9771948SGleb Smirnoff ip = mtod(m, struct ip *); 904a9771948SGleb Smirnoff ip->ip_v = IPVERSION; 905a9771948SGleb Smirnoff ip->ip_hl = sizeof(*ip) >> 2; 906a9771948SGleb Smirnoff ip->ip_tos = IPTOS_LOWDELAY; 907a9771948SGleb Smirnoff ip->ip_len = len; 908a9771948SGleb Smirnoff ip->ip_id = ip_newid(); 909a9771948SGleb Smirnoff ip->ip_off = IP_DF; 910a9771948SGleb Smirnoff ip->ip_ttl = CARP_DFLTTL; 911a9771948SGleb Smirnoff ip->ip_p = IPPROTO_CARP; 912a9771948SGleb Smirnoff ip->ip_sum = 0; 913a9771948SGleb Smirnoff ip->ip_src.s_addr = sc->sc_ia->ia_addr.sin_addr.s_addr; 914a9771948SGleb Smirnoff ip->ip_dst.s_addr = htonl(INADDR_CARP_GROUP); 915a9771948SGleb Smirnoff 916a9771948SGleb Smirnoff ch_ptr = (struct carp_header *)(&ip[1]); 917a9771948SGleb Smirnoff bcopy(&ch, ch_ptr, sizeof(ch)); 918a9771948SGleb Smirnoff if (carp_prepare_ad(m, sc, ch_ptr)) 919a9771948SGleb Smirnoff return; 920a9771948SGleb Smirnoff 921a9771948SGleb Smirnoff m->m_data += sizeof(*ip); 922a9771948SGleb Smirnoff ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip)); 923a9771948SGleb Smirnoff m->m_data -= sizeof(*ip); 924a9771948SGleb Smirnoff 925fc74a9f9SBrooks Davis getmicrotime(&SC2IFP(sc)->if_lastchange); 926fc74a9f9SBrooks Davis SC2IFP(sc)->if_opackets++; 927fc74a9f9SBrooks Davis SC2IFP(sc)->if_obytes += len; 928a9771948SGleb Smirnoff carpstats.carps_opackets++; 929a9771948SGleb Smirnoff 930a9771948SGleb Smirnoff if (ip_output(m, NULL, NULL, IP_RAWOUTPUT, &sc->sc_imo, NULL)) { 931fc74a9f9SBrooks Davis SC2IFP(sc)->if_oerrors++; 932a9771948SGleb Smirnoff if (sc->sc_sendad_errors < INT_MAX) 933a9771948SGleb Smirnoff sc->sc_sendad_errors++; 934a9771948SGleb Smirnoff if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS) { 935a9771948SGleb Smirnoff carp_suppress_preempt++; 936d220759bSGleb Smirnoff if (carp_suppress_preempt == 1) { 937d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 938a9771948SGleb Smirnoff carp_send_ad_all(); 939d220759bSGleb Smirnoff CARP_SCLOCK(sc); 940d220759bSGleb Smirnoff } 941a9771948SGleb Smirnoff } 942a9771948SGleb Smirnoff sc->sc_sendad_success = 0; 943a9771948SGleb Smirnoff } else { 944a9771948SGleb Smirnoff if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) { 945a9771948SGleb Smirnoff if (++sc->sc_sendad_success >= 946a9771948SGleb Smirnoff CARP_SENDAD_MIN_SUCCESS) { 947a9771948SGleb Smirnoff carp_suppress_preempt--; 948a9771948SGleb Smirnoff sc->sc_sendad_errors = 0; 949a9771948SGleb Smirnoff } 950a9771948SGleb Smirnoff } else 951a9771948SGleb Smirnoff sc->sc_sendad_errors = 0; 952a9771948SGleb Smirnoff } 953a9771948SGleb Smirnoff } 954a9771948SGleb Smirnoff #endif /* INET */ 955a9771948SGleb Smirnoff #ifdef INET6 956a9771948SGleb Smirnoff if (sc->sc_ia6) { 957a9771948SGleb Smirnoff struct ip6_hdr *ip6; 958a9771948SGleb Smirnoff 959a9771948SGleb Smirnoff MGETHDR(m, M_DONTWAIT, MT_HEADER); 960a9771948SGleb Smirnoff if (m == NULL) { 961fc74a9f9SBrooks Davis SC2IFP(sc)->if_oerrors++; 962a9771948SGleb Smirnoff carpstats.carps_onomem++; 963a9771948SGleb Smirnoff /* XXX maybe less ? */ 964a9771948SGleb Smirnoff if (advbase != 255 || advskew != 255) 965a9771948SGleb Smirnoff callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 966a9771948SGleb Smirnoff carp_send_ad, sc); 967a9771948SGleb Smirnoff return; 968a9771948SGleb Smirnoff } 969a9771948SGleb Smirnoff len = sizeof(*ip6) + sizeof(ch); 970a9771948SGleb Smirnoff m->m_pkthdr.len = len; 971a9771948SGleb Smirnoff m->m_pkthdr.rcvif = NULL; 972a9771948SGleb Smirnoff m->m_len = len; 973a9771948SGleb Smirnoff MH_ALIGN(m, m->m_len); 974a9771948SGleb Smirnoff m->m_flags |= M_MCAST; 975a9771948SGleb Smirnoff ip6 = mtod(m, struct ip6_hdr *); 976a9771948SGleb Smirnoff bzero(ip6, sizeof(*ip6)); 977a9771948SGleb Smirnoff ip6->ip6_vfc |= IPV6_VERSION; 978a9771948SGleb Smirnoff ip6->ip6_hlim = CARP_DFLTTL; 979a9771948SGleb Smirnoff ip6->ip6_nxt = IPPROTO_CARP; 980a9771948SGleb Smirnoff bcopy(&sc->sc_ia6->ia_addr.sin6_addr, &ip6->ip6_src, 981a9771948SGleb Smirnoff sizeof(struct in6_addr)); 982a9771948SGleb Smirnoff /* set the multicast destination */ 983a9771948SGleb Smirnoff 984a9771948SGleb Smirnoff ip6->ip6_dst.s6_addr8[0] = 0xff; 985a9771948SGleb Smirnoff ip6->ip6_dst.s6_addr8[1] = 0x02; 986a9771948SGleb Smirnoff ip6->ip6_dst.s6_addr8[15] = 0x12; 987a9771948SGleb Smirnoff 988a9771948SGleb Smirnoff ch_ptr = (struct carp_header *)(&ip6[1]); 989a9771948SGleb Smirnoff bcopy(&ch, ch_ptr, sizeof(ch)); 990a9771948SGleb Smirnoff if (carp_prepare_ad(m, sc, ch_ptr)) 991a9771948SGleb Smirnoff return; 992a9771948SGleb Smirnoff 993a9771948SGleb Smirnoff m->m_data += sizeof(*ip6); 994a9771948SGleb Smirnoff ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip6)); 995a9771948SGleb Smirnoff m->m_data -= sizeof(*ip6); 996a9771948SGleb Smirnoff 997fc74a9f9SBrooks Davis getmicrotime(&SC2IFP(sc)->if_lastchange); 998fc74a9f9SBrooks Davis SC2IFP(sc)->if_opackets++; 999fc74a9f9SBrooks Davis SC2IFP(sc)->if_obytes += len; 1000a9771948SGleb Smirnoff carpstats.carps_opackets6++; 1001a9771948SGleb Smirnoff 1002a9771948SGleb Smirnoff if (ip6_output(m, NULL, NULL, 0, &sc->sc_im6o, NULL, NULL)) { 1003fc74a9f9SBrooks Davis SC2IFP(sc)->if_oerrors++; 1004a9771948SGleb Smirnoff if (sc->sc_sendad_errors < INT_MAX) 1005a9771948SGleb Smirnoff sc->sc_sendad_errors++; 1006a9771948SGleb Smirnoff if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS) { 1007a9771948SGleb Smirnoff carp_suppress_preempt++; 1008d220759bSGleb Smirnoff if (carp_suppress_preempt == 1) { 1009d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 1010a9771948SGleb Smirnoff carp_send_ad_all(); 1011d220759bSGleb Smirnoff CARP_SCLOCK(sc); 1012d220759bSGleb Smirnoff } 1013a9771948SGleb Smirnoff } 1014a9771948SGleb Smirnoff sc->sc_sendad_success = 0; 1015a9771948SGleb Smirnoff } else { 1016a9771948SGleb Smirnoff if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) { 1017a9771948SGleb Smirnoff if (++sc->sc_sendad_success >= 1018a9771948SGleb Smirnoff CARP_SENDAD_MIN_SUCCESS) { 1019a9771948SGleb Smirnoff carp_suppress_preempt--; 1020a9771948SGleb Smirnoff sc->sc_sendad_errors = 0; 1021a9771948SGleb Smirnoff } 1022a9771948SGleb Smirnoff } else 1023a9771948SGleb Smirnoff sc->sc_sendad_errors = 0; 1024a9771948SGleb Smirnoff } 1025a9771948SGleb Smirnoff } 1026a9771948SGleb Smirnoff #endif /* INET6 */ 1027a9771948SGleb Smirnoff 1028a9771948SGleb Smirnoff if (advbase != 255 || advskew != 255) 1029a9771948SGleb Smirnoff callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 1030a9771948SGleb Smirnoff carp_send_ad, sc); 1031a9771948SGleb Smirnoff 1032a9771948SGleb Smirnoff } 1033a9771948SGleb Smirnoff 1034a9771948SGleb Smirnoff /* 1035a9771948SGleb Smirnoff * Broadcast a gratuitous ARP request containing 1036a9771948SGleb Smirnoff * the virtual router MAC address for each IP address 1037a9771948SGleb Smirnoff * associated with the virtual router. 1038a9771948SGleb Smirnoff */ 10395c1f0f6dSGleb Smirnoff static void 1040a9771948SGleb Smirnoff carp_send_arp(struct carp_softc *sc) 1041a9771948SGleb Smirnoff { 1042a9771948SGleb Smirnoff struct ifaddr *ifa; 1043a9771948SGleb Smirnoff 1044fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 1045a9771948SGleb Smirnoff 1046a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET) 1047a9771948SGleb Smirnoff continue; 1048a9771948SGleb Smirnoff 1049fc74a9f9SBrooks Davis /* arprequest(sc->sc_carpdev, &in, &in, IFP2ENADDR(sc->sc_ifp)); */ 1050fc74a9f9SBrooks Davis arp_ifinit2(sc->sc_carpdev, ifa, IFP2ENADDR(sc->sc_ifp)); 1051a9771948SGleb Smirnoff 1052a9771948SGleb Smirnoff DELAY(1000); /* XXX */ 1053a9771948SGleb Smirnoff } 1054a9771948SGleb Smirnoff } 1055a9771948SGleb Smirnoff 1056a9771948SGleb Smirnoff #ifdef INET6 10575c1f0f6dSGleb Smirnoff static void 1058a9771948SGleb Smirnoff carp_send_na(struct carp_softc *sc) 1059a9771948SGleb Smirnoff { 1060a9771948SGleb Smirnoff struct ifaddr *ifa; 1061a9771948SGleb Smirnoff struct in6_addr *in6; 1062a9771948SGleb Smirnoff static struct in6_addr mcast = IN6ADDR_LINKLOCAL_ALLNODES_INIT; 1063a9771948SGleb Smirnoff 1064fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 1065a9771948SGleb Smirnoff 1066a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family != AF_INET6) 1067a9771948SGleb Smirnoff continue; 1068a9771948SGleb Smirnoff 1069a9771948SGleb Smirnoff in6 = &ifatoia6(ifa)->ia_addr.sin6_addr; 1070e8c34a71SGleb Smirnoff nd6_na_output(sc->sc_carpdev, &mcast, in6, 1071a9771948SGleb Smirnoff ND_NA_FLAG_OVERRIDE, 1, NULL); 1072a9771948SGleb Smirnoff DELAY(1000); /* XXX */ 1073a9771948SGleb Smirnoff } 1074a9771948SGleb Smirnoff } 1075a9771948SGleb Smirnoff #endif /* INET6 */ 1076a9771948SGleb Smirnoff 10775c1f0f6dSGleb Smirnoff static int 1078a9771948SGleb Smirnoff carp_addrcount(struct carp_if *cif, struct in_ifaddr *ia, int type) 1079a9771948SGleb Smirnoff { 1080a9771948SGleb Smirnoff struct carp_softc *vh; 1081a9771948SGleb Smirnoff struct ifaddr *ifa; 1082a9771948SGleb Smirnoff int count = 0; 1083a9771948SGleb Smirnoff 1084d220759bSGleb Smirnoff CARP_LOCK_ASSERT(cif); 1085d220759bSGleb Smirnoff 1086a9771948SGleb Smirnoff TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) { 1087a9771948SGleb Smirnoff if ((type == CARP_COUNT_RUNNING && 1088fc74a9f9SBrooks Davis (SC2IFP(vh)->if_flags & (IFF_UP|IFF_RUNNING)) == 1089a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) || 1090a9771948SGleb Smirnoff (type == CARP_COUNT_MASTER && vh->sc_state == MASTER)) { 1091fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(vh)->if_addrlist, 1092a9771948SGleb Smirnoff ifa_list) { 1093a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == AF_INET && 1094a9771948SGleb Smirnoff ia->ia_addr.sin_addr.s_addr == 1095a9771948SGleb Smirnoff ifatoia(ifa)->ia_addr.sin_addr.s_addr) 1096a9771948SGleb Smirnoff count++; 1097a9771948SGleb Smirnoff } 1098a9771948SGleb Smirnoff } 1099a9771948SGleb Smirnoff } 1100a9771948SGleb Smirnoff return (count); 1101a9771948SGleb Smirnoff } 1102a9771948SGleb Smirnoff 1103a9771948SGleb Smirnoff int 1104a9771948SGleb Smirnoff carp_iamatch(void *v, struct in_ifaddr *ia, 1105a9771948SGleb Smirnoff struct in_addr *isaddr, u_int8_t **enaddr) 1106a9771948SGleb Smirnoff { 1107a9771948SGleb Smirnoff struct carp_if *cif = v; 1108a9771948SGleb Smirnoff struct carp_softc *vh; 1109a9771948SGleb Smirnoff int index, count = 0; 1110a9771948SGleb Smirnoff struct ifaddr *ifa; 1111a9771948SGleb Smirnoff 1112a9771948SGleb Smirnoff CARP_LOCK(cif); 1113a9771948SGleb Smirnoff 1114a9771948SGleb Smirnoff if (carp_opts[CARPCTL_ARPBALANCE]) { 1115a9771948SGleb Smirnoff /* 1116a9771948SGleb Smirnoff * XXX proof of concept implementation. 1117a9771948SGleb Smirnoff * We use the source ip to decide which virtual host should 1118a9771948SGleb Smirnoff * handle the request. If we're master of that virtual host, 1119a9771948SGleb Smirnoff * then we respond, otherwise, just drop the arp packet on 1120a9771948SGleb Smirnoff * the floor. 1121a9771948SGleb Smirnoff */ 1122a9771948SGleb Smirnoff count = carp_addrcount(cif, ia, CARP_COUNT_RUNNING); 1123a9771948SGleb Smirnoff if (count == 0) { 1124a9771948SGleb Smirnoff /* should never reach this */ 1125a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1126a9771948SGleb Smirnoff return (0); 1127a9771948SGleb Smirnoff } 1128a9771948SGleb Smirnoff 1129a9771948SGleb Smirnoff /* this should be a hash, like pf_hash() */ 1130a196a3c8SGleb Smirnoff index = ntohl(isaddr->s_addr) % count; 1131a9771948SGleb Smirnoff count = 0; 1132a9771948SGleb Smirnoff 1133a9771948SGleb Smirnoff TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) { 1134fc74a9f9SBrooks Davis if ((SC2IFP(vh)->if_flags & (IFF_UP|IFF_RUNNING)) == 1135a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) { 1136fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(vh)->if_addrlist, 1137a9771948SGleb Smirnoff ifa_list) { 1138a9771948SGleb Smirnoff if (ifa->ifa_addr->sa_family == 1139a9771948SGleb Smirnoff AF_INET && 1140a9771948SGleb Smirnoff ia->ia_addr.sin_addr.s_addr == 1141a9771948SGleb Smirnoff ifatoia(ifa)->ia_addr.sin_addr.s_addr) { 1142a9771948SGleb Smirnoff if (count == index) { 1143a9771948SGleb Smirnoff if (vh->sc_state == 1144a9771948SGleb Smirnoff MASTER) { 1145fc74a9f9SBrooks Davis *enaddr = IFP2ENADDR(vh->sc_ifp); 1146a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1147a9771948SGleb Smirnoff return (1); 1148a9771948SGleb Smirnoff } else { 1149a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1150a9771948SGleb Smirnoff return (0); 1151a9771948SGleb Smirnoff } 1152a9771948SGleb Smirnoff } 1153a9771948SGleb Smirnoff count++; 1154a9771948SGleb Smirnoff } 1155a9771948SGleb Smirnoff } 1156a9771948SGleb Smirnoff } 1157a9771948SGleb Smirnoff } 1158a9771948SGleb Smirnoff } else { 1159a9771948SGleb Smirnoff TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) { 1160fc74a9f9SBrooks Davis if ((SC2IFP(vh)->if_flags & (IFF_UP|IFF_RUNNING)) == 1161a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING) && ia->ia_ifp == 1162fc74a9f9SBrooks Davis SC2IFP(vh)) { 1163fc74a9f9SBrooks Davis *enaddr = IFP2ENADDR(vh->sc_ifp); 1164a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1165a9771948SGleb Smirnoff return (1); 1166a9771948SGleb Smirnoff } 1167a9771948SGleb Smirnoff } 1168a9771948SGleb Smirnoff } 1169a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1170a9771948SGleb Smirnoff return (0); 1171a9771948SGleb Smirnoff } 1172a9771948SGleb Smirnoff 1173a9771948SGleb Smirnoff #ifdef INET6 1174a4e53905SMax Laier struct ifaddr * 1175a9771948SGleb Smirnoff carp_iamatch6(void *v, struct in6_addr *taddr) 1176a9771948SGleb Smirnoff { 1177a9771948SGleb Smirnoff struct carp_if *cif = v; 1178a9771948SGleb Smirnoff struct carp_softc *vh; 1179a9771948SGleb Smirnoff struct ifaddr *ifa; 1180a9771948SGleb Smirnoff 1181a9771948SGleb Smirnoff CARP_LOCK(cif); 1182a9771948SGleb Smirnoff TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) { 1183fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(vh)->if_addrlist, ifa_list) { 1184a9771948SGleb Smirnoff if (IN6_ARE_ADDR_EQUAL(taddr, 1185a9771948SGleb Smirnoff &ifatoia6(ifa)->ia_addr.sin6_addr) && 1186fc74a9f9SBrooks Davis ((SC2IFP(vh)->if_flags & 1187a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) == (IFF_UP|IFF_RUNNING))) { 1188a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1189a9771948SGleb Smirnoff return (ifa); 1190a9771948SGleb Smirnoff } 1191a9771948SGleb Smirnoff } 1192a9771948SGleb Smirnoff } 1193a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1194a9771948SGleb Smirnoff 1195a9771948SGleb Smirnoff return (NULL); 1196a9771948SGleb Smirnoff } 1197a9771948SGleb Smirnoff 1198a4e53905SMax Laier void * 1199a9771948SGleb Smirnoff carp_macmatch6(void *v, struct mbuf *m, const struct in6_addr *taddr) 1200a9771948SGleb Smirnoff { 1201a9771948SGleb Smirnoff struct m_tag *mtag; 1202a9771948SGleb Smirnoff struct carp_if *cif = v; 1203a9771948SGleb Smirnoff struct carp_softc *sc; 1204a9771948SGleb Smirnoff struct ifaddr *ifa; 1205a9771948SGleb Smirnoff 1206a9771948SGleb Smirnoff CARP_LOCK(cif); 1207a9771948SGleb Smirnoff TAILQ_FOREACH(sc, &cif->vhif_vrs, sc_list) { 1208fc74a9f9SBrooks Davis TAILQ_FOREACH(ifa, &SC2IFP(sc)->if_addrlist, ifa_list) { 1209a9771948SGleb Smirnoff if (IN6_ARE_ADDR_EQUAL(taddr, 1210a9771948SGleb Smirnoff &ifatoia6(ifa)->ia_addr.sin6_addr) && 1211fc74a9f9SBrooks Davis ((SC2IFP(sc)->if_flags & 1212a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING)) == (IFF_UP|IFF_RUNNING))) { 1213fc74a9f9SBrooks Davis struct ifnet *ifp = SC2IFP(sc); 1214a9771948SGleb Smirnoff mtag = m_tag_get(PACKET_TAG_CARP, 1215a9771948SGleb Smirnoff sizeof(struct ifnet *), M_NOWAIT); 1216a9771948SGleb Smirnoff if (mtag == NULL) { 1217a9771948SGleb Smirnoff /* better a bit than nothing */ 1218a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1219fc74a9f9SBrooks Davis return (IFP2ENADDR(sc->sc_ifp)); 1220a9771948SGleb Smirnoff } 1221a9771948SGleb Smirnoff bcopy(&ifp, (caddr_t)(mtag + 1), 1222a9771948SGleb Smirnoff sizeof(struct ifnet *)); 1223a9771948SGleb Smirnoff m_tag_prepend(m, mtag); 1224a9771948SGleb Smirnoff 1225a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1226fc74a9f9SBrooks Davis return (IFP2ENADDR(sc->sc_ifp)); 1227a9771948SGleb Smirnoff } 1228a9771948SGleb Smirnoff } 1229a9771948SGleb Smirnoff } 1230a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1231a9771948SGleb Smirnoff 1232a9771948SGleb Smirnoff return (NULL); 1233a9771948SGleb Smirnoff } 1234a9771948SGleb Smirnoff #endif 1235a9771948SGleb Smirnoff 1236a9771948SGleb Smirnoff struct ifnet * 1237a9771948SGleb Smirnoff carp_forus(void *v, void *dhost) 1238a9771948SGleb Smirnoff { 1239a9771948SGleb Smirnoff struct carp_if *cif = v; 1240a9771948SGleb Smirnoff struct carp_softc *vh; 1241a9771948SGleb Smirnoff u_int8_t *ena = dhost; 1242a9771948SGleb Smirnoff 1243a9771948SGleb Smirnoff if (ena[0] || ena[1] || ena[2] != 0x5e || ena[3] || ena[4] != 1) 1244a9771948SGleb Smirnoff return (NULL); 1245a9771948SGleb Smirnoff 1246a9771948SGleb Smirnoff CARP_LOCK(cif); 1247a9771948SGleb Smirnoff TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) 1248fc74a9f9SBrooks Davis if ((SC2IFP(vh)->if_flags & (IFF_UP|IFF_RUNNING)) == 1249a9771948SGleb Smirnoff (IFF_UP|IFF_RUNNING) && vh->sc_state == MASTER && 1250fc74a9f9SBrooks Davis !bcmp(dhost, IFP2ENADDR(vh->sc_ifp), ETHER_ADDR_LEN)) { 1251a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1252fc74a9f9SBrooks Davis return (SC2IFP(vh)); 1253a9771948SGleb Smirnoff } 1254a9771948SGleb Smirnoff 1255a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1256a9771948SGleb Smirnoff return (NULL); 1257a9771948SGleb Smirnoff } 1258a9771948SGleb Smirnoff 12595c1f0f6dSGleb Smirnoff static void 1260a9771948SGleb Smirnoff carp_master_down(void *v) 1261a9771948SGleb Smirnoff { 1262a9771948SGleb Smirnoff struct carp_softc *sc = v; 1263a9771948SGleb Smirnoff 1264d220759bSGleb Smirnoff CARP_SCLOCK(sc); 1265d220759bSGleb Smirnoff carp_master_down_locked(sc); 1266d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 1267d220759bSGleb Smirnoff } 1268d220759bSGleb Smirnoff 1269d220759bSGleb Smirnoff static void 1270d220759bSGleb Smirnoff carp_master_down_locked(struct carp_softc *sc) 1271d220759bSGleb Smirnoff { 1272d220759bSGleb Smirnoff if (sc->sc_carpdev) 1273d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 1274d220759bSGleb Smirnoff 1275a9771948SGleb Smirnoff switch (sc->sc_state) { 1276a9771948SGleb Smirnoff case INIT: 1277a9771948SGleb Smirnoff printf("%s: master_down event in INIT state\n", 1278fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname); 1279a9771948SGleb Smirnoff break; 1280a9771948SGleb Smirnoff case MASTER: 1281a9771948SGleb Smirnoff break; 1282a9771948SGleb Smirnoff case BACKUP: 1283a9771948SGleb Smirnoff carp_set_state(sc, MASTER); 1284d220759bSGleb Smirnoff carp_send_ad_locked(sc); 1285a9771948SGleb Smirnoff carp_send_arp(sc); 1286a9771948SGleb Smirnoff #ifdef INET6 1287a9771948SGleb Smirnoff carp_send_na(sc); 1288a9771948SGleb Smirnoff #endif /* INET6 */ 1289a9771948SGleb Smirnoff carp_setrun(sc, 0); 1290a9771948SGleb Smirnoff carp_setroute(sc, RTM_ADD); 1291a9771948SGleb Smirnoff break; 1292a9771948SGleb Smirnoff } 1293a9771948SGleb Smirnoff } 1294a9771948SGleb Smirnoff 1295a9771948SGleb Smirnoff /* 1296a9771948SGleb Smirnoff * When in backup state, af indicates whether to reset the master down timer 1297a9771948SGleb Smirnoff * for v4 or v6. If it's set to zero, reset the ones which are already pending. 1298a9771948SGleb Smirnoff */ 12995c1f0f6dSGleb Smirnoff static void 1300a9771948SGleb Smirnoff carp_setrun(struct carp_softc *sc, sa_family_t af) 1301a9771948SGleb Smirnoff { 1302a9771948SGleb Smirnoff struct timeval tv; 1303a9771948SGleb Smirnoff 1304d220759bSGleb Smirnoff if (sc->sc_carpdev) 1305d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 1306d220759bSGleb Smirnoff 1307fc74a9f9SBrooks Davis if (SC2IFP(sc)->if_flags & IFF_UP && 1308a9771948SGleb Smirnoff sc->sc_vhid > 0 && (sc->sc_naddrs || sc->sc_naddrs6)) 1309fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_RUNNING; 1310a9771948SGleb Smirnoff else { 1311fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags &= ~IFF_RUNNING; 1312a9771948SGleb Smirnoff carp_setroute(sc, RTM_DELETE); 1313a9771948SGleb Smirnoff return; 1314a9771948SGleb Smirnoff } 1315a9771948SGleb Smirnoff 1316a9771948SGleb Smirnoff switch (sc->sc_state) { 1317a9771948SGleb Smirnoff case INIT: 1318a9771948SGleb Smirnoff if (carp_opts[CARPCTL_PREEMPT] && !carp_suppress_preempt) { 1319d220759bSGleb Smirnoff carp_send_ad_locked(sc); 1320a9771948SGleb Smirnoff carp_send_arp(sc); 1321a9771948SGleb Smirnoff #ifdef INET6 1322a9771948SGleb Smirnoff carp_send_na(sc); 1323a9771948SGleb Smirnoff #endif /* INET6 */ 132488bf82a6SGleb Smirnoff CARP_DEBUG("%s: INIT -> MASTER (preempting)\n", 1325fc74a9f9SBrooks Davis SC2IFP(sc)->if_xname); 1326a9771948SGleb Smirnoff carp_set_state(sc, MASTER); 1327a9771948SGleb Smirnoff carp_setroute(sc, RTM_ADD); 1328a9771948SGleb Smirnoff } else { 1329fc74a9f9SBrooks Davis CARP_DEBUG("%s: INIT -> BACKUP\n", SC2IFP(sc)->if_xname); 1330a9771948SGleb Smirnoff carp_set_state(sc, BACKUP); 1331a9771948SGleb Smirnoff carp_setroute(sc, RTM_DELETE); 1332a9771948SGleb Smirnoff carp_setrun(sc, 0); 1333a9771948SGleb Smirnoff } 1334a9771948SGleb Smirnoff break; 1335a9771948SGleb Smirnoff case BACKUP: 1336a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 1337a9771948SGleb Smirnoff tv.tv_sec = 3 * sc->sc_advbase; 1338a9771948SGleb Smirnoff tv.tv_usec = sc->sc_advskew * 1000000 / 256; 1339a9771948SGleb Smirnoff switch (af) { 1340a9771948SGleb Smirnoff #ifdef INET 1341a9771948SGleb Smirnoff case AF_INET: 1342a9771948SGleb Smirnoff callout_reset(&sc->sc_md_tmo, tvtohz(&tv), 1343a9771948SGleb Smirnoff carp_master_down, sc); 1344a9771948SGleb Smirnoff break; 1345a9771948SGleb Smirnoff #endif /* INET */ 1346a9771948SGleb Smirnoff #ifdef INET6 1347a9771948SGleb Smirnoff case AF_INET6: 1348a9771948SGleb Smirnoff callout_reset(&sc->sc_md6_tmo, tvtohz(&tv), 1349a9771948SGleb Smirnoff carp_master_down, sc); 1350a9771948SGleb Smirnoff break; 1351a9771948SGleb Smirnoff #endif /* INET6 */ 1352a9771948SGleb Smirnoff default: 1353a9771948SGleb Smirnoff if (sc->sc_naddrs) 1354a9771948SGleb Smirnoff callout_reset(&sc->sc_md_tmo, tvtohz(&tv), 1355a9771948SGleb Smirnoff carp_master_down, sc); 1356a9771948SGleb Smirnoff if (sc->sc_naddrs6) 1357a9771948SGleb Smirnoff callout_reset(&sc->sc_md6_tmo, tvtohz(&tv), 1358a9771948SGleb Smirnoff carp_master_down, sc); 1359a9771948SGleb Smirnoff break; 1360a9771948SGleb Smirnoff } 1361a9771948SGleb Smirnoff break; 1362a9771948SGleb Smirnoff case MASTER: 1363a9771948SGleb Smirnoff tv.tv_sec = sc->sc_advbase; 1364a9771948SGleb Smirnoff tv.tv_usec = sc->sc_advskew * 1000000 / 256; 1365a9771948SGleb Smirnoff callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 1366a9771948SGleb Smirnoff carp_send_ad, sc); 1367a9771948SGleb Smirnoff break; 1368a9771948SGleb Smirnoff } 1369a9771948SGleb Smirnoff } 1370a9771948SGleb Smirnoff 13715c1f0f6dSGleb Smirnoff static int 1372a9771948SGleb Smirnoff carp_set_addr(struct carp_softc *sc, struct sockaddr_in *sin) 1373a9771948SGleb Smirnoff { 1374a9771948SGleb Smirnoff struct ifnet *ifp; 1375a9771948SGleb Smirnoff struct carp_if *cif; 1376a9771948SGleb Smirnoff struct in_ifaddr *ia, *ia_if; 1377a9771948SGleb Smirnoff struct ip_moptions *imo = &sc->sc_imo; 1378a9771948SGleb Smirnoff struct in_addr addr; 1379a9771948SGleb Smirnoff u_long iaddr = htonl(sin->sin_addr.s_addr); 1380a9771948SGleb Smirnoff int own, error; 1381a9771948SGleb Smirnoff 1382a9771948SGleb Smirnoff if (sin->sin_addr.s_addr == 0) { 1383fc74a9f9SBrooks Davis if (!(SC2IFP(sc)->if_flags & IFF_UP)) 1384a9771948SGleb Smirnoff carp_set_state(sc, INIT); 1385a9771948SGleb Smirnoff if (sc->sc_naddrs) 1386fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1387a9771948SGleb Smirnoff carp_setrun(sc, 0); 1388a9771948SGleb Smirnoff return (0); 1389a9771948SGleb Smirnoff } 1390a9771948SGleb Smirnoff 1391a9771948SGleb Smirnoff /* we have to do it by hands to check we won't match on us */ 1392a9771948SGleb Smirnoff ia_if = NULL; own = 0; 1393a9771948SGleb Smirnoff TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) { 1394a9771948SGleb Smirnoff /* and, yeah, we need a multicast-capable iface too */ 1395fc74a9f9SBrooks Davis if (ia->ia_ifp != SC2IFP(sc) && 1396a9771948SGleb Smirnoff (ia->ia_ifp->if_flags & IFF_MULTICAST) && 1397a9771948SGleb Smirnoff (iaddr & ia->ia_subnetmask) == ia->ia_subnet) { 1398a9771948SGleb Smirnoff if (!ia_if) 1399a9771948SGleb Smirnoff ia_if = ia; 1400a9771948SGleb Smirnoff if (sin->sin_addr.s_addr == 1401a9771948SGleb Smirnoff ia->ia_addr.sin_addr.s_addr) 1402a9771948SGleb Smirnoff own++; 1403a9771948SGleb Smirnoff } 1404a9771948SGleb Smirnoff } 1405a9771948SGleb Smirnoff 1406a9771948SGleb Smirnoff if (!ia_if) 1407a9771948SGleb Smirnoff return (EADDRNOTAVAIL); 1408a9771948SGleb Smirnoff 1409a9771948SGleb Smirnoff ia = ia_if; 1410a9771948SGleb Smirnoff ifp = ia->ia_ifp; 1411a9771948SGleb Smirnoff 1412a9771948SGleb Smirnoff if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0 || 1413a9771948SGleb Smirnoff (imo->imo_multicast_ifp && imo->imo_multicast_ifp != ifp)) 1414a9771948SGleb Smirnoff return (EADDRNOTAVAIL); 1415a9771948SGleb Smirnoff 1416a9771948SGleb Smirnoff if (imo->imo_num_memberships == 0) { 1417a9771948SGleb Smirnoff addr.s_addr = htonl(INADDR_CARP_GROUP); 1418a9771948SGleb Smirnoff if ((imo->imo_membership[0] = in_addmulti(&addr, ifp)) == NULL) 1419a9771948SGleb Smirnoff return (ENOBUFS); 1420a9771948SGleb Smirnoff imo->imo_num_memberships++; 1421a9771948SGleb Smirnoff imo->imo_multicast_ifp = ifp; 1422a9771948SGleb Smirnoff imo->imo_multicast_ttl = CARP_DFLTTL; 1423a9771948SGleb Smirnoff imo->imo_multicast_loop = 0; 1424a9771948SGleb Smirnoff } 1425a9771948SGleb Smirnoff 1426a9771948SGleb Smirnoff if (!ifp->if_carp) { 1427a9771948SGleb Smirnoff 1428a9771948SGleb Smirnoff MALLOC(cif, struct carp_if *, sizeof(*cif), M_CARP, 1429a9771948SGleb Smirnoff M_WAITOK|M_ZERO); 1430a9771948SGleb Smirnoff if (!cif) { 1431a9771948SGleb Smirnoff error = ENOBUFS; 1432a9771948SGleb Smirnoff goto cleanup; 1433a9771948SGleb Smirnoff } 1434a9771948SGleb Smirnoff if ((error = ifpromisc(ifp, 1))) { 1435a9771948SGleb Smirnoff FREE(cif, M_CARP); 1436a9771948SGleb Smirnoff goto cleanup; 1437a9771948SGleb Smirnoff } 1438a9771948SGleb Smirnoff 1439a9771948SGleb Smirnoff CARP_LOCK_INIT(cif); 1440a9771948SGleb Smirnoff CARP_LOCK(cif); 1441a9771948SGleb Smirnoff cif->vhif_ifp = ifp; 1442a9771948SGleb Smirnoff TAILQ_INIT(&cif->vhif_vrs); 1443a9771948SGleb Smirnoff ifp->if_carp = cif; 1444a9771948SGleb Smirnoff 1445a9771948SGleb Smirnoff } else { 1446a9771948SGleb Smirnoff struct carp_softc *vr; 1447a9771948SGleb Smirnoff 1448a9771948SGleb Smirnoff cif = (struct carp_if *)ifp->if_carp; 1449a9771948SGleb Smirnoff CARP_LOCK(cif); 1450a9771948SGleb Smirnoff TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) 1451a9771948SGleb Smirnoff if (vr != sc && vr->sc_vhid == sc->sc_vhid) { 1452a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1453a9771948SGleb Smirnoff error = EINVAL; 1454a9771948SGleb Smirnoff goto cleanup; 1455a9771948SGleb Smirnoff } 1456a9771948SGleb Smirnoff } 1457a9771948SGleb Smirnoff sc->sc_ia = ia; 1458e8c34a71SGleb Smirnoff sc->sc_carpdev = ifp; 1459a9771948SGleb Smirnoff 1460a9771948SGleb Smirnoff { /* XXX prevent endless loop if already in queue */ 1461a9771948SGleb Smirnoff struct carp_softc *vr, *after = NULL; 1462a9771948SGleb Smirnoff int myself = 0; 1463a9771948SGleb Smirnoff cif = (struct carp_if *)ifp->if_carp; 1464a9771948SGleb Smirnoff 1465a9771948SGleb Smirnoff /* XXX: cif should not change, right? So we still hold the lock */ 1466a9771948SGleb Smirnoff CARP_LOCK_ASSERT(cif); 1467a9771948SGleb Smirnoff 1468a9771948SGleb Smirnoff TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) { 1469a9771948SGleb Smirnoff if (vr == sc) 1470a9771948SGleb Smirnoff myself = 1; 1471a9771948SGleb Smirnoff if (vr->sc_vhid < sc->sc_vhid) 1472a9771948SGleb Smirnoff after = vr; 1473a9771948SGleb Smirnoff } 1474a9771948SGleb Smirnoff 1475a9771948SGleb Smirnoff if (!myself) { 1476a9771948SGleb Smirnoff /* We're trying to keep things in order */ 1477a9771948SGleb Smirnoff if (after == NULL) { 1478a9771948SGleb Smirnoff TAILQ_INSERT_TAIL(&cif->vhif_vrs, sc, sc_list); 1479a9771948SGleb Smirnoff } else { 1480a9771948SGleb Smirnoff TAILQ_INSERT_AFTER(&cif->vhif_vrs, after, sc, sc_list); 1481a9771948SGleb Smirnoff } 1482a9771948SGleb Smirnoff cif->vhif_nvrs++; 1483a9771948SGleb Smirnoff } 1484a9771948SGleb Smirnoff } 1485a9771948SGleb Smirnoff 1486a9771948SGleb Smirnoff sc->sc_naddrs++; 1487fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1488a9771948SGleb Smirnoff if (own) 1489a9771948SGleb Smirnoff sc->sc_advskew = 0; 14904cb39345SGleb Smirnoff carp_sc_state_locked(sc); 1491a9771948SGleb Smirnoff carp_setrun(sc, 0); 1492a9771948SGleb Smirnoff 1493d220759bSGleb Smirnoff CARP_UNLOCK(cif); 1494d220759bSGleb Smirnoff 1495a9771948SGleb Smirnoff return (0); 1496a9771948SGleb Smirnoff 1497a9771948SGleb Smirnoff cleanup: 1498a9771948SGleb Smirnoff in_delmulti(imo->imo_membership[--imo->imo_num_memberships]); 1499a9771948SGleb Smirnoff return (error); 1500a9771948SGleb Smirnoff } 1501a9771948SGleb Smirnoff 15025c1f0f6dSGleb Smirnoff static int 1503a9771948SGleb Smirnoff carp_del_addr(struct carp_softc *sc, struct sockaddr_in *sin) 1504a9771948SGleb Smirnoff { 1505a9771948SGleb Smirnoff int error = 0; 1506a9771948SGleb Smirnoff 1507a9771948SGleb Smirnoff if (!--sc->sc_naddrs) { 1508e8c34a71SGleb Smirnoff struct carp_if *cif = (struct carp_if *)sc->sc_carpdev->if_carp; 1509a9771948SGleb Smirnoff struct ip_moptions *imo = &sc->sc_imo; 1510a9771948SGleb Smirnoff 1511d220759bSGleb Smirnoff CARP_LOCK(cif); 1512a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 1513fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags &= ~(IFF_UP|IFF_RUNNING); 1514a9771948SGleb Smirnoff sc->sc_vhid = -1; 1515a9771948SGleb Smirnoff in_delmulti(imo->imo_membership[--imo->imo_num_memberships]); 1516a9771948SGleb Smirnoff imo->imo_multicast_ifp = NULL; 1517a9771948SGleb Smirnoff TAILQ_REMOVE(&cif->vhif_vrs, sc, sc_list); 1518a9771948SGleb Smirnoff if (!--cif->vhif_nvrs) { 1519e8c34a71SGleb Smirnoff sc->sc_carpdev->if_carp = NULL; 1520a9771948SGleb Smirnoff CARP_LOCK_DESTROY(cif); 1521a9771948SGleb Smirnoff FREE(cif, M_IFADDR); 1522a9771948SGleb Smirnoff } else { 1523a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1524a9771948SGleb Smirnoff } 1525a9771948SGleb Smirnoff } 1526a9771948SGleb Smirnoff 1527a9771948SGleb Smirnoff return (error); 1528a9771948SGleb Smirnoff } 1529a9771948SGleb Smirnoff 1530a9771948SGleb Smirnoff #ifdef INET6 15315c1f0f6dSGleb Smirnoff static int 1532a9771948SGleb Smirnoff carp_set_addr6(struct carp_softc *sc, struct sockaddr_in6 *sin6) 1533a9771948SGleb Smirnoff { 1534a9771948SGleb Smirnoff struct ifnet *ifp; 1535a9771948SGleb Smirnoff struct carp_if *cif; 1536a9771948SGleb Smirnoff struct in6_ifaddr *ia, *ia_if; 1537a9771948SGleb Smirnoff struct ip6_moptions *im6o = &sc->sc_im6o; 1538a9771948SGleb Smirnoff struct in6_multi_mship *imm; 1539a1f7e5f8SHajimu UMEMOTO struct in6_addr in6; 1540a9771948SGleb Smirnoff int own, error; 1541a9771948SGleb Smirnoff 1542a9771948SGleb Smirnoff if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 1543fc74a9f9SBrooks Davis if (!(SC2IFP(sc)->if_flags & IFF_UP)) 1544a9771948SGleb Smirnoff carp_set_state(sc, INIT); 1545a9771948SGleb Smirnoff if (sc->sc_naddrs6) 1546fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1547a9771948SGleb Smirnoff carp_setrun(sc, 0); 1548a9771948SGleb Smirnoff return (0); 1549a9771948SGleb Smirnoff } 1550a9771948SGleb Smirnoff 1551a9771948SGleb Smirnoff /* we have to do it by hands to check we won't match on us */ 1552a9771948SGleb Smirnoff ia_if = NULL; own = 0; 1553a9771948SGleb Smirnoff for (ia = in6_ifaddr; ia; ia = ia->ia_next) { 1554a9771948SGleb Smirnoff int i; 1555a9771948SGleb Smirnoff 1556a9771948SGleb Smirnoff for (i = 0; i < 4; i++) { 1557a9771948SGleb Smirnoff if ((sin6->sin6_addr.s6_addr32[i] & 1558a9771948SGleb Smirnoff ia->ia_prefixmask.sin6_addr.s6_addr32[i]) != 1559a9771948SGleb Smirnoff (ia->ia_addr.sin6_addr.s6_addr32[i] & 1560a9771948SGleb Smirnoff ia->ia_prefixmask.sin6_addr.s6_addr32[i])) 1561a9771948SGleb Smirnoff break; 1562a9771948SGleb Smirnoff } 1563a9771948SGleb Smirnoff /* and, yeah, we need a multicast-capable iface too */ 1564fc74a9f9SBrooks Davis if (ia->ia_ifp != SC2IFP(sc) && 1565a9771948SGleb Smirnoff (ia->ia_ifp->if_flags & IFF_MULTICAST) && 1566a9771948SGleb Smirnoff (i == 4)) { 1567a9771948SGleb Smirnoff if (!ia_if) 1568a9771948SGleb Smirnoff ia_if = ia; 1569a9771948SGleb Smirnoff if (IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, 1570a9771948SGleb Smirnoff &ia->ia_addr.sin6_addr)) 1571a9771948SGleb Smirnoff own++; 1572a9771948SGleb Smirnoff } 1573a9771948SGleb Smirnoff } 1574a9771948SGleb Smirnoff 1575a9771948SGleb Smirnoff if (!ia_if) 1576a9771948SGleb Smirnoff return (EADDRNOTAVAIL); 1577a9771948SGleb Smirnoff ia = ia_if; 1578a9771948SGleb Smirnoff ifp = ia->ia_ifp; 1579a9771948SGleb Smirnoff 1580a9771948SGleb Smirnoff if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0 || 1581a9771948SGleb Smirnoff (im6o->im6o_multicast_ifp && im6o->im6o_multicast_ifp != ifp)) 1582a9771948SGleb Smirnoff return (EADDRNOTAVAIL); 1583a9771948SGleb Smirnoff 1584a9771948SGleb Smirnoff if (!sc->sc_naddrs6) { 1585a9771948SGleb Smirnoff im6o->im6o_multicast_ifp = ifp; 1586a9771948SGleb Smirnoff 1587a9771948SGleb Smirnoff /* join CARP multicast address */ 1588a1f7e5f8SHajimu UMEMOTO bzero(&in6, sizeof(in6)); 1589a1f7e5f8SHajimu UMEMOTO in6.s6_addr16[0] = htons(0xff02); 1590a1f7e5f8SHajimu UMEMOTO in6.s6_addr8[15] = 0x12; 1591a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&in6, ifp, NULL) != 0) 1592a1f7e5f8SHajimu UMEMOTO goto cleanup; 1593a1f7e5f8SHajimu UMEMOTO if ((imm = in6_joingroup(ifp, &in6, &error)) == NULL) 1594a9771948SGleb Smirnoff goto cleanup; 1595a9771948SGleb Smirnoff LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain); 1596a9771948SGleb Smirnoff 1597a9771948SGleb Smirnoff /* join solicited multicast address */ 1598a1f7e5f8SHajimu UMEMOTO bzero(&in6, sizeof(in6)); 1599a1f7e5f8SHajimu UMEMOTO in6.s6_addr16[0] = htons(0xff02); 1600a1f7e5f8SHajimu UMEMOTO in6.s6_addr32[1] = 0; 1601a1f7e5f8SHajimu UMEMOTO in6.s6_addr32[2] = htonl(1); 1602a1f7e5f8SHajimu UMEMOTO in6.s6_addr32[3] = sin6->sin6_addr.s6_addr32[3]; 1603a1f7e5f8SHajimu UMEMOTO in6.s6_addr8[12] = 0xff; 1604a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&in6, ifp, NULL) != 0) 1605a1f7e5f8SHajimu UMEMOTO goto cleanup; 1606a1f7e5f8SHajimu UMEMOTO if ((imm = in6_joingroup(ifp, &in6, &error)) == NULL) 1607a9771948SGleb Smirnoff goto cleanup; 1608a9771948SGleb Smirnoff LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain); 1609a9771948SGleb Smirnoff } 1610a9771948SGleb Smirnoff 1611a9771948SGleb Smirnoff if (!ifp->if_carp) { 1612a9771948SGleb Smirnoff MALLOC(cif, struct carp_if *, sizeof(*cif), M_CARP, 1613a9771948SGleb Smirnoff M_WAITOK|M_ZERO); 1614a9771948SGleb Smirnoff if (!cif) { 1615a9771948SGleb Smirnoff error = ENOBUFS; 1616a9771948SGleb Smirnoff goto cleanup; 1617a9771948SGleb Smirnoff } 1618a9771948SGleb Smirnoff if ((error = ifpromisc(ifp, 1))) { 1619a9771948SGleb Smirnoff FREE(cif, M_CARP); 1620a9771948SGleb Smirnoff goto cleanup; 1621a9771948SGleb Smirnoff } 1622a9771948SGleb Smirnoff 1623a9771948SGleb Smirnoff CARP_LOCK_INIT(cif); 1624a9771948SGleb Smirnoff CARP_LOCK(cif); 1625a9771948SGleb Smirnoff cif->vhif_ifp = ifp; 1626a9771948SGleb Smirnoff TAILQ_INIT(&cif->vhif_vrs); 1627a9771948SGleb Smirnoff ifp->if_carp = cif; 1628a9771948SGleb Smirnoff 1629a9771948SGleb Smirnoff } else { 1630a9771948SGleb Smirnoff struct carp_softc *vr; 1631a9771948SGleb Smirnoff 1632a9771948SGleb Smirnoff cif = (struct carp_if *)ifp->if_carp; 1633a9771948SGleb Smirnoff CARP_LOCK(cif); 1634a9771948SGleb Smirnoff TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) 1635a9771948SGleb Smirnoff if (vr != sc && vr->sc_vhid == sc->sc_vhid) { 1636a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1637a9771948SGleb Smirnoff error = EINVAL; 1638a9771948SGleb Smirnoff goto cleanup; 1639a9771948SGleb Smirnoff } 1640a9771948SGleb Smirnoff } 1641a9771948SGleb Smirnoff sc->sc_ia6 = ia; 1642e8c34a71SGleb Smirnoff sc->sc_carpdev = ifp; 1643a9771948SGleb Smirnoff 1644a9771948SGleb Smirnoff { /* XXX prevent endless loop if already in queue */ 1645a9771948SGleb Smirnoff struct carp_softc *vr, *after = NULL; 1646a9771948SGleb Smirnoff int myself = 0; 1647a9771948SGleb Smirnoff cif = (struct carp_if *)ifp->if_carp; 1648a9771948SGleb Smirnoff CARP_LOCK_ASSERT(cif); 1649a9771948SGleb Smirnoff 1650a9771948SGleb Smirnoff TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) { 1651a9771948SGleb Smirnoff if (vr == sc) 1652a9771948SGleb Smirnoff myself = 1; 1653a9771948SGleb Smirnoff if (vr->sc_vhid < sc->sc_vhid) 1654a9771948SGleb Smirnoff after = vr; 1655a9771948SGleb Smirnoff } 1656a9771948SGleb Smirnoff 1657a9771948SGleb Smirnoff if (!myself) { 1658a9771948SGleb Smirnoff /* We're trying to keep things in order */ 1659a9771948SGleb Smirnoff if (after == NULL) { 1660a9771948SGleb Smirnoff TAILQ_INSERT_TAIL(&cif->vhif_vrs, sc, sc_list); 1661a9771948SGleb Smirnoff } else { 1662a9771948SGleb Smirnoff TAILQ_INSERT_AFTER(&cif->vhif_vrs, after, sc, sc_list); 1663a9771948SGleb Smirnoff } 1664a9771948SGleb Smirnoff cif->vhif_nvrs++; 1665a9771948SGleb Smirnoff } 1666a9771948SGleb Smirnoff } 1667a9771948SGleb Smirnoff 1668a9771948SGleb Smirnoff sc->sc_naddrs6++; 1669fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1670a9771948SGleb Smirnoff if (own) 1671a9771948SGleb Smirnoff sc->sc_advskew = 0; 16724cb39345SGleb Smirnoff carp_sc_state_locked(sc); 1673a9771948SGleb Smirnoff carp_setrun(sc, 0); 1674a9771948SGleb Smirnoff 1675d220759bSGleb Smirnoff CARP_UNLOCK(cif); 1676d220759bSGleb Smirnoff 1677a9771948SGleb Smirnoff return (0); 1678a9771948SGleb Smirnoff 1679a9771948SGleb Smirnoff cleanup: 1680a9771948SGleb Smirnoff /* clean up multicast memberships */ 1681a9771948SGleb Smirnoff if (!sc->sc_naddrs6) { 1682a9771948SGleb Smirnoff while (!LIST_EMPTY(&im6o->im6o_memberships)) { 1683a9771948SGleb Smirnoff imm = LIST_FIRST(&im6o->im6o_memberships); 1684a9771948SGleb Smirnoff LIST_REMOVE(imm, i6mm_chain); 1685a9771948SGleb Smirnoff in6_leavegroup(imm); 1686a9771948SGleb Smirnoff } 1687a9771948SGleb Smirnoff } 1688a9771948SGleb Smirnoff return (error); 1689a9771948SGleb Smirnoff } 1690a9771948SGleb Smirnoff 16915c1f0f6dSGleb Smirnoff static int 1692a9771948SGleb Smirnoff carp_del_addr6(struct carp_softc *sc, struct sockaddr_in6 *sin6) 1693a9771948SGleb Smirnoff { 1694a9771948SGleb Smirnoff int error = 0; 1695a9771948SGleb Smirnoff 1696a9771948SGleb Smirnoff if (!--sc->sc_naddrs6) { 1697e8c34a71SGleb Smirnoff struct carp_if *cif = (struct carp_if *)sc->sc_carpdev->if_carp; 1698a9771948SGleb Smirnoff struct ip6_moptions *im6o = &sc->sc_im6o; 1699a9771948SGleb Smirnoff 1700d220759bSGleb Smirnoff CARP_LOCK(cif); 1701a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 1702fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags &= ~(IFF_UP|IFF_RUNNING); 1703a9771948SGleb Smirnoff sc->sc_vhid = -1; 1704a9771948SGleb Smirnoff while (!LIST_EMPTY(&im6o->im6o_memberships)) { 1705a9771948SGleb Smirnoff struct in6_multi_mship *imm = 1706a9771948SGleb Smirnoff LIST_FIRST(&im6o->im6o_memberships); 1707a9771948SGleb Smirnoff 1708a9771948SGleb Smirnoff LIST_REMOVE(imm, i6mm_chain); 1709a9771948SGleb Smirnoff in6_leavegroup(imm); 1710a9771948SGleb Smirnoff } 1711a9771948SGleb Smirnoff im6o->im6o_multicast_ifp = NULL; 1712a9771948SGleb Smirnoff TAILQ_REMOVE(&cif->vhif_vrs, sc, sc_list); 1713a9771948SGleb Smirnoff if (!--cif->vhif_nvrs) { 1714a9771948SGleb Smirnoff CARP_LOCK_DESTROY(cif); 1715e8c34a71SGleb Smirnoff sc->sc_carpdev->if_carp = NULL; 1716a9771948SGleb Smirnoff FREE(cif, M_IFADDR); 1717a9771948SGleb Smirnoff } else 1718a9771948SGleb Smirnoff CARP_UNLOCK(cif); 1719a9771948SGleb Smirnoff } 1720a9771948SGleb Smirnoff 1721a9771948SGleb Smirnoff return (error); 1722a9771948SGleb Smirnoff } 1723a9771948SGleb Smirnoff #endif /* INET6 */ 1724a9771948SGleb Smirnoff 17255c1f0f6dSGleb Smirnoff static int 1726a9771948SGleb Smirnoff carp_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr) 1727a9771948SGleb Smirnoff { 1728a9771948SGleb Smirnoff struct carp_softc *sc = ifp->if_softc, *vr; 1729a9771948SGleb Smirnoff struct carpreq carpr; 1730a9771948SGleb Smirnoff struct ifaddr *ifa; 1731a9771948SGleb Smirnoff struct ifreq *ifr; 1732a9771948SGleb Smirnoff struct ifaliasreq *ifra; 1733d220759bSGleb Smirnoff int locked = 0, error = 0; 1734a9771948SGleb Smirnoff 1735a9771948SGleb Smirnoff ifa = (struct ifaddr *)addr; 1736a9771948SGleb Smirnoff ifra = (struct ifaliasreq *)addr; 1737a9771948SGleb Smirnoff ifr = (struct ifreq *)addr; 1738a9771948SGleb Smirnoff 1739a9771948SGleb Smirnoff switch (cmd) { 1740a9771948SGleb Smirnoff case SIOCSIFADDR: 1741a9771948SGleb Smirnoff switch (ifa->ifa_addr->sa_family) { 1742a9771948SGleb Smirnoff #ifdef INET 1743a9771948SGleb Smirnoff case AF_INET: 1744fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1745a9771948SGleb Smirnoff bcopy(ifa->ifa_addr, ifa->ifa_dstaddr, 1746a9771948SGleb Smirnoff sizeof(struct sockaddr)); 1747a9771948SGleb Smirnoff error = carp_set_addr(sc, satosin(ifa->ifa_addr)); 1748a9771948SGleb Smirnoff break; 1749a9771948SGleb Smirnoff #endif /* INET */ 1750a9771948SGleb Smirnoff #ifdef INET6 1751a9771948SGleb Smirnoff case AF_INET6: 1752fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1753a9771948SGleb Smirnoff error = carp_set_addr6(sc, satosin6(ifa->ifa_addr)); 1754a9771948SGleb Smirnoff break; 1755a9771948SGleb Smirnoff #endif /* INET6 */ 1756a9771948SGleb Smirnoff default: 1757a9771948SGleb Smirnoff error = EAFNOSUPPORT; 1758a9771948SGleb Smirnoff break; 1759a9771948SGleb Smirnoff } 1760a9771948SGleb Smirnoff break; 1761a9771948SGleb Smirnoff 1762a9771948SGleb Smirnoff case SIOCAIFADDR: 1763a9771948SGleb Smirnoff switch (ifa->ifa_addr->sa_family) { 1764a9771948SGleb Smirnoff #ifdef INET 1765a9771948SGleb Smirnoff case AF_INET: 1766fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1767a9771948SGleb Smirnoff bcopy(ifa->ifa_addr, ifa->ifa_dstaddr, 1768a9771948SGleb Smirnoff sizeof(struct sockaddr)); 1769a9771948SGleb Smirnoff error = carp_set_addr(sc, satosin(&ifra->ifra_addr)); 1770a9771948SGleb Smirnoff break; 1771a9771948SGleb Smirnoff #endif /* INET */ 1772a9771948SGleb Smirnoff #ifdef INET6 1773a9771948SGleb Smirnoff case AF_INET6: 1774fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1775a9771948SGleb Smirnoff error = carp_set_addr6(sc, satosin6(&ifra->ifra_addr)); 1776a9771948SGleb Smirnoff break; 1777a9771948SGleb Smirnoff #endif /* INET6 */ 1778a9771948SGleb Smirnoff default: 1779a9771948SGleb Smirnoff error = EAFNOSUPPORT; 1780a9771948SGleb Smirnoff break; 1781a9771948SGleb Smirnoff } 1782a9771948SGleb Smirnoff break; 1783a9771948SGleb Smirnoff 1784a9771948SGleb Smirnoff case SIOCDIFADDR: 1785a9771948SGleb Smirnoff switch (ifa->ifa_addr->sa_family) { 1786a9771948SGleb Smirnoff #ifdef INET 1787a9771948SGleb Smirnoff case AF_INET: 1788a9771948SGleb Smirnoff error = carp_del_addr(sc, satosin(&ifra->ifra_addr)); 1789a9771948SGleb Smirnoff break; 1790a9771948SGleb Smirnoff #endif /* INET */ 1791a9771948SGleb Smirnoff #ifdef INET6 1792a9771948SGleb Smirnoff case AF_INET6: 1793a9771948SGleb Smirnoff error = carp_del_addr6(sc, satosin6(&ifra->ifra_addr)); 1794a9771948SGleb Smirnoff break; 1795a9771948SGleb Smirnoff #endif /* INET6 */ 1796a9771948SGleb Smirnoff default: 1797a9771948SGleb Smirnoff error = EAFNOSUPPORT; 1798a9771948SGleb Smirnoff break; 1799a9771948SGleb Smirnoff } 1800a9771948SGleb Smirnoff break; 1801a9771948SGleb Smirnoff 1802a9771948SGleb Smirnoff case SIOCSIFFLAGS: 1803d220759bSGleb Smirnoff if (sc->sc_carpdev) { 1804d220759bSGleb Smirnoff locked = 1; 1805d220759bSGleb Smirnoff CARP_SCLOCK(sc); 1806d220759bSGleb Smirnoff } 1807a9771948SGleb Smirnoff if (sc->sc_state != INIT && !(ifr->ifr_flags & IFF_UP)) { 1808a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 1809a9771948SGleb Smirnoff callout_stop(&sc->sc_md_tmo); 1810a9771948SGleb Smirnoff callout_stop(&sc->sc_md6_tmo); 1811a9771948SGleb Smirnoff if (sc->sc_state == MASTER) 1812d220759bSGleb Smirnoff carp_send_ad_locked(sc); 1813a9771948SGleb Smirnoff carp_set_state(sc, INIT); 1814a9771948SGleb Smirnoff carp_setrun(sc, 0); 1815a9771948SGleb Smirnoff } else if (sc->sc_state == INIT && (ifr->ifr_flags & IFF_UP)) { 1816fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= IFF_UP; 1817a9771948SGleb Smirnoff carp_setrun(sc, 0); 1818a9771948SGleb Smirnoff } 1819a9771948SGleb Smirnoff break; 1820a9771948SGleb Smirnoff 1821a9771948SGleb Smirnoff case SIOCSVH: 1822a9771948SGleb Smirnoff if ((error = suser(curthread)) != 0) 1823a9771948SGleb Smirnoff break; 1824a9771948SGleb Smirnoff if ((error = copyin(ifr->ifr_data, &carpr, sizeof carpr))) 1825a9771948SGleb Smirnoff break; 1826a9771948SGleb Smirnoff error = 1; 1827d220759bSGleb Smirnoff if (sc->sc_carpdev) { 1828d220759bSGleb Smirnoff locked = 1; 1829d220759bSGleb Smirnoff CARP_SCLOCK(sc); 1830d220759bSGleb Smirnoff } 1831a9771948SGleb Smirnoff if (sc->sc_state != INIT && carpr.carpr_state != sc->sc_state) { 1832a9771948SGleb Smirnoff switch (carpr.carpr_state) { 1833a9771948SGleb Smirnoff case BACKUP: 1834a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 1835a9771948SGleb Smirnoff carp_set_state(sc, BACKUP); 1836a9771948SGleb Smirnoff carp_setrun(sc, 0); 1837a9771948SGleb Smirnoff carp_setroute(sc, RTM_DELETE); 1838a9771948SGleb Smirnoff break; 1839a9771948SGleb Smirnoff case MASTER: 1840d220759bSGleb Smirnoff carp_master_down_locked(sc); 1841a9771948SGleb Smirnoff break; 1842a9771948SGleb Smirnoff default: 1843a9771948SGleb Smirnoff break; 1844a9771948SGleb Smirnoff } 1845a9771948SGleb Smirnoff } 1846a9771948SGleb Smirnoff if (carpr.carpr_vhid > 0) { 1847a9771948SGleb Smirnoff if (carpr.carpr_vhid > 255) { 1848a9771948SGleb Smirnoff error = EINVAL; 1849a9771948SGleb Smirnoff break; 1850a9771948SGleb Smirnoff } 1851e8c34a71SGleb Smirnoff if (sc->sc_carpdev) { 1852a9771948SGleb Smirnoff struct carp_if *cif; 1853e8c34a71SGleb Smirnoff cif = (struct carp_if *)sc->sc_carpdev->if_carp; 1854a9771948SGleb Smirnoff TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) 1855a9771948SGleb Smirnoff if (vr != sc && 1856ee6f2270SGleb Smirnoff vr->sc_vhid == carpr.carpr_vhid) 1857ee6f2270SGleb Smirnoff return EEXIST; 1858a9771948SGleb Smirnoff } 1859a9771948SGleb Smirnoff sc->sc_vhid = carpr.carpr_vhid; 1860fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[0] = 0; 1861fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[1] = 0; 1862fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[2] = 0x5e; 1863fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[3] = 0; 1864fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[4] = 1; 1865fc74a9f9SBrooks Davis IFP2ENADDR(sc->sc_ifp)[5] = sc->sc_vhid; 1866a9771948SGleb Smirnoff error--; 1867a9771948SGleb Smirnoff } 1868a9771948SGleb Smirnoff if (carpr.carpr_advbase > 0 || carpr.carpr_advskew > 0) { 1869a9771948SGleb Smirnoff if (carpr.carpr_advskew >= 255) { 1870a9771948SGleb Smirnoff error = EINVAL; 1871a9771948SGleb Smirnoff break; 1872a9771948SGleb Smirnoff } 1873a9771948SGleb Smirnoff if (carpr.carpr_advbase > 255) { 1874a9771948SGleb Smirnoff error = EINVAL; 1875a9771948SGleb Smirnoff break; 1876a9771948SGleb Smirnoff } 1877a9771948SGleb Smirnoff sc->sc_advbase = carpr.carpr_advbase; 1878a9771948SGleb Smirnoff sc->sc_advskew = carpr.carpr_advskew; 1879a9771948SGleb Smirnoff error--; 1880a9771948SGleb Smirnoff } 1881a9771948SGleb Smirnoff bcopy(carpr.carpr_key, sc->sc_key, sizeof(sc->sc_key)); 1882a9771948SGleb Smirnoff if (error > 0) 1883a9771948SGleb Smirnoff error = EINVAL; 1884a9771948SGleb Smirnoff else { 1885a9771948SGleb Smirnoff error = 0; 1886a9771948SGleb Smirnoff carp_setrun(sc, 0); 1887a9771948SGleb Smirnoff } 1888a9771948SGleb Smirnoff break; 1889a9771948SGleb Smirnoff 1890a9771948SGleb Smirnoff case SIOCGVH: 1891d220759bSGleb Smirnoff /* XXX: lockless read */ 1892a9771948SGleb Smirnoff bzero(&carpr, sizeof(carpr)); 1893a9771948SGleb Smirnoff carpr.carpr_state = sc->sc_state; 1894a9771948SGleb Smirnoff carpr.carpr_vhid = sc->sc_vhid; 1895a9771948SGleb Smirnoff carpr.carpr_advbase = sc->sc_advbase; 1896a9771948SGleb Smirnoff carpr.carpr_advskew = sc->sc_advskew; 1897a9771948SGleb Smirnoff if (suser(curthread) == 0) 1898a9771948SGleb Smirnoff bcopy(sc->sc_key, carpr.carpr_key, 1899a9771948SGleb Smirnoff sizeof(carpr.carpr_key)); 1900a9771948SGleb Smirnoff error = copyout(&carpr, ifr->ifr_data, sizeof(carpr)); 1901a9771948SGleb Smirnoff break; 1902a9771948SGleb Smirnoff 1903a9771948SGleb Smirnoff default: 1904a9771948SGleb Smirnoff error = EINVAL; 1905a9771948SGleb Smirnoff } 1906a9771948SGleb Smirnoff 1907d220759bSGleb Smirnoff if (locked) 1908d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 1909d220759bSGleb Smirnoff 1910a9771948SGleb Smirnoff carp_hmac_prepare(sc); 1911d220759bSGleb Smirnoff 1912a9771948SGleb Smirnoff return (error); 1913a9771948SGleb Smirnoff } 1914a9771948SGleb Smirnoff 1915a9771948SGleb Smirnoff /* 1916a9771948SGleb Smirnoff * XXX: this is looutput. We should eventually use it from there. 1917a9771948SGleb Smirnoff */ 1918a9771948SGleb Smirnoff static int 1919a9771948SGleb Smirnoff carp_looutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst, 1920a9771948SGleb Smirnoff struct rtentry *rt) 1921a9771948SGleb Smirnoff { 192201399f34SDavid Malone u_int32_t af; 192301399f34SDavid Malone 1924a9771948SGleb Smirnoff M_ASSERTPKTHDR(m); /* check if we have the packet header */ 1925a9771948SGleb Smirnoff 1926a9771948SGleb Smirnoff if (rt && rt->rt_flags & (RTF_REJECT|RTF_BLACKHOLE)) { 1927a9771948SGleb Smirnoff m_freem(m); 1928a9771948SGleb Smirnoff return (rt->rt_flags & RTF_BLACKHOLE ? 0 : 1929a9771948SGleb Smirnoff rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); 1930a9771948SGleb Smirnoff } 1931a9771948SGleb Smirnoff 1932a9771948SGleb Smirnoff ifp->if_opackets++; 1933a9771948SGleb Smirnoff ifp->if_obytes += m->m_pkthdr.len; 193401399f34SDavid Malone 193501399f34SDavid Malone /* BPF writes need to be handled specially. */ 193601399f34SDavid Malone if (dst->sa_family == AF_UNSPEC) { 193701399f34SDavid Malone bcopy(dst->sa_data, &af, sizeof(af)); 193801399f34SDavid Malone dst->sa_family = af; 193901399f34SDavid Malone } 194001399f34SDavid Malone 1941a9771948SGleb Smirnoff #if 1 /* XXX */ 1942a9771948SGleb Smirnoff switch (dst->sa_family) { 1943a9771948SGleb Smirnoff case AF_INET: 1944a9771948SGleb Smirnoff case AF_INET6: 1945a9771948SGleb Smirnoff case AF_IPX: 1946a9771948SGleb Smirnoff case AF_APPLETALK: 1947a9771948SGleb Smirnoff break; 1948a9771948SGleb Smirnoff default: 1949a9771948SGleb Smirnoff printf("carp_looutput: af=%d unexpected\n", dst->sa_family); 1950a9771948SGleb Smirnoff m_freem(m); 1951a9771948SGleb Smirnoff return (EAFNOSUPPORT); 1952a9771948SGleb Smirnoff } 1953a9771948SGleb Smirnoff #endif 1954a9771948SGleb Smirnoff return(if_simloop(ifp, m, dst->sa_family, 0)); 1955a9771948SGleb Smirnoff } 1956a9771948SGleb Smirnoff 1957a9771948SGleb Smirnoff /* 1958a9771948SGleb Smirnoff * Start output on carp interface. This function should never be called. 1959a9771948SGleb Smirnoff */ 19605c1f0f6dSGleb Smirnoff static void 1961a9771948SGleb Smirnoff carp_start(struct ifnet *ifp) 1962a9771948SGleb Smirnoff { 1963a9771948SGleb Smirnoff #ifdef DEBUG 1964a9771948SGleb Smirnoff printf("%s: start called\n", ifp->if_xname); 1965a9771948SGleb Smirnoff #endif 1966a9771948SGleb Smirnoff } 1967a9771948SGleb Smirnoff 1968a9771948SGleb Smirnoff int 1969a9771948SGleb Smirnoff carp_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *sa, 1970a9771948SGleb Smirnoff struct rtentry *rt) 1971a9771948SGleb Smirnoff { 1972a9771948SGleb Smirnoff struct m_tag *mtag; 1973a9771948SGleb Smirnoff struct carp_softc *sc; 1974a9771948SGleb Smirnoff struct ifnet *carp_ifp; 1975a9771948SGleb Smirnoff 1976a9771948SGleb Smirnoff if (!sa) 1977a9771948SGleb Smirnoff return (0); 1978a9771948SGleb Smirnoff 1979a9771948SGleb Smirnoff switch (sa->sa_family) { 1980a9771948SGleb Smirnoff #ifdef INET 1981a9771948SGleb Smirnoff case AF_INET: 1982a9771948SGleb Smirnoff break; 1983a9771948SGleb Smirnoff #endif /* INET */ 1984a9771948SGleb Smirnoff #ifdef INET6 1985a9771948SGleb Smirnoff case AF_INET6: 1986a9771948SGleb Smirnoff break; 1987a9771948SGleb Smirnoff #endif /* INET6 */ 1988a9771948SGleb Smirnoff default: 1989a9771948SGleb Smirnoff return (0); 1990a9771948SGleb Smirnoff } 1991a9771948SGleb Smirnoff 1992a9771948SGleb Smirnoff mtag = m_tag_find(m, PACKET_TAG_CARP, NULL); 1993a9771948SGleb Smirnoff if (mtag == NULL) 1994a9771948SGleb Smirnoff return (0); 1995a9771948SGleb Smirnoff 1996a9771948SGleb Smirnoff bcopy(mtag + 1, &carp_ifp, sizeof(struct ifnet *)); 1997a9771948SGleb Smirnoff sc = carp_ifp->if_softc; 1998a9771948SGleb Smirnoff 1999a9771948SGleb Smirnoff /* Set the source MAC address to Virtual Router MAC Address */ 2000a9771948SGleb Smirnoff switch (ifp->if_type) { 2001630481bbSYaroslav Tykhiy case IFT_ETHER: 2002630481bbSYaroslav Tykhiy case IFT_L2VLAN: { 2003a9771948SGleb Smirnoff struct ether_header *eh; 2004a9771948SGleb Smirnoff 2005a9771948SGleb Smirnoff eh = mtod(m, struct ether_header *); 2006a9771948SGleb Smirnoff eh->ether_shost[0] = 0; 2007a9771948SGleb Smirnoff eh->ether_shost[1] = 0; 2008a9771948SGleb Smirnoff eh->ether_shost[2] = 0x5e; 2009a9771948SGleb Smirnoff eh->ether_shost[3] = 0; 2010a9771948SGleb Smirnoff eh->ether_shost[4] = 1; 2011a9771948SGleb Smirnoff eh->ether_shost[5] = sc->sc_vhid; 2012a9771948SGleb Smirnoff } 2013a9771948SGleb Smirnoff break; 2014a9771948SGleb Smirnoff case IFT_FDDI: { 2015a9771948SGleb Smirnoff struct fddi_header *fh; 2016a9771948SGleb Smirnoff 2017a9771948SGleb Smirnoff fh = mtod(m, struct fddi_header *); 2018a9771948SGleb Smirnoff fh->fddi_shost[0] = 0; 2019a9771948SGleb Smirnoff fh->fddi_shost[1] = 0; 2020a9771948SGleb Smirnoff fh->fddi_shost[2] = 0x5e; 2021a9771948SGleb Smirnoff fh->fddi_shost[3] = 0; 2022a9771948SGleb Smirnoff fh->fddi_shost[4] = 1; 2023a9771948SGleb Smirnoff fh->fddi_shost[5] = sc->sc_vhid; 2024a9771948SGleb Smirnoff } 2025a9771948SGleb Smirnoff break; 2026a9771948SGleb Smirnoff case IFT_ISO88025: { 2027a9771948SGleb Smirnoff struct iso88025_header *th; 2028a9771948SGleb Smirnoff th = mtod(m, struct iso88025_header *); 2029a9771948SGleb Smirnoff th->iso88025_shost[0] = 3; 2030a9771948SGleb Smirnoff th->iso88025_shost[1] = 0; 2031a9771948SGleb Smirnoff th->iso88025_shost[2] = 0x40 >> (sc->sc_vhid - 1); 2032a9771948SGleb Smirnoff th->iso88025_shost[3] = 0x40000 >> (sc->sc_vhid - 1); 2033a9771948SGleb Smirnoff th->iso88025_shost[4] = 0; 2034a9771948SGleb Smirnoff th->iso88025_shost[5] = 0; 2035a9771948SGleb Smirnoff } 2036a9771948SGleb Smirnoff break; 2037a9771948SGleb Smirnoff default: 2038a9771948SGleb Smirnoff printf("%s: carp is not supported for this interface type\n", 2039a9771948SGleb Smirnoff ifp->if_xname); 2040a9771948SGleb Smirnoff return (EOPNOTSUPP); 2041a9771948SGleb Smirnoff } 2042a9771948SGleb Smirnoff 2043a9771948SGleb Smirnoff return (0); 2044a9771948SGleb Smirnoff } 2045a9771948SGleb Smirnoff 20465c1f0f6dSGleb Smirnoff static void 2047a9771948SGleb Smirnoff carp_set_state(struct carp_softc *sc, int state) 2048a9771948SGleb Smirnoff { 2049d220759bSGleb Smirnoff 2050d220759bSGleb Smirnoff if (sc->sc_carpdev) 2051d220759bSGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 2052d220759bSGleb Smirnoff 2053a9771948SGleb Smirnoff if (sc->sc_state == state) 2054a9771948SGleb Smirnoff return; 2055a9771948SGleb Smirnoff 2056a9771948SGleb Smirnoff sc->sc_state = state; 2057a9771948SGleb Smirnoff switch (state) { 2058a9771948SGleb Smirnoff case BACKUP: 2059fc74a9f9SBrooks Davis SC2IFP(sc)->if_link_state = LINK_STATE_DOWN; 2060a9771948SGleb Smirnoff break; 2061a9771948SGleb Smirnoff case MASTER: 2062fc74a9f9SBrooks Davis SC2IFP(sc)->if_link_state = LINK_STATE_UP; 2063a9771948SGleb Smirnoff break; 2064a9771948SGleb Smirnoff default: 2065fc74a9f9SBrooks Davis SC2IFP(sc)->if_link_state = LINK_STATE_UNKNOWN; 2066a9771948SGleb Smirnoff break; 2067a9771948SGleb Smirnoff } 2068fc74a9f9SBrooks Davis rt_ifmsg(SC2IFP(sc)); 2069a9771948SGleb Smirnoff } 2070a9771948SGleb Smirnoff 2071a9771948SGleb Smirnoff void 2072a9771948SGleb Smirnoff carp_carpdev_state(void *v) 2073a9771948SGleb Smirnoff { 2074a9771948SGleb Smirnoff struct carp_if *cif = v; 2075d220759bSGleb Smirnoff 2076a9771948SGleb Smirnoff CARP_LOCK(cif); 2077d220759bSGleb Smirnoff carp_carpdev_state_locked(cif); 2078d220759bSGleb Smirnoff CARP_UNLOCK(cif); 2079d220759bSGleb Smirnoff } 2080d220759bSGleb Smirnoff 2081d220759bSGleb Smirnoff static void 2082d220759bSGleb Smirnoff carp_carpdev_state_locked(struct carp_if *cif) 2083d220759bSGleb Smirnoff { 2084d220759bSGleb Smirnoff struct carp_softc *sc; 2085d220759bSGleb Smirnoff 20864cb39345SGleb Smirnoff TAILQ_FOREACH(sc, &cif->vhif_vrs, sc_list) 20874cb39345SGleb Smirnoff carp_sc_state_locked(sc); 20884cb39345SGleb Smirnoff } 20894cb39345SGleb Smirnoff 20904cb39345SGleb Smirnoff static void 20914cb39345SGleb Smirnoff carp_sc_state_locked(struct carp_softc *sc) 20924cb39345SGleb Smirnoff { 20934cb39345SGleb Smirnoff CARP_SCLOCK_ASSERT(sc); 20944cb39345SGleb Smirnoff 2095e8c34a71SGleb Smirnoff if (sc->sc_carpdev->if_link_state != LINK_STATE_UP || 2096e8c34a71SGleb Smirnoff !(sc->sc_carpdev->if_flags & IFF_UP)) { 2097fc74a9f9SBrooks Davis sc->sc_flags_backup = SC2IFP(sc)->if_flags; 2098fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags &= ~(IFF_UP|IFF_RUNNING); 2099a9771948SGleb Smirnoff callout_stop(&sc->sc_ad_tmo); 2100a9771948SGleb Smirnoff callout_stop(&sc->sc_md_tmo); 2101a9771948SGleb Smirnoff callout_stop(&sc->sc_md6_tmo); 2102a9771948SGleb Smirnoff carp_set_state(sc, INIT); 2103a9771948SGleb Smirnoff carp_setrun(sc, 0); 2104a9771948SGleb Smirnoff if (!sc->sc_suppress) { 2105a9771948SGleb Smirnoff carp_suppress_preempt++; 2106d220759bSGleb Smirnoff if (carp_suppress_preempt == 1) { 2107d220759bSGleb Smirnoff CARP_SCUNLOCK(sc); 2108a9771948SGleb Smirnoff carp_send_ad_all(); 2109d220759bSGleb Smirnoff CARP_SCLOCK(sc); 2110d220759bSGleb Smirnoff } 2111a9771948SGleb Smirnoff } 2112a9771948SGleb Smirnoff sc->sc_suppress = 1; 2113a9771948SGleb Smirnoff } else { 2114fc74a9f9SBrooks Davis SC2IFP(sc)->if_flags |= sc->sc_flags_backup; 2115a9771948SGleb Smirnoff carp_set_state(sc, INIT); 2116a9771948SGleb Smirnoff carp_setrun(sc, 0); 2117a9771948SGleb Smirnoff if (sc->sc_suppress) 2118a9771948SGleb Smirnoff carp_suppress_preempt--; 2119a9771948SGleb Smirnoff sc->sc_suppress = 0; 2120a9771948SGleb Smirnoff } 21214cb39345SGleb Smirnoff 21224cb39345SGleb Smirnoff return; 2123a9771948SGleb Smirnoff } 2124a9771948SGleb Smirnoff 2125a9771948SGleb Smirnoff static int 2126a9771948SGleb Smirnoff carp_modevent(module_t mod, int type, void *data) 2127a9771948SGleb Smirnoff { 2128a9771948SGleb Smirnoff int error = 0; 2129a9771948SGleb Smirnoff 2130a9771948SGleb Smirnoff switch (type) { 2131a9771948SGleb Smirnoff case MOD_LOAD: 2132d92d54d5SGleb Smirnoff mtx_init(&carp_mtx, "carp_mtx", NULL, MTX_DEF); 2133a9771948SGleb Smirnoff LIST_INIT(&carpif_list); 2134a9771948SGleb Smirnoff if_clone_attach(&carp_cloner); 2135a9771948SGleb Smirnoff break; 2136a9771948SGleb Smirnoff 2137a9771948SGleb Smirnoff case MOD_UNLOAD: 2138a9771948SGleb Smirnoff if_clone_detach(&carp_cloner); 2139a9771948SGleb Smirnoff while (!LIST_EMPTY(&carpif_list)) 2140fc74a9f9SBrooks Davis carp_clone_destroy(SC2IFP(LIST_FIRST(&carpif_list))); 2141d92d54d5SGleb Smirnoff mtx_destroy(&carp_mtx); 2142a9771948SGleb Smirnoff break; 2143a9771948SGleb Smirnoff 2144a9771948SGleb Smirnoff default: 2145a9771948SGleb Smirnoff error = EINVAL; 2146a9771948SGleb Smirnoff break; 2147a9771948SGleb Smirnoff } 2148a9771948SGleb Smirnoff 2149a9771948SGleb Smirnoff return error; 2150a9771948SGleb Smirnoff } 2151a9771948SGleb Smirnoff 2152a9771948SGleb Smirnoff static moduledata_t carp_mod = { 2153a9771948SGleb Smirnoff "carp", 2154a9771948SGleb Smirnoff carp_modevent, 2155a9771948SGleb Smirnoff 0 2156a9771948SGleb Smirnoff }; 2157a9771948SGleb Smirnoff 2158a9771948SGleb Smirnoff DECLARE_MODULE(carp, carp_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 2159