D45039.diff
No OneTemporary
Actions

Size

17 KB

Referenced Files

None

Subscribers

None

D45039.diff
View Options

	diff --git a/sys/netinet/ip_carp.c b/sys/netinet/ip_carp.c
	--- a/sys/netinet/ip_carp.c
	+++ b/sys/netinet/ip_carp.c
	@@ -97,7 +97,7 @@
	struct ifnet sc_carpdev; / Pointer to parent ifnet. */
	struct ifaddr *sc_ifas; / Our ifaddrs. */
	carp_version_t sc_version; /* carp or VRRPv3 */
	- struct sockaddr_dl sc_addr; /* Our link level address. */
	+ uint8_t sc_addr[ETHER_ADDR_LEN]; /* Our link level address. */
	struct callout sc_ad_tmo; /* Advertising timeout. */
	#ifdef INET
	struct callout sc_md_tmo; /* Master down timeout. */
	@@ -108,18 +108,25 @@
	struct mtx sc_mtx;

	int sc_vhid;
	- struct { /* CARP specific context */
	- int sc_advskew;
	- int sc_advbase;
	- struct in_addr sc_carpaddr;
	- struct in6_addr sc_carpaddr6;
	- };
	- struct { /* VRRPv3 specific context */
	- uint8_t sc_vrrp_prio;
	- uint16_t sc_vrrp_adv_inter;
	- uint16_t sc_vrrp_master_inter;
	+ union {
	+ struct { /* sc_version == CARP_VERSION_CARP */
	+ int sc_advskew;
	+ int sc_advbase;
	+ struct in_addr sc_carpaddr;
	+ struct in6_addr sc_carpaddr6;
	+ uint64_t sc_counter;
	+ bool sc_init_counter;
	+#define CARP_HMAC_PAD 64
	+ unsigned char sc_key[CARP_KEY_LEN];
	+ unsigned char sc_pad[CARP_HMAC_PAD];
	+ SHA1_CTX sc_sha1;
	+ };
	+ struct { /* sc_version == CARP_VERSION_VRRPv3 */
	+ uint8_t sc_vrrp_prio;
	+ uint16_t sc_vrrp_adv_inter;
	+ uint16_t sc_vrrp_master_inter;
	+ };
	};
	-
	int sc_naddrs;
	int sc_naddrs6;
	int sc_ifasiz;
	@@ -130,15 +137,6 @@
	int sc_sendad_success;
	#define CARP_SENDAD_MIN_SUCCESS 3

	- int sc_init_counter;
	- uint64_t sc_counter;
	-
	- /* authentication */
	-#define CARP_HMAC_PAD 64
	- unsigned char sc_key[CARP_KEY_LEN];
	- unsigned char sc_pad[CARP_HMAC_PAD];
	- SHA1_CTX sc_sha1;
	-
	TAILQ_ENTRY(carp_softc) sc_list; /* On the carp_if list. */
	LIST_ENTRY(carp_softc) sc_next; /* On the global list. */
	};
	@@ -339,7 +337,7 @@
	static void carp_input_c(struct mbuf , struct carp_header , sa_family_t, int);
	static void vrrp_input_c(struct mbuf *, int, sa_family_t, int, int, uint16_t);
	static struct carp_softc
	- carp_alloc(struct ifnet );
	+ carp_alloc(struct ifnet , carp_version_t, int);
	static void carp_destroy(struct carp_softc *);
	static struct carp_if
	carp_alloc_if(struct ifnet );
	@@ -398,6 +396,7 @@
	#endif

	CARP_LOCK_ASSERT(sc);
	+ MPASS(sc->sc_version == CARP_VERSION_CARP);

	/* Compute ipad from key. */
	bzero(sc->sc_pad, sizeof(sc->sc_pad));
	@@ -522,7 +521,6 @@
	int iplen;
	int minlen;
	int totlen;
	- uint16_t phdrcksum = 0;

	iplen = *offp;
	*mp = NULL;
	@@ -593,10 +591,10 @@
	vh = (struct vrrpv3_header )((char )ip + iplen);
	}

	- phdrcksum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
	- htonl((u_short)(totlen - iplen) + ip->ip_p));
	+ switch (vh->vrrp_version) {
	+ case CARP_VERSION_CARP: {
	+ struct carp_header *ch;

	- if (vh->vrrp_version == CARP_VERSION_CARP) {
	/* verify the CARP checksum */
	m->m_data += iplen;
	if (in_cksum(m, totlen - iplen)) {
	@@ -604,20 +602,22 @@
	CARP_DEBUG("%s: checksum failed on %s\n", __func__,
	if_name(m->m_pkthdr.rcvif));
	m_freem(m);
	- return (IPPROTO_DONE);
	+ break;
	}
	m->m_data -= iplen;
	- }
	-
	- switch (vh->vrrp_version) {
	- case CARP_VERSION_CARP: {
	- struct carp_header ch = (struct carp_header )((char *)ip + iplen);
	+ ch = (struct carp_header )((char )ip + iplen);
	carp_input_c(m, ch, AF_INET, ip->ip_ttl);
	break;
	}
	- case CARP_VERSION_VRRPv3:
	- vrrp_input_c(m, iplen, AF_INET, ip->ip_ttl, totlen - iplen, phdrcksum);
	+ case CARP_VERSION_VRRPv3: {
	+ uint16_t phdrcksum;
	+
	+ phdrcksum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
	+ htonl((u_short)(totlen - iplen) + ip->ip_p));
	+ vrrp_input_c(m, iplen, AF_INET, ip->ip_ttl, totlen - iplen,
	+ phdrcksum);
	break;
	+ }
	default:
	KASSERT(false, ("Unsupported version %d", vh->vrrp_version));
	}
	@@ -634,7 +634,6 @@
	struct ip6_hdr ip6 = mtod(m, struct ip6_hdr );
	struct vrrpv3_header *vh;
	u_int len, minlen;
	- uint16_t phdrcksum = 0;

	CARPSTATS_INC(carps_ipackets6);

	@@ -700,31 +699,33 @@
	vh = (struct vrrpv3_header )mtodo(m, sizeof(ip6));
	}

	- phdrcksum = in6_cksum_pseudo(ip6, ntohs(ip6->ip6_plen), ip6->ip6_nxt, 0);
	+ switch (vh->vrrp_version) {
	+ case CARP_VERSION_CARP: {
	+ struct carp_header *ch;

	- /* verify the CARP checksum */
	- if (vh->vrrp_version == CARP_VERSION_CARP) {
	+ /* verify the CARP checksum */
	m->m_data += *offp;
	if (in_cksum(m, sizeof(struct carp_header))) {
	CARPSTATS_INC(carps_badsum);
	CARP_DEBUG("%s: checksum failed, on %s\n", __func__,
	if_name(m->m_pkthdr.rcvif));
	m_freem(m);
	- return (IPPROTO_DONE);
	+ break;
	}
	m->m_data -= *offp;
	- }
	-
	- switch (vh->vrrp_version) {
	- case CARP_VERSION_CARP: {
	- struct carp_header ch = (struct carp_header )((char )ip6 + sizeof(ip6));
	+ ch = (struct carp_header )((char )ip6 + sizeof(*ip6));
	carp_input_c(m, ch, AF_INET6, ip6->ip6_hlim);
	break;
	}
	- case CARP_VERSION_VRRPv3:
	- vrrp_input_c(m, sizeof(*ip6), AF_INET6, ip6->ip6_hlim, ntohs(ip6->ip6_plen),
	- phdrcksum);
	+ case CARP_VERSION_VRRPv3: {
	+ uint16_t phdrcksum;
	+
	+ phdrcksum = in6_cksum_pseudo(ip6, ntohs(ip6->ip6_plen),
	+ ip6->ip6_nxt, 0);
	+ vrrp_input_c(m, sizeof(*ip6), AF_INET6, ip6->ip6_hlim,
	+ ntohs(ip6->ip6_plen), phdrcksum);
	break;
	+ }
	default:
	KASSERT(false, ("Unsupported version %d", vh->vrrp_version));
	}
	@@ -886,7 +887,7 @@

	/* XXX Replay protection goes here */

	- sc->sc_init_counter = 0;
	+ sc->sc_init_counter = false;
	sc->sc_counter = tmp_counter;

	sc_tv.tv_sec = sc->sc_advbase;
	@@ -1624,7 +1625,7 @@
	if (ifa->ifa_addr->sa_family != AF_INET)
	continue;
	addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
	- arp_announce_ifaddr(sc->sc_carpdev, addr, LLADDR(&sc->sc_addr));
	+ arp_announce_ifaddr(sc->sc_carpdev, addr, sc->sc_addr);
	}
	}

	@@ -1634,7 +1635,7 @@
	struct carp_softc *sc = ifa->ifa_carp;

	if (sc->sc_state == MASTER) {
	- *enaddr = LLADDR(&sc->sc_addr);
	+ *enaddr = sc->sc_addr;
	return (1);
	}

	@@ -1705,12 +1706,12 @@
	sizeof(struct carp_softc *), M_NOWAIT);
	if (mtag == NULL)
	/* Better a bit than nothing. */
	- return (LLADDR(&sc->sc_addr));
	+ return (sc->sc_addr);

	bcopy(&sc, mtag + 1, sizeof(sc));
	m_tag_prepend(m, mtag);

	- return (LLADDR(&sc->sc_addr));
	+ return (sc->sc_addr);
	}

	return (NULL);
	@@ -1732,7 +1733,7 @@
	* CARP_LOCK() is not here, since would protect nothing, but
	* cause deadlock with if_bridge, calling this under its lock.
	*/
	- if (sc->sc_state == MASTER && !bcmp(dhost, LLADDR(&sc->sc_addr),
	+ if (sc->sc_state == MASTER && !bcmp(dhost, sc->sc_addr,
	ETHER_ADDR_LEN)) {
	CIF_UNLOCK(ifp->if_carp);
	return (1);
	@@ -1821,18 +1822,21 @@
	case BACKUP:
	callout_stop(&sc->sc_ad_tmo);

	- if (sc->sc_version == CARP_VERSION_CARP) {
	+ switch (sc->sc_version) {
	+ case CARP_VERSION_CARP:
	tv.tv_sec = 3 * sc->sc_advbase;
	tv.tv_usec = sc->sc_advskew * 1000000 / 256;
	timeout = tvtohz(&tv);
	- } else {
	+ break;
	+ case CARP_VERSION_VRRPv3:
	/* skew time */
	- timeout = (256 - sc->sc_vrrp_prio) * sc->sc_vrrp_master_inter / 256;
	+ timeout = (256 - sc->sc_vrrp_prio) *
	+ sc->sc_vrrp_master_inter / 256;
	timeout += (3 * sc->sc_vrrp_master_inter);
	timeout *= hz;
	- timeout /= 100; /* master interval is in centiseconds. */
	+ timeout /= 100; /* master interval is in centiseconds */
	+ break;
	}
	-
	switch (af) {
	#ifdef INET
	case AF_INET:
	@@ -1861,15 +1865,18 @@
	}
	break;
	case MASTER:
	- if (sc->sc_version == CARP_VERSION_CARP) {
	+ switch (sc->sc_version) {
	+ case CARP_VERSION_CARP:
	tv.tv_sec = sc->sc_advbase;
	tv.tv_usec = sc->sc_advskew * 1000000 / 256;
	callout_reset(&sc->sc_ad_tmo, tvtohz(&tv),
	carp_callout, sc);
	- } else {
	+ break;
	+ case CARP_VERSION_VRRPv3:
	callout_reset(&sc->sc_ad_tmo,
	sc->sc_vrrp_adv_inter * hz / 100,
	carp_callout, sc);
	+ break;
	}
	break;
	}
	@@ -2073,7 +2080,7 @@
	}

	static struct carp_softc*
	-carp_alloc(struct ifnet *ifp)
	+carp_alloc(struct ifnet *ifp, carp_version_t version, int vhid)
	{
	struct carp_softc *sc;
	struct carp_if *cif;
	@@ -2083,25 +2090,31 @@
	if ((cif = ifp->if_carp) == NULL)
	cif = carp_alloc_if(ifp);

	- sc = malloc(sizeof(*sc), M_CARP, M_WAITOK\|M_ZERO);
	-
	- sc->sc_version = CARP_VERSION_CARP;
	- sc->sc_advbase = CARP_DFLTINTV;
	- sc->sc_vhid = -1; /* required setting */
	- sc->sc_init_counter = 1;
	- sc->sc_state = INIT;
	-
	- sc->sc_ifasiz = sizeof(struct ifaddr *);
	+ sc = malloc(sizeof(*sc), M_CARP, M_WAITOK);
	+ *sc = (struct carp_softc ){
	+ .sc_vhid = vhid,
	+ .sc_version = version,
	+ .sc_state = INIT,
	+ .sc_carpdev = ifp,
	+ .sc_ifasiz = sizeof(struct ifaddr *),
	+ .sc_addr = { 0, 0, 0x5e, 0, 1, vhid },
	+ };
	sc->sc_ifas = malloc(sc->sc_ifasiz, M_CARP, M_WAITOK\|M_ZERO);
	- sc->sc_carpdev = ifp;

	- sc->sc_carpaddr.s_addr = htonl(INADDR_CARP_GROUP);
	- sc->sc_carpaddr6.s6_addr16[0] = IPV6_ADDR_INT16_MLL;
	- sc->sc_carpaddr6.s6_addr8[15] = 0x12;
	-
	- sc->sc_vrrp_adv_inter = 100;
	- sc->sc_vrrp_master_inter = sc->sc_vrrp_adv_inter;
	- sc->sc_vrrp_prio = 100;
	+ switch (version) {
	+ case CARP_VERSION_CARP:
	+ sc->sc_advbase = CARP_DFLTINTV;
	+ sc->sc_init_counter = true;
	+ sc->sc_carpaddr.s_addr = htonl(INADDR_CARP_GROUP);
	+ sc->sc_carpaddr6.s6_addr16[0] = IPV6_ADDR_INT16_MLL;
	+ sc->sc_carpaddr6.s6_addr8[15] = 0x12;
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ sc->sc_vrrp_adv_inter = 100;
	+ sc->sc_vrrp_master_inter = sc->sc_vrrp_adv_inter;
	+ sc->sc_vrrp_prio = 100;
	+ break;
	+ }

	CARP_LOCK_INIT(sc);
	#ifdef INET
	@@ -2226,12 +2239,19 @@
	CARP_LOCK(sc);
	carpr->carpr_state = sc->sc_state;
	carpr->carpr_vhid = sc->sc_vhid;
	- carpr->carpr_advbase = sc->sc_advbase;
	- carpr->carpr_advskew = sc->sc_advskew;
	- if (priv)
	- bcopy(sc->sc_key, carpr->carpr_key, sizeof(carpr->carpr_key));
	- else
	- bzero(carpr->carpr_key, sizeof(carpr->carpr_key));
	+ switch (sc->sc_version) {
	+ case CARP_VERSION_CARP:
	+ carpr->carpr_advbase = sc->sc_advbase;
	+ carpr->carpr_advskew = sc->sc_advskew;
	+ if (priv)
	+ bcopy(sc->sc_key, carpr->carpr_key,
	+ sizeof(carpr->carpr_key));
	+ else
	+ bzero(carpr->carpr_key, sizeof(carpr->carpr_key));
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ break;
	+ }
	CARP_UNLOCK(sc);

	return (true);
	@@ -2244,10 +2264,21 @@
	struct carp_softc *sc = NULL;
	int error = 0;

	- if (carpr->carpr_vhid <= 0 \|\| carpr->carpr_vhid > CARP_MAXVHID \|\|
	- carpr->carpr_advbase < 0 \|\| carpr->carpr_advskew < 0 \|\|
	- (carpr->carpr_version != CARP_VERSION_CARP &&
	- carpr->carpr_version != CARP_VERSION_VRRPv3)) {
	+ if (carpr->carpr_vhid <= 0 \|\| carpr->carpr_vhid > CARP_MAXVHID)
	+ return (EINVAL);
	+
	+ switch (carpr->carpr_version) {
	+ case CARP_VERSION_CARP:
	+ if (carpr->carpr_advbase != 0 && (carpr->carpr_advbase > 255 \|\|
	+ carpr->carpr_advbase < CARP_DFLTINTV))
	+ return (EINVAL);
	+ if (carpr->carpr_advskew < 0 \|\| carpr->carpr_advskew >= 255)
	+ return (EINVAL);
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ /* XXXGL: shouldn't we check anything? */
	+ break;
	+ default:
	return (EINVAL);
	}

	@@ -2256,46 +2287,36 @@
	if (sc->sc_vhid == carpr->carpr_vhid)
	break;
	}
	- if (sc == NULL) {
	- sc = carp_alloc(ifp);
	- CARP_LOCK(sc);
	- sc->sc_vhid = carpr->carpr_vhid;
	- LLADDR(&sc->sc_addr)[0] = 0;
	- LLADDR(&sc->sc_addr)[1] = 0;
	- LLADDR(&sc->sc_addr)[2] = 0x5e;
	- LLADDR(&sc->sc_addr)[3] = 0;
	- LLADDR(&sc->sc_addr)[4] = 1;
	- LLADDR(&sc->sc_addr)[5] = sc->sc_vhid;
	- } else
	- CARP_LOCK(sc);
	- sc->sc_version = carpr->carpr_version;
	- if (carpr->carpr_advbase > 0) {
	- if (carpr->carpr_advbase > 255 \|\|
	- carpr->carpr_advbase < CARP_DFLTINTV) {
	- error = EINVAL;
	- goto out;
	+
	+ if (sc == NULL)
	+ sc = carp_alloc(ifp, carpr->carpr_version, carpr->carpr_vhid);
	+ else if (sc->sc_version != carpr->carpr_version)
	+ return (EINVAL);
	+
	+ CARP_LOCK(sc);
	+ switch (sc->sc_version) {
	+ case CARP_VERSION_CARP:
	+ if (carpr->carpr_advbase != 0)
	+ sc->sc_advbase = carpr->carpr_advbase;
	+ sc->sc_advskew = carpr->carpr_advskew;
	+ if (carpr->carpr_addr.s_addr != INADDR_ANY)
	+ sc->sc_carpaddr = carpr->carpr_addr;
	+ if (!IN6_IS_ADDR_UNSPECIFIED(&carpr->carpr_addr6)) {
	+ memcpy(&sc->sc_carpaddr6, &carpr->carpr_addr6,
	+ sizeof(sc->sc_carpaddr6));
	}
	- sc->sc_advbase = carpr->carpr_advbase;
	- }
	- if (carpr->carpr_advskew >= 255) {
	- error = EINVAL;
	- goto out;
	- }
	- sc->sc_advskew = carpr->carpr_advskew;
	- if (carpr->carpr_addr.s_addr != INADDR_ANY)
	- sc->sc_carpaddr = carpr->carpr_addr;
	- if (! IN6_IS_ADDR_UNSPECIFIED(&carpr->carpr_addr6)) {
	- memcpy(&sc->sc_carpaddr6, &carpr->carpr_addr6,
	- sizeof(sc->sc_carpaddr6));
	- }
	- if (carpr->carpr_key[0] != '\0') {
	- bcopy(carpr->carpr_key, sc->sc_key, sizeof(sc->sc_key));
	- carp_hmac_prepare(sc);
	+ if (carpr->carpr_key[0] != '\0') {
	+ bcopy(carpr->carpr_key, sc->sc_key, sizeof(sc->sc_key));
	+ carp_hmac_prepare(sc);
	+ }
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ if (carpr->carpr_vrrp_priority != 0)
	+ sc->sc_vrrp_prio = carpr->carpr_vrrp_priority;
	+ if (carpr->carpr_vrrp_adv_inter)
	+ sc->sc_vrrp_adv_inter = carpr->carpr_vrrp_adv_inter;
	+ break;
	}
	- if (carpr->carpr_vrrp_priority != 0)
	- sc->sc_vrrp_prio = carpr->carpr_vrrp_priority;
	- if (carpr->carpr_vrrp_adv_inter)
	- sc->sc_vrrp_adv_inter = carpr->carpr_vrrp_adv_inter;

	if (sc->sc_state != INIT &&
	carpr->carpr_state != sc->sc_state) {
	@@ -2317,8 +2338,6 @@
	break;
	}
	}
	-
	-out:
	CARP_UNLOCK(sc);

	return (error);
	@@ -2373,7 +2392,9 @@
	carp_ioctl(struct ifreq ifr, u_long cmd, struct thread td)
	{
	struct carpreq carpr;
	- struct carpkreq carprk = { };
	+ struct carpkreq carprk = {
	+ .carpr_version = CARP_VERSION_CARP,
	+ };
	struct ifnet *ifp;
	int error = 0;

	@@ -2497,7 +2518,8 @@
	CARP_LOCK(sc);
	sc->sc_ifas[index - 1] = ifa;
	ifa->ifa_carp = sc;
	- carp_hmac_prepare(sc);
	+ if (sc->sc_version == CARP_VERSION_CARP)
	+ carp_hmac_prepare(sc);
	carp_sc_state(sc);
	CARP_UNLOCK(sc);

	@@ -2550,7 +2572,8 @@
	ifa->ifa_carp = NULL;
	ifa_free(ifa);

	- carp_hmac_prepare(sc);
	+ if (sc->sc_version == CARP_VERSION_CARP)
	+ carp_hmac_prepare(sc);
	carp_sc_state(sc);

	if (!keep_cif && sc->sc_naddrs == 0 && sc->sc_naddrs6 == 0)
	@@ -2742,16 +2765,23 @@

	nlattr_add_u32(nw, CARP_NL_VHID, sc->sc_vhid);
	nlattr_add_u32(nw, CARP_NL_STATE, sc->sc_state);
	- nlattr_add_s32(nw, CARP_NL_ADVBASE, sc->sc_advbase);
	- nlattr_add_s32(nw, CARP_NL_ADVSKEW, sc->sc_advskew);
	- nlattr_add_in_addr(nw, CARP_NL_ADDR, &sc->sc_carpaddr);
	- nlattr_add_in6_addr(nw, CARP_NL_ADDR6, &sc->sc_carpaddr6);
	nlattr_add_u8(nw, CARP_NL_VERSION, sc->sc_version);
	- nlattr_add_u8(nw, CARP_NL_VRRP_PRIORITY, sc->sc_vrrp_prio);
	- nlattr_add_u16(nw, CARP_NL_VRRP_ADV_INTER, sc->sc_vrrp_adv_inter);
	-
	- if (priv)
	- nlattr_add(nw, CARP_NL_KEY, sizeof(sc->sc_key), sc->sc_key);
	+ switch (sc->sc_version) {
	+ case CARP_VERSION_CARP:
	+ nlattr_add_s32(nw, CARP_NL_ADVBASE, sc->sc_advbase);
	+ nlattr_add_s32(nw, CARP_NL_ADVSKEW, sc->sc_advskew);
	+ nlattr_add_in_addr(nw, CARP_NL_ADDR, &sc->sc_carpaddr);
	+ nlattr_add_in6_addr(nw, CARP_NL_ADDR6, &sc->sc_carpaddr6);
	+ if (priv)
	+ nlattr_add(nw, CARP_NL_KEY, sizeof(sc->sc_key),
	+ sc->sc_key);
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ nlattr_add_u8(nw, CARP_NL_VRRP_PRIORITY, sc->sc_vrrp_prio);
	+ nlattr_add_u16(nw, CARP_NL_VRRP_ADV_INTER,
	+ sc->sc_vrrp_adv_inter);
	+ break;
	+ }

	CARP_UNLOCK(sc);

	@@ -2865,19 +2895,24 @@
	return (EINVAL);
	if (attrs.state > CARP_MAXSTATE)
	return (EINVAL);
	- if (attrs.advbase < 0 \|\| attrs.advskew < 0)
	- return (EINVAL);
	- if (attrs.advbase > 255)
	- return (EINVAL);
	- if (attrs.advskew >= 255)
	- return (EINVAL);
	- if (attrs.version == 0)
	+ if (attrs.version == 0) /* compat with pre-VRRPv3 */
	attrs.version = CARP_VERSION_CARP;
	- if (attrs.version != CARP_VERSION_CARP &&
	- attrs.version != CARP_VERSION_VRRPv3)
	- return (EINVAL);
	- if (attrs.vrrp_adv_inter > VRRP_MAX_INTERVAL)
	+ switch (attrs.version) {
	+ case CARP_VERSION_CARP:
	+ if (attrs.advbase < 0 \|\| attrs.advskew < 0)
	+ return (EINVAL);
	+ if (attrs.advbase > 255)
	+ return (EINVAL);
	+ if (attrs.advskew >= 255)
	+ return (EINVAL);
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ if (attrs.vrrp_adv_inter > VRRP_MAX_INTERVAL)
	+ return (EINVAL);
	+ break;
	+ default:
	return (EINVAL);
	+ }

	NET_EPOCH_ENTER(et);
	if (attrs.ifname != NULL)
	@@ -2897,15 +2932,20 @@
	carpr.carpr_count = 1;
	carpr.carpr_vhid = attrs.vhid;
	carpr.carpr_state = attrs.state;
	- carpr.carpr_advbase = attrs.advbase;
	- carpr.carpr_advskew = attrs.advskew;
	- carpr.carpr_addr = attrs.addr;
	- carpr.carpr_addr6 = attrs.addr6;
	carpr.carpr_version = attrs.version;
	- carpr.carpr_vrrp_priority = attrs.vrrp_prio;
	- carpr.carpr_vrrp_adv_inter = attrs.vrrp_adv_inter;
	-
	- memcpy(&carpr.carpr_key, &attrs.key, sizeof(attrs.key));
	+ switch (attrs.version) {
	+ case CARP_VERSION_CARP:
	+ carpr.carpr_advbase = attrs.advbase;
	+ carpr.carpr_advskew = attrs.advskew;
	+ carpr.carpr_addr = attrs.addr;
	+ carpr.carpr_addr6 = attrs.addr6;
	+ memcpy(&carpr.carpr_key, &attrs.key, sizeof(attrs.key));
	+ break;
	+ case CARP_VERSION_VRRPv3:
	+ carpr.carpr_vrrp_priority = attrs.vrrp_prio;
	+ carpr.carpr_vrrp_adv_inter = attrs.vrrp_adv_inter;
	+ break;
	+ }

	sx_xlock(&carp_sx);
	error = carp_ioctl_set(ifp, &carpr);

File Metadata

Mime Type: text/plain
Expires: Sun, Feb 8, 3:42 AM (4 h, 2 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 28463592
Default Alt Text: D45039.diff (17 KB)

D45039.diffNo OneTemporaryActions

D45039.diffView Options

File Metadata

Event Timeline

D45039.diff
No OneTemporary
Actions

D45039.diff
View Options