xref: /freebsd/sys/netinet/ip_carp.c (revision a1f7e5f8ee7fee62414af8d3a3008313cfd2cb17)
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