Annotation of sys/netinet/ip_carp.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ip_carp.c,v 1.147 2007/06/23 16:15:26 reyk Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2002 Michael Shalayeff. All rights reserved.
! 5: * Copyright (c) 2003 Ryan McBride. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 19: * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
! 20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 22: * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
! 25: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
! 26: * THE POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28:
! 29: /*
! 30: * TODO:
! 31: * - iface reconfigure
! 32: * - support for hardware checksum calculations;
! 33: *
! 34: */
! 35:
! 36: #include "ether.h"
! 37:
! 38: #include <sys/param.h>
! 39: #include <sys/proc.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/mbuf.h>
! 42: #include <sys/socket.h>
! 43: #include <sys/socketvar.h>
! 44: #include <sys/ioctl.h>
! 45: #include <sys/errno.h>
! 46: #include <sys/device.h>
! 47: #include <sys/kernel.h>
! 48: #include <sys/sysctl.h>
! 49: #include <sys/syslog.h>
! 50:
! 51: #include <machine/cpu.h>
! 52:
! 53: #include <net/if.h>
! 54: #include <net/if_types.h>
! 55: #include <net/if_llc.h>
! 56: #include <net/route.h>
! 57: #include <net/netisr.h>
! 58:
! 59: /* for arc4random() */
! 60: #include <dev/rndvar.h>
! 61:
! 62: #if NFDDI > 0
! 63: #include <net/if_fddi.h>
! 64: #endif
! 65:
! 66: #include <crypto/sha1.h>
! 67:
! 68: #ifdef INET
! 69: #include <netinet/in.h>
! 70: #include <netinet/in_systm.h>
! 71: #include <netinet/in_var.h>
! 72: #include <netinet/ip.h>
! 73: #include <netinet/ip_var.h>
! 74: #include <netinet/if_ether.h>
! 75: #include <netinet/ip_ipsp.h>
! 76:
! 77: #include <net/if_enc.h>
! 78: #include <net/if_dl.h>
! 79: #endif
! 80:
! 81: #ifdef INET6
! 82: #include <netinet/icmp6.h>
! 83: #include <netinet/ip6.h>
! 84: #include <netinet6/ip6_var.h>
! 85: #include <netinet6/nd6.h>
! 86: #include <netinet6/in6_ifattach.h>
! 87: #endif
! 88:
! 89: #include "bpfilter.h"
! 90: #if NBPFILTER > 0
! 91: #include <net/bpf.h>
! 92: #endif
! 93:
! 94: #include <netinet/ip_carp.h>
! 95:
! 96: struct carp_mc_entry {
! 97: LIST_ENTRY(carp_mc_entry) mc_entries;
! 98: union {
! 99: struct ether_multi *mcu_enm;
! 100: } mc_u;
! 101: struct sockaddr_storage mc_addr;
! 102: };
! 103: #define mc_enm mc_u.mcu_enm
! 104:
! 105: enum { HMAC_ORIG=0, HMAC_NOV6LL=1, HMAC_MAX=2 };
! 106:
! 107: struct carp_softc {
! 108: struct arpcom sc_ac;
! 109: #define sc_if sc_ac.ac_if
! 110: #define sc_carpdev sc_ac.ac_if.if_carpdev
! 111: void *ah_cookie;
! 112: void *lh_cookie;
! 113: struct ip_moptions sc_imo;
! 114: #ifdef INET6
! 115: struct ip6_moptions sc_im6o;
! 116: #endif /* INET6 */
! 117: TAILQ_ENTRY(carp_softc) sc_list;
! 118:
! 119: enum { INIT = 0, BACKUP, MASTER } sc_state;
! 120:
! 121: int sc_suppress;
! 122: int sc_bow_out;
! 123:
! 124: int sc_sendad_errors;
! 125: #define CARP_SENDAD_MAX_ERRORS 3
! 126: int sc_sendad_success;
! 127: #define CARP_SENDAD_MIN_SUCCESS 3
! 128:
! 129: char sc_carplladdr[ETHER_ADDR_LEN];
! 130: char sc_curlladdr[ETHER_ADDR_LEN];
! 131: int sc_vhid;
! 132: int sc_advskew;
! 133: int sc_naddrs;
! 134: int sc_naddrs6;
! 135: int sc_advbase; /* seconds */
! 136: int sc_init_counter;
! 137: u_int64_t sc_counter;
! 138:
! 139: /* authentication */
! 140: #define CARP_HMAC_PAD 64
! 141: unsigned char sc_key[CARP_KEY_LEN];
! 142: unsigned char sc_pad[CARP_HMAC_PAD];
! 143:
! 144: SHA1_CTX sc_sha1[HMAC_MAX];
! 145: u_int32_t sc_hashkey[2];
! 146: u_int32_t sc_lsmask; /* load sharing mask */
! 147: int sc_lscount; /* # load sharing interfaces (max 32) */
! 148:
! 149: struct timeout sc_ad_tmo; /* advertisement timeout */
! 150: struct timeout sc_md_tmo; /* master down timeout */
! 151: struct timeout sc_md6_tmo; /* master down timeout */
! 152: int sc_delayed_arp; /* delayed ARP request countdown */
! 153:
! 154: LIST_HEAD(__carp_mchead, carp_mc_entry) carp_mc_listhead;
! 155: };
! 156:
! 157: int carp_opts[CARPCTL_MAXID] = { 0, 1, 0, 0, 0 }; /* XXX for now */
! 158: struct carpstats carpstats;
! 159:
! 160: struct carp_if {
! 161: TAILQ_HEAD(, carp_softc) vhif_vrs;
! 162: int vhif_nvrs;
! 163:
! 164: struct ifnet *vhif_ifp;
! 165: };
! 166:
! 167: #define CARP_LOG(sc, s) \
! 168: if (carp_opts[CARPCTL_LOG]) { \
! 169: if (sc) \
! 170: log(LOG_INFO, "%s: ", \
! 171: (sc)->sc_if.if_xname); \
! 172: else \
! 173: log(LOG_INFO, "carp: "); \
! 174: addlog s; \
! 175: addlog("\n"); \
! 176: }
! 177:
! 178: void carp_hmac_prepare(struct carp_softc *);
! 179: void carp_hmac_prepare_ctx(struct carp_softc *, u_int8_t);
! 180: void carp_hmac_generate(struct carp_softc *, u_int32_t *,
! 181: unsigned char *, u_int8_t);
! 182: int carp_hmac_verify(struct carp_softc *, u_int32_t *,
! 183: unsigned char *);
! 184: void carp_setroute(struct carp_softc *, int);
! 185: void carp_proto_input_c(struct mbuf *, struct carp_header *, sa_family_t);
! 186: void carpattach(int);
! 187: void carpdetach(struct carp_softc *);
! 188: int carp_prepare_ad(struct mbuf *, struct carp_softc *,
! 189: struct carp_header *);
! 190: void carp_send_ad_all(void);
! 191: void carp_send_ad(void *);
! 192: void carp_send_arp(struct carp_softc *);
! 193: void carp_master_down(void *);
! 194: int carp_ioctl(struct ifnet *, u_long, caddr_t);
! 195: void carp_ifgroup_ioctl(struct ifnet *, u_long, caddr_t);
! 196: void carp_ifgattr_ioctl(struct ifnet *, u_long, caddr_t);
! 197: void carp_start(struct ifnet *);
! 198: void carp_setrun(struct carp_softc *, sa_family_t);
! 199: void carp_set_state(struct carp_softc *, int);
! 200: int carp_addrcount(struct carp_if *, struct ifaddr *, int);
! 201: enum { CARP_COUNT_MASTER, CARP_COUNT_RUNNING, CARP_COUNT_LINK0 };
! 202: void carp_multicast_cleanup(struct carp_softc *);
! 203: int carp_set_ifp(struct carp_softc *, struct ifnet *);
! 204: void carp_set_enaddr(struct carp_softc *);
! 205: void carp_addr_updated(void *);
! 206: u_int32_t carp_hash(struct carp_softc *, u_char *);
! 207: int carp_set_addr(struct carp_softc *, struct sockaddr_in *);
! 208: int carp_join_multicast(struct carp_softc *);
! 209: #ifdef INET6
! 210: void carp_send_na(struct carp_softc *);
! 211: int carp_set_addr6(struct carp_softc *, struct sockaddr_in6 *);
! 212: int carp_join_multicast6(struct carp_softc *);
! 213: #endif
! 214: int carp_clone_create(struct if_clone *, int);
! 215: int carp_clone_destroy(struct ifnet *);
! 216: int carp_ether_addmulti(struct carp_softc *, struct ifreq *);
! 217: int carp_ether_delmulti(struct carp_softc *, struct ifreq *);
! 218: void carp_ether_purgemulti(struct carp_softc *);
! 219: int carp_group_demote_count(struct carp_softc *);
! 220: void carp_update_lsmask(struct carp_softc *);
! 221:
! 222: struct if_clone carp_cloner =
! 223: IF_CLONE_INITIALIZER("carp", carp_clone_create, carp_clone_destroy);
! 224:
! 225: #define carp_cksum(_m, _l) ((u_int16_t)in_cksum((_m), (_l)))
! 226:
! 227: void
! 228: carp_hmac_prepare(struct carp_softc *sc)
! 229: {
! 230: u_int8_t i;
! 231:
! 232: for (i=0; i < HMAC_MAX; i++)
! 233: carp_hmac_prepare_ctx(sc, i);
! 234: }
! 235:
! 236: void
! 237: carp_hmac_prepare_ctx(struct carp_softc *sc, u_int8_t ctx)
! 238: {
! 239: u_int8_t version = CARP_VERSION, type = CARP_ADVERTISEMENT;
! 240: u_int8_t vhid = sc->sc_vhid & 0xff;
! 241: SHA1_CTX sha1ctx;
! 242: u_int32_t kmd[5];
! 243: struct ifaddr *ifa;
! 244: int i, found;
! 245: struct in_addr last, cur, in;
! 246: #ifdef INET6
! 247: struct in6_addr last6, cur6, in6;
! 248: #endif /* INET6 */
! 249:
! 250: /* compute ipad from key */
! 251: bzero(sc->sc_pad, sizeof(sc->sc_pad));
! 252: bcopy(sc->sc_key, sc->sc_pad, sizeof(sc->sc_key));
! 253: for (i = 0; i < sizeof(sc->sc_pad); i++)
! 254: sc->sc_pad[i] ^= 0x36;
! 255:
! 256: /* precompute first part of inner hash */
! 257: SHA1Init(&sc->sc_sha1[ctx]);
! 258: SHA1Update(&sc->sc_sha1[ctx], sc->sc_pad, sizeof(sc->sc_pad));
! 259: SHA1Update(&sc->sc_sha1[ctx], (void *)&version, sizeof(version));
! 260: SHA1Update(&sc->sc_sha1[ctx], (void *)&type, sizeof(type));
! 261:
! 262: /* generate a key for the arpbalance hash, before the vhid is hashed */
! 263: bcopy(&sc->sc_sha1[ctx], &sha1ctx, sizeof(sha1ctx));
! 264: SHA1Final((unsigned char *)kmd, &sha1ctx);
! 265: sc->sc_hashkey[0] = kmd[0] ^ kmd[1];
! 266: sc->sc_hashkey[1] = kmd[2] ^ kmd[3];
! 267:
! 268: /* the rest of the precomputation */
! 269: if (bcmp(sc->sc_ac.ac_enaddr, sc->sc_carplladdr, ETHER_ADDR_LEN) != 0)
! 270: SHA1Update(&sc->sc_sha1[ctx], sc->sc_ac.ac_enaddr,
! 271: ETHER_ADDR_LEN);
! 272:
! 273: SHA1Update(&sc->sc_sha1[ctx], (void *)&vhid, sizeof(vhid));
! 274:
! 275: /* Hash the addresses from smallest to largest, not interface order */
! 276: #ifdef INET
! 277: cur.s_addr = 0;
! 278: do {
! 279: found = 0;
! 280: last = cur;
! 281: cur.s_addr = 0xffffffff;
! 282: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 283: in.s_addr = ifatoia(ifa)->ia_addr.sin_addr.s_addr;
! 284: if (ifa->ifa_addr->sa_family == AF_INET &&
! 285: ntohl(in.s_addr) > ntohl(last.s_addr) &&
! 286: ntohl(in.s_addr) < ntohl(cur.s_addr)) {
! 287: cur.s_addr = in.s_addr;
! 288: found++;
! 289: }
! 290: }
! 291: if (found)
! 292: SHA1Update(&sc->sc_sha1[ctx],
! 293: (void *)&cur, sizeof(cur));
! 294: } while (found);
! 295: #endif /* INET */
! 296: #ifdef INET6
! 297: memset(&cur6, 0x00, sizeof(cur6));
! 298: do {
! 299: found = 0;
! 300: last6 = cur6;
! 301: memset(&cur6, 0xff, sizeof(cur6));
! 302: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 303: in6 = ifatoia6(ifa)->ia_addr.sin6_addr;
! 304: if (IN6_IS_SCOPE_EMBED(&in6)) {
! 305: if (ctx == HMAC_NOV6LL)
! 306: continue;
! 307: in6.s6_addr16[1] = 0;
! 308: }
! 309: if (ifa->ifa_addr->sa_family == AF_INET6 &&
! 310: memcmp(&in6, &last6, sizeof(in6)) > 0 &&
! 311: memcmp(&in6, &cur6, sizeof(in6)) < 0) {
! 312: cur6 = in6;
! 313: found++;
! 314: }
! 315: }
! 316: if (found)
! 317: SHA1Update(&sc->sc_sha1[ctx],
! 318: (void *)&cur6, sizeof(cur6));
! 319: } while (found);
! 320: #endif /* INET6 */
! 321:
! 322: /* convert ipad to opad */
! 323: for (i = 0; i < sizeof(sc->sc_pad); i++)
! 324: sc->sc_pad[i] ^= 0x36 ^ 0x5c;
! 325: }
! 326:
! 327: void
! 328: carp_hmac_generate(struct carp_softc *sc, u_int32_t counter[2],
! 329: unsigned char md[20], u_int8_t ctx)
! 330: {
! 331: SHA1_CTX sha1ctx;
! 332:
! 333: /* fetch first half of inner hash */
! 334: bcopy(&sc->sc_sha1[ctx], &sha1ctx, sizeof(sha1ctx));
! 335:
! 336: SHA1Update(&sha1ctx, (void *)counter, sizeof(sc->sc_counter));
! 337: SHA1Final(md, &sha1ctx);
! 338:
! 339: /* outer hash */
! 340: SHA1Init(&sha1ctx);
! 341: SHA1Update(&sha1ctx, sc->sc_pad, sizeof(sc->sc_pad));
! 342: SHA1Update(&sha1ctx, md, 20);
! 343: SHA1Final(md, &sha1ctx);
! 344: }
! 345:
! 346: int
! 347: carp_hmac_verify(struct carp_softc *sc, u_int32_t counter[2],
! 348: unsigned char md[20])
! 349: {
! 350: unsigned char md2[20];
! 351: u_int8_t i;
! 352:
! 353: for (i=0; i < HMAC_MAX; i++) {
! 354: carp_hmac_generate(sc, counter, md2, i);
! 355: if (!bcmp(md, md2, sizeof(md2)))
! 356: return (0);
! 357: }
! 358: return (1);
! 359: }
! 360:
! 361: void
! 362: carp_setroute(struct carp_softc *sc, int cmd)
! 363: {
! 364: struct ifaddr *ifa;
! 365: int s;
! 366:
! 367: /* XXX this mess needs fixing */
! 368:
! 369: s = splsoftnet();
! 370: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 371: switch (ifa->ifa_addr->sa_family) {
! 372: case AF_INET: {
! 373: int count = 0, error;
! 374: struct sockaddr sa;
! 375: struct rtentry *rt;
! 376: struct radix_node_head *rnh;
! 377: struct radix_node *rn;
! 378: struct rt_addrinfo info;
! 379: int hr_otherif, nr_ourif;
! 380: struct sockaddr_rtlabel sa_rl;
! 381: const char *label;
! 382:
! 383: /*
! 384: * Avoid screwing with the routes if there are other
! 385: * carp interfaces which are master and have the same
! 386: * address.
! 387: */
! 388: if (sc->sc_carpdev != NULL &&
! 389: sc->sc_carpdev->if_carp != NULL) {
! 390: count = carp_addrcount(
! 391: (struct carp_if *)sc->sc_carpdev->if_carp,
! 392: ifa, CARP_COUNT_MASTER);
! 393: if ((cmd == RTM_ADD && count != 1) ||
! 394: (cmd == RTM_DELETE && count != 0))
! 395: continue;
! 396: }
! 397:
! 398: /* Remove the existing host route, if any */
! 399: bzero(&info, sizeof(info));
! 400: info.rti_info[RTAX_DST] = ifa->ifa_addr;
! 401: info.rti_flags = RTF_HOST;
! 402: error = rtrequest1(RTM_DELETE, &info, NULL, 0);
! 403: rt_missmsg(RTM_DELETE, &info, info.rti_flags, NULL,
! 404: error, 0);
! 405:
! 406:
! 407: /* Check for our address on another interface */
! 408: /* XXX cries for proper API */
! 409: rnh = rt_gettable(ifa->ifa_addr->sa_family, 0);
! 410: rn = rnh->rnh_matchaddr(ifa->ifa_addr, rnh);
! 411: rt = (struct rtentry *)rn;
! 412: hr_otherif = (rt && rt->rt_ifp != &sc->sc_if &&
! 413: rt->rt_flags & (RTF_CLONING|RTF_CLONED));
! 414:
! 415: /* Check for a network route on our interface */
! 416: bcopy(ifa->ifa_addr, &sa, sizeof(sa));
! 417: satosin(&sa)->sin_addr.s_addr = satosin(ifa->ifa_netmask
! 418: )->sin_addr.s_addr & satosin(&sa)->sin_addr.s_addr;
! 419: rt = (struct rtentry *)rt_lookup(&sa,
! 420: ifa->ifa_netmask, 0);
! 421: nr_ourif = (rt && rt->rt_ifp == &sc->sc_if);
! 422:
! 423: /* Restore the route label */
! 424: bzero(&sa_rl, sizeof(sa_rl));
! 425: if (rt && rt->rt_labelid) {
! 426: sa_rl.sr_len = sizeof(sa_rl);
! 427: sa_rl.sr_family = AF_UNSPEC;
! 428: label = rtlabel_id2name(rt->rt_labelid);
! 429: if (label != NULL)
! 430: strlcpy(sa_rl.sr_label, label,
! 431: sizeof(sa_rl.sr_label));
! 432: }
! 433:
! 434: switch (cmd) {
! 435: case RTM_ADD:
! 436: if (hr_otherif) {
! 437: ifa->ifa_rtrequest = NULL;
! 438: ifa->ifa_flags &= ~RTF_CLONING;
! 439: bzero(&info, sizeof(info));
! 440: info.rti_info[RTAX_DST] = ifa->ifa_addr;
! 441: info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
! 442: info.rti_flags = RTF_UP | RTF_HOST;
! 443: error = rtrequest1(RTM_ADD, &info, NULL, 0);
! 444: rt_missmsg(RTM_ADD, &info, info.rti_flags, NULL,
! 445: error, 0);
! 446: }
! 447: if (!hr_otherif || nr_ourif || !rt) {
! 448: if (nr_ourif && !(rt->rt_flags &
! 449: RTF_CLONING)) {
! 450: bzero(&info, sizeof(info));
! 451: info.rti_info[RTAX_DST] = &sa;
! 452: info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
! 453: error = rtrequest1(RTM_DELETE, &info, NULL, 0);
! 454: rt_missmsg(RTM_DELETE, &info, info.rti_flags, NULL,
! 455: error, 0);
! 456: }
! 457:
! 458: ifa->ifa_rtrequest = arp_rtrequest;
! 459: ifa->ifa_flags |= RTF_CLONING;
! 460:
! 461: bzero(&info, sizeof(info));
! 462: info.rti_info[RTAX_DST] = &sa;
! 463: info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
! 464: info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
! 465: info.rti_info[RTAX_LABEL] =
! 466: (struct sockaddr *)&sa_rl;
! 467: error = rtrequest1(RTM_ADD, &info, NULL, 0);
! 468: if (error == 0)
! 469: ifa->ifa_flags |= IFA_ROUTE;
! 470: rt_missmsg(RTM_ADD, &info, info.rti_flags, NULL,
! 471: error, 0);
! 472: }
! 473: break;
! 474: case RTM_DELETE:
! 475: break;
! 476: default:
! 477: break;
! 478: }
! 479: break;
! 480: }
! 481:
! 482: #ifdef INET6
! 483: case AF_INET6:
! 484: if (cmd == RTM_ADD)
! 485: in6_ifaddloop(ifa);
! 486: else
! 487: in6_ifremloop(ifa);
! 488: break;
! 489: #endif /* INET6 */
! 490: default:
! 491: break;
! 492: }
! 493: }
! 494: splx(s);
! 495: }
! 496:
! 497: /*
! 498: * process input packet.
! 499: * we have rearranged checks order compared to the rfc,
! 500: * but it seems more efficient this way or not possible otherwise.
! 501: */
! 502: void
! 503: carp_proto_input(struct mbuf *m, ...)
! 504: {
! 505: struct ip *ip = mtod(m, struct ip *);
! 506: struct carp_softc *sc = NULL;
! 507: struct carp_header *ch;
! 508: int iplen, len, hlen;
! 509: va_list ap;
! 510:
! 511: va_start(ap, m);
! 512: hlen = va_arg(ap, int);
! 513: va_end(ap);
! 514:
! 515: carpstats.carps_ipackets++;
! 516:
! 517: if (!carp_opts[CARPCTL_ALLOW]) {
! 518: m_freem(m);
! 519: return;
! 520: }
! 521:
! 522: /* check if received on a valid carp interface */
! 523: if (m->m_pkthdr.rcvif->if_type != IFT_CARP) {
! 524: carpstats.carps_badif++;
! 525: CARP_LOG(sc, ("packet received on non-carp interface: %s",
! 526: m->m_pkthdr.rcvif->if_xname));
! 527: m_freem(m);
! 528: return;
! 529: }
! 530:
! 531: /* verify that the IP TTL is 255. */
! 532: if (ip->ip_ttl != CARP_DFLTTL) {
! 533: carpstats.carps_badttl++;
! 534: CARP_LOG(sc, ("received ttl %d != %d on %s", ip->ip_ttl,
! 535: CARP_DFLTTL, m->m_pkthdr.rcvif->if_xname));
! 536: m_freem(m);
! 537: return;
! 538: }
! 539:
! 540: /*
! 541: * verify that the received packet length is
! 542: * equal to the CARP header
! 543: */
! 544: iplen = ip->ip_hl << 2;
! 545: len = iplen + sizeof(*ch);
! 546: if (len > m->m_pkthdr.len) {
! 547: carpstats.carps_badlen++;
! 548: CARP_LOG(sc, ("packet too short %d on %s", m->m_pkthdr.len,
! 549: m->m_pkthdr.rcvif->if_xname));
! 550: m_freem(m);
! 551: return;
! 552: }
! 553:
! 554: if ((m = m_pullup2(m, len)) == NULL) {
! 555: carpstats.carps_hdrops++;
! 556: return;
! 557: }
! 558: ip = mtod(m, struct ip *);
! 559: ch = (void *)ip + iplen;
! 560:
! 561: /* verify the CARP checksum */
! 562: m->m_data += iplen;
! 563: if (carp_cksum(m, len - iplen)) {
! 564: carpstats.carps_badsum++;
! 565: CARP_LOG(sc, ("checksum failed on %s",
! 566: m->m_pkthdr.rcvif->if_xname));
! 567: m_freem(m);
! 568: return;
! 569: }
! 570: m->m_data -= iplen;
! 571:
! 572: carp_proto_input_c(m, ch, AF_INET);
! 573: }
! 574:
! 575: #ifdef INET6
! 576: int
! 577: carp6_proto_input(struct mbuf **mp, int *offp, int proto)
! 578: {
! 579: struct mbuf *m = *mp;
! 580: struct carp_softc *sc = NULL;
! 581: struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
! 582: struct carp_header *ch;
! 583: u_int len;
! 584:
! 585: carpstats.carps_ipackets6++;
! 586:
! 587: if (!carp_opts[CARPCTL_ALLOW]) {
! 588: m_freem(m);
! 589: return (IPPROTO_DONE);
! 590: }
! 591:
! 592: /* check if received on a valid carp interface */
! 593: if (m->m_pkthdr.rcvif->if_type != IFT_CARP) {
! 594: carpstats.carps_badif++;
! 595: CARP_LOG(sc, ("packet received on non-carp interface: %s",
! 596: m->m_pkthdr.rcvif->if_xname));
! 597: m_freem(m);
! 598: return (IPPROTO_DONE);
! 599: }
! 600:
! 601: /* verify that the IP TTL is 255 */
! 602: if (ip6->ip6_hlim != CARP_DFLTTL) {
! 603: carpstats.carps_badttl++;
! 604: CARP_LOG(sc, ("received ttl %d != %d on %s", ip6->ip6_hlim,
! 605: CARP_DFLTTL, m->m_pkthdr.rcvif->if_xname));
! 606: m_freem(m);
! 607: return (IPPROTO_DONE);
! 608: }
! 609:
! 610: /* verify that we have a complete carp packet */
! 611: len = m->m_len;
! 612: IP6_EXTHDR_GET(ch, struct carp_header *, m, *offp, sizeof(*ch));
! 613: if (ch == NULL) {
! 614: carpstats.carps_badlen++;
! 615: CARP_LOG(sc, ("packet size %u too small", len));
! 616: return (IPPROTO_DONE);
! 617: }
! 618:
! 619:
! 620: /* verify the CARP checksum */
! 621: m->m_data += *offp;
! 622: if (carp_cksum(m, sizeof(*ch))) {
! 623: carpstats.carps_badsum++;
! 624: CARP_LOG(sc, ("checksum failed, on %s",
! 625: m->m_pkthdr.rcvif->if_xname));
! 626: m_freem(m);
! 627: return (IPPROTO_DONE);
! 628: }
! 629: m->m_data -= *offp;
! 630:
! 631: carp_proto_input_c(m, ch, AF_INET6);
! 632: return (IPPROTO_DONE);
! 633: }
! 634: #endif /* INET6 */
! 635:
! 636: void
! 637: carp_proto_input_c(struct mbuf *m, struct carp_header *ch, sa_family_t af)
! 638: {
! 639: struct carp_softc *sc;
! 640: u_int64_t tmp_counter;
! 641: struct timeval sc_tv, ch_tv;
! 642:
! 643: TAILQ_FOREACH(sc, &((struct carp_if *)
! 644: m->m_pkthdr.rcvif->if_carpdev->if_carp)->vhif_vrs, sc_list)
! 645: if (sc->sc_vhid == ch->carp_vhid)
! 646: break;
! 647:
! 648: if (!sc || (sc->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
! 649: (IFF_UP|IFF_RUNNING)) {
! 650: carpstats.carps_badvhid++;
! 651: m_freem(m);
! 652: return;
! 653: }
! 654:
! 655: /*
! 656: * Check if our own advertisement was duplicated
! 657: * from a non simplex interface.
! 658: * XXX If there is no address on our physical interface
! 659: * there is no way to distinguish our ads from the ones
! 660: * another carp host might have sent us.
! 661: */
! 662: if ((sc->sc_carpdev->if_flags & IFF_SIMPLEX) == 0) {
! 663: struct sockaddr sa;
! 664: struct ifaddr *ifa;
! 665:
! 666: bzero(&sa, sizeof(sa));
! 667: sa.sa_family = af;
! 668: ifa = ifaof_ifpforaddr(&sa, sc->sc_carpdev);
! 669:
! 670: if (ifa && af == AF_INET) {
! 671: struct ip *ip = mtod(m, struct ip *);
! 672: if (ip->ip_src.s_addr ==
! 673: ifatoia(ifa)->ia_addr.sin_addr.s_addr) {
! 674: m_freem(m);
! 675: return;
! 676: }
! 677: }
! 678: #ifdef INET6
! 679: if (ifa && af == AF_INET6) {
! 680: struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
! 681: struct in6_addr in6_src, in6_found;
! 682:
! 683: in6_src = ip6->ip6_src;
! 684: in6_found = ifatoia6(ifa)->ia_addr.sin6_addr;
! 685: if (IN6_IS_SCOPE_EMBED(&in6_src))
! 686: in6_src.s6_addr16[1] = 0;
! 687: if (IN6_IS_SCOPE_EMBED(&in6_found))
! 688: in6_found.s6_addr16[1] = 0;
! 689: if (IN6_ARE_ADDR_EQUAL(&in6_src, &in6_found)) {
! 690: m_freem(m);
! 691: return;
! 692: }
! 693: }
! 694: #endif /* INET6 */
! 695: }
! 696:
! 697: getmicrotime(&sc->sc_if.if_lastchange);
! 698: sc->sc_if.if_ipackets++;
! 699: sc->sc_if.if_ibytes += m->m_pkthdr.len;
! 700:
! 701: /* verify the CARP version. */
! 702: if (ch->carp_version != CARP_VERSION) {
! 703: carpstats.carps_badver++;
! 704: sc->sc_if.if_ierrors++;
! 705: CARP_LOG(sc, ("invalid version %d != %d",
! 706: ch->carp_version, CARP_VERSION));
! 707: m_freem(m);
! 708: return;
! 709: }
! 710:
! 711: /* verify the hash */
! 712: if (carp_hmac_verify(sc, ch->carp_counter, ch->carp_md)) {
! 713: carpstats.carps_badauth++;
! 714: sc->sc_if.if_ierrors++;
! 715: CARP_LOG(sc, ("incorrect hash"));
! 716: m_freem(m);
! 717: return;
! 718: }
! 719:
! 720: tmp_counter = ntohl(ch->carp_counter[0]);
! 721: tmp_counter = tmp_counter<<32;
! 722: tmp_counter += ntohl(ch->carp_counter[1]);
! 723:
! 724: /* XXX Replay protection goes here */
! 725:
! 726: sc->sc_init_counter = 0;
! 727: sc->sc_counter = tmp_counter;
! 728:
! 729:
! 730: sc_tv.tv_sec = sc->sc_advbase;
! 731: if (carp_group_demote_count(sc) && sc->sc_advskew < 240)
! 732: sc_tv.tv_usec = 240 * 1000000 / 256;
! 733: else
! 734: sc_tv.tv_usec = sc->sc_advskew * 1000000 / 256;
! 735: ch_tv.tv_sec = ch->carp_advbase;
! 736: ch_tv.tv_usec = ch->carp_advskew * 1000000 / 256;
! 737:
! 738: switch (sc->sc_state) {
! 739: case INIT:
! 740: break;
! 741: case MASTER:
! 742: /*
! 743: * If we receive an advertisement from a master who's going to
! 744: * be more frequent than us, go into BACKUP state.
! 745: */
! 746: if (timercmp(&sc_tv, &ch_tv, >) ||
! 747: (timercmp(&sc_tv, &ch_tv, ==) &&
! 748: ch->carp_demote <=
! 749: (carp_group_demote_count(sc) & 0xff))) {
! 750: timeout_del(&sc->sc_ad_tmo);
! 751: carp_set_state(sc, BACKUP);
! 752: carp_setrun(sc, 0);
! 753: carp_setroute(sc, RTM_DELETE);
! 754: }
! 755: break;
! 756: case BACKUP:
! 757: /*
! 758: * If we're pre-empting masters who advertise slower than us,
! 759: * and this one claims to be slower, treat him as down.
! 760: */
! 761: if (carp_opts[CARPCTL_PREEMPT] && timercmp(&sc_tv, &ch_tv, <)) {
! 762: carp_master_down(sc);
! 763: break;
! 764: }
! 765:
! 766: /*
! 767: * Take over masters advertising with a higher demote count,
! 768: * regardless of CARPCTL_PREEMPT.
! 769: */
! 770: if (ch->carp_demote > (carp_group_demote_count(sc) & 0xff)) {
! 771: carp_master_down(sc);
! 772: break;
! 773: }
! 774:
! 775: /*
! 776: * If the master is going to advertise at such a low frequency
! 777: * that he's guaranteed to time out, we'd might as well just
! 778: * treat him as timed out now.
! 779: */
! 780: sc_tv.tv_sec = sc->sc_advbase * 3;
! 781: if (timercmp(&sc_tv, &ch_tv, <)) {
! 782: carp_master_down(sc);
! 783: break;
! 784: }
! 785:
! 786: /*
! 787: * Otherwise, we reset the counter and wait for the next
! 788: * advertisement.
! 789: */
! 790: carp_setrun(sc, af);
! 791: break;
! 792: }
! 793:
! 794: m_freem(m);
! 795: return;
! 796: }
! 797:
! 798: int
! 799: carp_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
! 800: size_t newlen)
! 801: {
! 802: /* All sysctl names at this level are terminal. */
! 803: if (namelen != 1)
! 804: return (ENOTDIR);
! 805:
! 806: if (name[0] <= 0 || name[0] >= CARPCTL_MAXID)
! 807: return (ENOPROTOOPT);
! 808:
! 809: return sysctl_int(oldp, oldlenp, newp, newlen, &carp_opts[name[0]]);
! 810: }
! 811:
! 812: /*
! 813: * Interface side of the CARP implementation.
! 814: */
! 815:
! 816: /* ARGSUSED */
! 817: void
! 818: carpattach(int n)
! 819: {
! 820: struct ifg_group *ifg;
! 821:
! 822: if ((ifg = if_creategroup("carp")) != NULL)
! 823: ifg->ifg_refcnt++; /* keep around even if empty */
! 824: if_clone_attach(&carp_cloner);
! 825: }
! 826:
! 827: int
! 828: carp_clone_create(ifc, unit)
! 829: struct if_clone *ifc;
! 830: int unit;
! 831: {
! 832: struct carp_softc *sc;
! 833: struct ifnet *ifp;
! 834:
! 835: sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
! 836: if (!sc)
! 837: return (ENOMEM);
! 838: bzero(sc, sizeof(*sc));
! 839:
! 840: sc->sc_suppress = 0;
! 841: sc->sc_advbase = CARP_DFLTINTV;
! 842: sc->sc_vhid = -1; /* required setting */
! 843: sc->sc_advskew = 0;
! 844: sc->sc_init_counter = 1;
! 845: sc->sc_naddrs = sc->sc_naddrs6 = 0;
! 846: #ifdef INET6
! 847: sc->sc_im6o.im6o_multicast_hlim = CARP_DFLTTL;
! 848: #endif /* INET6 */
! 849:
! 850: timeout_set(&sc->sc_ad_tmo, carp_send_ad, sc);
! 851: timeout_set(&sc->sc_md_tmo, carp_master_down, sc);
! 852: timeout_set(&sc->sc_md6_tmo, carp_master_down, sc);
! 853:
! 854: LIST_INIT(&sc->carp_mc_listhead);
! 855: ifp = &sc->sc_if;
! 856: ifp->if_softc = sc;
! 857: snprintf(ifp->if_xname, sizeof ifp->if_xname, "%s%d", ifc->ifc_name,
! 858: unit);
! 859: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
! 860: ifp->if_ioctl = carp_ioctl;
! 861: ifp->if_start = carp_start;
! 862: ifp->if_output = carp_output;
! 863: ifp->if_type = IFT_CARP;
! 864: ifp->if_addrlen = ETHER_ADDR_LEN;
! 865: ifp->if_hdrlen = ETHER_HDR_LEN;
! 866: ifp->if_mtu = ETHERMTU;
! 867: IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
! 868: IFQ_SET_READY(&ifp->if_snd);
! 869: if_attach(ifp);
! 870:
! 871: if_alloc_sadl(ifp);
! 872: LIST_INIT(&sc->sc_ac.ac_multiaddrs);
! 873: #if NBPFILTER > 0
! 874: bpfattach(&ifp->if_bpf, ifp, DLT_EN10MB, ETHER_HDR_LEN);
! 875: #endif
! 876: return (0);
! 877: }
! 878:
! 879: int
! 880: carp_clone_destroy(struct ifnet *ifp)
! 881: {
! 882: carpdetach(ifp->if_softc);
! 883: ether_ifdetach(ifp);
! 884: if_detach(ifp);
! 885: free(ifp->if_softc, M_DEVBUF);
! 886:
! 887: return (0);
! 888: }
! 889:
! 890: void
! 891: carpdetach(struct carp_softc *sc)
! 892: {
! 893: struct carp_if *cif;
! 894: int s;
! 895:
! 896: timeout_del(&sc->sc_ad_tmo);
! 897: timeout_del(&sc->sc_md_tmo);
! 898: timeout_del(&sc->sc_md6_tmo);
! 899:
! 900: if (sc->sc_suppress)
! 901: carp_group_demote_adj(&sc->sc_if, -1);
! 902: sc->sc_suppress = 0;
! 903:
! 904: if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS)
! 905: carp_group_demote_adj(&sc->sc_if, -1);
! 906: sc->sc_sendad_errors = 0;
! 907:
! 908: carp_set_state(sc, INIT);
! 909: sc->sc_if.if_flags &= ~IFF_UP;
! 910: carp_setrun(sc, 0);
! 911: carp_multicast_cleanup(sc);
! 912:
! 913: s = splnet();
! 914: if (sc->sc_carpdev != NULL) {
! 915: if (sc->lh_cookie != NULL)
! 916: hook_disestablish(sc->sc_carpdev->if_linkstatehooks,
! 917: sc->lh_cookie);
! 918: cif = (struct carp_if *)sc->sc_carpdev->if_carp;
! 919: TAILQ_REMOVE(&cif->vhif_vrs, sc, sc_list);
! 920: if (!--cif->vhif_nvrs) {
! 921: ifpromisc(sc->sc_carpdev, 0);
! 922: sc->sc_carpdev->if_carp = NULL;
! 923: FREE(cif, M_IFADDR);
! 924: }
! 925: }
! 926: sc->sc_carpdev = NULL;
! 927: splx(s);
! 928: }
! 929:
! 930: /* Detach an interface from the carp. */
! 931: void
! 932: carp_ifdetach(struct ifnet *ifp)
! 933: {
! 934: struct carp_softc *sc, *nextsc;
! 935: struct carp_if *cif = (struct carp_if *)ifp->if_carp;
! 936:
! 937: for (sc = TAILQ_FIRST(&cif->vhif_vrs); sc; sc = nextsc) {
! 938: nextsc = TAILQ_NEXT(sc, sc_list);
! 939: carpdetach(sc);
! 940: }
! 941: }
! 942:
! 943: int
! 944: carp_prepare_ad(struct mbuf *m, struct carp_softc *sc, struct carp_header *ch)
! 945: {
! 946: if (sc->sc_init_counter) {
! 947: /* this could also be seconds since unix epoch */
! 948: sc->sc_counter = arc4random();
! 949: sc->sc_counter = sc->sc_counter << 32;
! 950: sc->sc_counter += arc4random();
! 951: } else
! 952: sc->sc_counter++;
! 953:
! 954: ch->carp_counter[0] = htonl((sc->sc_counter>>32)&0xffffffff);
! 955: ch->carp_counter[1] = htonl(sc->sc_counter&0xffffffff);
! 956:
! 957: /*
! 958: * For the time being, do not include the IPv6 linklayer addresses
! 959: * in the HMAC.
! 960: */
! 961: carp_hmac_generate(sc, ch->carp_counter, ch->carp_md, HMAC_NOV6LL);
! 962:
! 963: return (0);
! 964: }
! 965:
! 966: void
! 967: carp_send_ad_all(void)
! 968: {
! 969: struct ifnet *ifp;
! 970: struct carp_if *cif;
! 971: struct carp_softc *vh;
! 972:
! 973: TAILQ_FOREACH(ifp, &ifnet, if_list) {
! 974: if (ifp->if_carp == NULL || ifp->if_type == IFT_CARP)
! 975: continue;
! 976:
! 977: cif = (struct carp_if *)ifp->if_carp;
! 978: TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) {
! 979: if ((vh->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) ==
! 980: (IFF_UP|IFF_RUNNING) && vh->sc_state == MASTER)
! 981: carp_send_ad(vh);
! 982: }
! 983: }
! 984: }
! 985:
! 986:
! 987: void
! 988: carp_send_ad(void *v)
! 989: {
! 990: struct carp_header ch;
! 991: struct timeval tv;
! 992: struct carp_softc *sc = v;
! 993: struct carp_header *ch_ptr;
! 994: struct mbuf *m;
! 995: int error, len, advbase, advskew, s;
! 996: struct ifaddr *ifa;
! 997: struct sockaddr sa;
! 998:
! 999: s = splsoftnet();
! 1000:
! 1001: if (sc->sc_carpdev == NULL) {
! 1002: sc->sc_if.if_oerrors++;
! 1003: goto retry_later;
! 1004: }
! 1005:
! 1006: /* bow out if we've gone to backup (the carp interface is going down) */
! 1007: if (sc->sc_bow_out) {
! 1008: sc->sc_bow_out = 0;
! 1009: advbase = 255;
! 1010: advskew = 255;
! 1011: } else {
! 1012: advbase = sc->sc_advbase;
! 1013: if (!carp_group_demote_count(sc) || sc->sc_advskew > 240)
! 1014: advskew = sc->sc_advskew;
! 1015: else
! 1016: advskew = 240;
! 1017: tv.tv_sec = advbase;
! 1018: tv.tv_usec = advskew * 1000000 / 256;
! 1019: }
! 1020:
! 1021: ch.carp_version = CARP_VERSION;
! 1022: ch.carp_type = CARP_ADVERTISEMENT;
! 1023: ch.carp_vhid = sc->sc_vhid;
! 1024: ch.carp_demote = carp_group_demote_count(sc) & 0xff;
! 1025: ch.carp_advbase = advbase;
! 1026: ch.carp_advskew = advskew;
! 1027: ch.carp_authlen = 7; /* XXX DEFINE */
! 1028: ch.carp_cksum = 0;
! 1029:
! 1030:
! 1031: #ifdef INET
! 1032: if (sc->sc_naddrs) {
! 1033: struct ip *ip;
! 1034:
! 1035: MGETHDR(m, M_DONTWAIT, MT_HEADER);
! 1036: if (m == NULL) {
! 1037: sc->sc_if.if_oerrors++;
! 1038: carpstats.carps_onomem++;
! 1039: /* XXX maybe less ? */
! 1040: goto retry_later;
! 1041: }
! 1042: len = sizeof(*ip) + sizeof(ch);
! 1043: m->m_pkthdr.len = len;
! 1044: m->m_pkthdr.rcvif = NULL;
! 1045: m->m_len = len;
! 1046: MH_ALIGN(m, m->m_len);
! 1047: m->m_flags |= M_MCAST;
! 1048: ip = mtod(m, struct ip *);
! 1049: ip->ip_v = IPVERSION;
! 1050: ip->ip_hl = sizeof(*ip) >> 2;
! 1051: ip->ip_tos = IPTOS_LOWDELAY;
! 1052: ip->ip_len = htons(len);
! 1053: ip->ip_id = htons(ip_randomid());
! 1054: ip->ip_off = htons(IP_DF);
! 1055: ip->ip_ttl = CARP_DFLTTL;
! 1056: ip->ip_p = IPPROTO_CARP;
! 1057: ip->ip_sum = 0;
! 1058:
! 1059: bzero(&sa, sizeof(sa));
! 1060: sa.sa_family = AF_INET;
! 1061: ifa = ifaof_ifpforaddr(&sa, sc->sc_carpdev);
! 1062: if (ifa == NULL)
! 1063: ip->ip_src.s_addr = 0;
! 1064: else
! 1065: ip->ip_src.s_addr =
! 1066: ifatoia(ifa)->ia_addr.sin_addr.s_addr;
! 1067: ip->ip_dst.s_addr = INADDR_CARP_GROUP;
! 1068:
! 1069: ch_ptr = (void *)ip + sizeof(*ip);
! 1070: bcopy(&ch, ch_ptr, sizeof(ch));
! 1071: if (carp_prepare_ad(m, sc, ch_ptr))
! 1072: goto retry_later;
! 1073:
! 1074: m->m_data += sizeof(*ip);
! 1075: ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip));
! 1076: m->m_data -= sizeof(*ip);
! 1077:
! 1078: getmicrotime(&sc->sc_if.if_lastchange);
! 1079: sc->sc_if.if_opackets++;
! 1080: sc->sc_if.if_obytes += len;
! 1081: carpstats.carps_opackets++;
! 1082:
! 1083: error = ip_output(m, NULL, NULL, IP_RAWOUTPUT, &sc->sc_imo,
! 1084: NULL);
! 1085: if (error) {
! 1086: if (error == ENOBUFS)
! 1087: carpstats.carps_onomem++;
! 1088: else
! 1089: CARP_LOG(sc, ("ip_output failed: %d", error));
! 1090: sc->sc_if.if_oerrors++;
! 1091: if (sc->sc_sendad_errors < INT_MAX)
! 1092: sc->sc_sendad_errors++;
! 1093: if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS)
! 1094: carp_group_demote_adj(&sc->sc_if, 1);
! 1095: sc->sc_sendad_success = 0;
! 1096: } else {
! 1097: if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) {
! 1098: if (++sc->sc_sendad_success >=
! 1099: CARP_SENDAD_MIN_SUCCESS) {
! 1100: carp_group_demote_adj(&sc->sc_if, -1);
! 1101: sc->sc_sendad_errors = 0;
! 1102: }
! 1103: } else
! 1104: sc->sc_sendad_errors = 0;
! 1105: }
! 1106: if (sc->sc_delayed_arp > 0)
! 1107: sc->sc_delayed_arp--;
! 1108: if (sc->sc_delayed_arp == 0) {
! 1109: carp_send_arp(sc);
! 1110: sc->sc_delayed_arp = -1;
! 1111: }
! 1112: }
! 1113: #endif /* INET */
! 1114: #ifdef INET6
! 1115: if (sc->sc_naddrs6) {
! 1116: struct ip6_hdr *ip6;
! 1117:
! 1118: MGETHDR(m, M_DONTWAIT, MT_HEADER);
! 1119: if (m == NULL) {
! 1120: sc->sc_if.if_oerrors++;
! 1121: carpstats.carps_onomem++;
! 1122: /* XXX maybe less ? */
! 1123: goto retry_later;
! 1124: }
! 1125: len = sizeof(*ip6) + sizeof(ch);
! 1126: m->m_pkthdr.len = len;
! 1127: m->m_pkthdr.rcvif = NULL;
! 1128: m->m_len = len;
! 1129: MH_ALIGN(m, m->m_len);
! 1130: m->m_flags |= M_MCAST;
! 1131: ip6 = mtod(m, struct ip6_hdr *);
! 1132: bzero(ip6, sizeof(*ip6));
! 1133: ip6->ip6_vfc |= IPV6_VERSION;
! 1134: ip6->ip6_hlim = CARP_DFLTTL;
! 1135: ip6->ip6_nxt = IPPROTO_CARP;
! 1136:
! 1137: /* set the source address */
! 1138: bzero(&sa, sizeof(sa));
! 1139: sa.sa_family = AF_INET6;
! 1140: ifa = ifaof_ifpforaddr(&sa, sc->sc_carpdev);
! 1141: if (ifa == NULL) /* This should never happen with IPv6 */
! 1142: bzero(&ip6->ip6_src, sizeof(struct in6_addr));
! 1143: else
! 1144: bcopy(ifatoia6(ifa)->ia_addr.sin6_addr.s6_addr,
! 1145: &ip6->ip6_src, sizeof(struct in6_addr));
! 1146: /* set the multicast destination */
! 1147:
! 1148: ip6->ip6_dst.s6_addr8[0] = 0xff;
! 1149: ip6->ip6_dst.s6_addr8[1] = 0x02;
! 1150: ip6->ip6_dst.s6_addr8[15] = 0x12;
! 1151:
! 1152: ch_ptr = (void *)ip6 + sizeof(*ip6);
! 1153: bcopy(&ch, ch_ptr, sizeof(ch));
! 1154: if (carp_prepare_ad(m, sc, ch_ptr))
! 1155: goto retry_later;
! 1156:
! 1157: m->m_data += sizeof(*ip6);
! 1158: ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip6));
! 1159: m->m_data -= sizeof(*ip6);
! 1160:
! 1161: getmicrotime(&sc->sc_if.if_lastchange);
! 1162: sc->sc_if.if_opackets++;
! 1163: sc->sc_if.if_obytes += len;
! 1164: carpstats.carps_opackets6++;
! 1165:
! 1166: error = ip6_output(m, NULL, NULL, 0, &sc->sc_im6o, NULL, NULL);
! 1167: if (error) {
! 1168: if (error == ENOBUFS)
! 1169: carpstats.carps_onomem++;
! 1170: else
! 1171: CARP_LOG(sc, ("ip6_output failed: %d", error));
! 1172: sc->sc_if.if_oerrors++;
! 1173: if (sc->sc_sendad_errors < INT_MAX)
! 1174: sc->sc_sendad_errors++;
! 1175: if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS)
! 1176: carp_group_demote_adj(&sc->sc_if, 1);
! 1177: sc->sc_sendad_success = 0;
! 1178: } else {
! 1179: if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) {
! 1180: if (++sc->sc_sendad_success >=
! 1181: CARP_SENDAD_MIN_SUCCESS) {
! 1182: carp_group_demote_adj(&sc->sc_if, -1);
! 1183: sc->sc_sendad_errors = 0;
! 1184: }
! 1185: } else
! 1186: sc->sc_sendad_errors = 0;
! 1187: }
! 1188: }
! 1189: #endif /* INET6 */
! 1190:
! 1191: retry_later:
! 1192: splx(s);
! 1193: if (advbase != 255 || advskew != 255)
! 1194: timeout_add(&sc->sc_ad_tmo, tvtohz(&tv));
! 1195: }
! 1196:
! 1197: /*
! 1198: * Broadcast a gratuitous ARP request containing
! 1199: * the virtual router MAC address for each IP address
! 1200: * associated with the virtual router.
! 1201: */
! 1202: void
! 1203: carp_send_arp(struct carp_softc *sc)
! 1204: {
! 1205: struct ifaddr *ifa;
! 1206: in_addr_t in;
! 1207: int s = splsoftnet();
! 1208:
! 1209: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 1210:
! 1211: if (ifa->ifa_addr->sa_family != AF_INET)
! 1212: continue;
! 1213:
! 1214: if (carp_addrcount((struct carp_if *)sc->sc_carpdev->if_carp,
! 1215: ifa, CARP_COUNT_LINK0))
! 1216: continue;
! 1217:
! 1218: in = ifatoia(ifa)->ia_addr.sin_addr.s_addr;
! 1219: arprequest(sc->sc_carpdev, &in, &in, sc->sc_ac.ac_enaddr);
! 1220: DELAY(1000); /* XXX */
! 1221: }
! 1222: splx(s);
! 1223: }
! 1224:
! 1225: #ifdef INET6
! 1226: void
! 1227: carp_send_na(struct carp_softc *sc)
! 1228: {
! 1229: struct ifaddr *ifa;
! 1230: struct in6_addr *in6;
! 1231: static struct in6_addr mcast = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
! 1232: int s = splsoftnet();
! 1233:
! 1234: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 1235:
! 1236: if (ifa->ifa_addr->sa_family != AF_INET6)
! 1237: continue;
! 1238:
! 1239: in6 = &ifatoia6(ifa)->ia_addr.sin6_addr;
! 1240: nd6_na_output(sc->sc_carpdev, &mcast, in6,
! 1241: ND_NA_FLAG_OVERRIDE, 1, NULL);
! 1242: DELAY(1000); /* XXX */
! 1243: }
! 1244: splx(s);
! 1245: }
! 1246: #endif /* INET6 */
! 1247:
! 1248: /*
! 1249: * Based on bridge_hash() in if_bridge.c
! 1250: */
! 1251: #define mix(a,b,c) \
! 1252: do { \
! 1253: a -= b; a -= c; a ^= (c >> 13); \
! 1254: b -= c; b -= a; b ^= (a << 8); \
! 1255: c -= a; c -= b; c ^= (b >> 13); \
! 1256: a -= b; a -= c; a ^= (c >> 12); \
! 1257: b -= c; b -= a; b ^= (a << 16); \
! 1258: c -= a; c -= b; c ^= (b >> 5); \
! 1259: a -= b; a -= c; a ^= (c >> 3); \
! 1260: b -= c; b -= a; b ^= (a << 10); \
! 1261: c -= a; c -= b; c ^= (b >> 15); \
! 1262: } while (0)
! 1263:
! 1264: u_int32_t
! 1265: carp_hash(struct carp_softc *sc, u_char *src)
! 1266: {
! 1267: u_int32_t a = 0x9e3779b9, b = sc->sc_hashkey[0], c = sc->sc_hashkey[1];
! 1268:
! 1269: c += sc->sc_key[3] << 24;
! 1270: c += sc->sc_key[2] << 16;
! 1271: c += sc->sc_key[1] << 8;
! 1272: c += sc->sc_key[0];
! 1273: b += src[5] << 8;
! 1274: b += src[4];
! 1275: a += src[3] << 24;
! 1276: a += src[2] << 16;
! 1277: a += src[1] << 8;
! 1278: a += src[0];
! 1279:
! 1280: mix(a, b, c);
! 1281: return (c);
! 1282: }
! 1283:
! 1284: int
! 1285: carp_addrcount(struct carp_if *cif, struct ifaddr *ifa0, int type)
! 1286: {
! 1287: struct carp_softc *vh;
! 1288: struct ifaddr *ifa;
! 1289: int count = 0;
! 1290:
! 1291: TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) {
! 1292: switch (type) {
! 1293: case CARP_COUNT_RUNNING:
! 1294: if ((vh->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
! 1295: (IFF_UP|IFF_RUNNING))
! 1296: continue;
! 1297: break;
! 1298: case CARP_COUNT_MASTER:
! 1299: if (vh->sc_state != MASTER)
! 1300: continue;
! 1301: break;
! 1302: case CARP_COUNT_LINK0:
! 1303: if (!(vh->sc_if.if_flags & IFF_LINK0) ||
! 1304: (vh->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
! 1305: (IFF_UP|IFF_RUNNING))
! 1306: continue;
! 1307: break;
! 1308: }
! 1309: TAILQ_FOREACH(ifa, &vh->sc_if.if_addrlist, ifa_list) {
! 1310: if (ifa->ifa_addr->sa_family == AF_INET &&
! 1311: ifa0->ifa_addr->sa_family == AF_INET &&
! 1312: ifatoia(ifa0)->ia_addr.sin_addr.s_addr ==
! 1313: ifatoia(ifa)->ia_addr.sin_addr.s_addr)
! 1314: count++;
! 1315: #ifdef INET6
! 1316: if (ifa->ifa_addr->sa_family == AF_INET6 &&
! 1317: ifa0->ifa_addr->sa_family == AF_INET6 &&
! 1318: IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa0), IFA_IN6(ifa)))
! 1319: count++;
! 1320: #endif
! 1321: }
! 1322: }
! 1323: return (count);
! 1324: }
! 1325:
! 1326: void
! 1327: carp_update_lsmask(struct carp_softc *sc)
! 1328: {
! 1329: struct carp_softc *curvh, *vh, *sc0 = NULL;
! 1330: struct carp_if *cif;
! 1331: struct ifaddr *ifa, *ifa0 = NULL;
! 1332: int cur, last, count, found;
! 1333:
! 1334: if (!sc->sc_carpdev)
! 1335: return;
! 1336: cif = (struct carp_if *)sc->sc_carpdev->if_carp;
! 1337:
! 1338: /*
! 1339: * Take the first IPv4 address from the LINK0 carp interface
! 1340: * to determine the load sharing group.
! 1341: * Fallback on the first IPv6 address.
! 1342: */
! 1343: TAILQ_FOREACH(sc0, &cif->vhif_vrs, sc_list)
! 1344: if (sc0->sc_if.if_flags & IFF_LINK0)
! 1345: break;
! 1346: if (sc0 == NULL)
! 1347: return;
! 1348:
! 1349: TAILQ_FOREACH(ifa0, &sc0->sc_if.if_addrlist, ifa_list)
! 1350: if (ifa0->ifa_addr->sa_family == AF_INET)
! 1351: break;
! 1352: #ifdef INET6
! 1353: if (ifa0 == NULL)
! 1354: TAILQ_FOREACH(ifa0, &sc0->sc_if.if_addrlist, ifa_list)
! 1355: if (ifa0->ifa_addr->sa_family == AF_INET6 &&
! 1356: !IN6_IS_ADDR_LINKLOCAL(IFA_IN6(ifa0)))
! 1357: break;
! 1358: #endif
! 1359: if (ifa0 == NULL)
! 1360: return;
! 1361: /*
! 1362: * Calculate the load sharing mask w/ all carp interfaces
! 1363: * that share the first address of the LINK0 interface.
! 1364: * Sort by virtual host ID.
! 1365: */
! 1366: sc0->sc_lsmask = 0;
! 1367: cur = 0;
! 1368: curvh = NULL;
! 1369: count = 0;
! 1370: do {
! 1371: found = 0;
! 1372: last = cur;
! 1373: cur = 255;
! 1374: TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) {
! 1375: if ((vh->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
! 1376: (IFF_UP|IFF_RUNNING))
! 1377: continue;
! 1378: TAILQ_FOREACH(ifa, &vh->sc_if.if_addrlist, ifa_list) {
! 1379: if (ifa->ifa_addr->sa_family == AF_INET &&
! 1380: ifa0->ifa_addr->sa_family == AF_INET &&
! 1381: ifatoia(ifa0)->ia_addr.sin_addr.s_addr ==
! 1382: ifatoia(ifa)->ia_addr.sin_addr.s_addr)
! 1383: break;
! 1384: #ifdef INET6
! 1385: if (ifa->ifa_addr->sa_family == AF_INET6 &&
! 1386: ifa0->ifa_addr->sa_family == AF_INET6 &&
! 1387: IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa0), IFA_IN6(ifa)))
! 1388: break;
! 1389: #endif
! 1390: }
! 1391: if (ifa && vh->sc_vhid > last && vh->sc_vhid < cur) {
! 1392: cur = vh->sc_vhid;
! 1393: curvh = vh;
! 1394: found++;
! 1395: }
! 1396: }
! 1397: if (found) {
! 1398: if (curvh->sc_state == MASTER &&
! 1399: count < sizeof(sc0->sc_lsmask) * 8)
! 1400: sc0->sc_lsmask |= 1 << count;
! 1401: count++;
! 1402: }
! 1403: } while (found);
! 1404:
! 1405: sc0->sc_lscount = count;
! 1406: if (count == 0)
! 1407: return;
! 1408:
! 1409: CARP_LOG(sc, ("carp_update_lsmask: %x", sc0->sc_lsmask))
! 1410: }
! 1411:
! 1412: int
! 1413: carp_iamatch(struct in_ifaddr *ia, u_char *src,
! 1414: u_int32_t *count, u_int32_t index)
! 1415: {
! 1416: struct carp_softc *sc = ia->ia_ifp->if_softc;
! 1417:
! 1418: /*
! 1419: * If the asked address is found on a LINK0 interface
! 1420: * don't answer the arp reply unless we are MASTER on it.
! 1421: */
! 1422: if (!(sc->sc_if.if_flags & IFF_LINK0) && sc->sc_carpdev &&
! 1423: carp_addrcount((struct carp_if *)sc->sc_carpdev->if_carp,
! 1424: (struct ifaddr *)ia, CARP_COUNT_LINK0))
! 1425: return (0);
! 1426:
! 1427: if (carp_opts[CARPCTL_ARPBALANCE]) {
! 1428: /*
! 1429: * We use the source ip to decide which virtual host should
! 1430: * handle the request. If we're master of that virtual host,
! 1431: * then we respond, otherwise, just drop the arp packet on
! 1432: * the floor.
! 1433: */
! 1434:
! 1435: /* Count the eligible carp interfaces with this address */
! 1436: if (*count == 0)
! 1437: *count = carp_addrcount(
! 1438: (struct carp_if *)ia->ia_ifp->if_carpdev->if_carp,
! 1439: (struct ifaddr *)ia, CARP_COUNT_RUNNING);
! 1440:
! 1441: /* This should never happen, but... */
! 1442: if (*count == 0)
! 1443: return (0);
! 1444:
! 1445: if (carp_hash(sc, src) % *count == index - 1 &&
! 1446: sc->sc_state == MASTER) {
! 1447: return (1);
! 1448: }
! 1449: } else {
! 1450: if (sc->sc_state == MASTER)
! 1451: return (1);
! 1452: }
! 1453:
! 1454: return (0);
! 1455: }
! 1456:
! 1457: #ifdef INET6
! 1458: int
! 1459: carp_iamatch6(struct ifnet *ifp, struct ifaddr *ifa)
! 1460: {
! 1461: struct carp_softc *sc = ifp->if_softc;
! 1462:
! 1463: /*
! 1464: * If the asked address is found on a LINK0 interface
! 1465: * don't answer the arp request unless we are MASTER on it.
! 1466: */
! 1467: if (!(sc->sc_if.if_flags & IFF_LINK0) && sc->sc_carpdev &&
! 1468: carp_addrcount((struct carp_if *)sc->sc_carpdev->if_carp,
! 1469: ifa, CARP_COUNT_LINK0))
! 1470: return (0);
! 1471:
! 1472: if (sc->sc_state == MASTER)
! 1473: return (1);
! 1474:
! 1475: return (0);
! 1476: }
! 1477: #endif /* INET6 */
! 1478:
! 1479: struct ifnet *
! 1480: carp_ourether(void *v, struct ether_header *eh, u_char iftype, int src)
! 1481: {
! 1482: struct carp_if *cif = (struct carp_if *)v;
! 1483: struct carp_softc *vh;
! 1484: u_int8_t *ena;
! 1485:
! 1486: if (src)
! 1487: ena = (u_int8_t *)&eh->ether_shost;
! 1488: else
! 1489: ena = (u_int8_t *)&eh->ether_dhost;
! 1490:
! 1491: TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) {
! 1492: if ((vh->sc_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
! 1493: (IFF_UP|IFF_RUNNING))
! 1494: continue;
! 1495: if ((vh->sc_state == MASTER || vh->sc_if.if_flags & IFF_LINK0)
! 1496: && !bcmp(ena, vh->sc_ac.ac_enaddr, ETHER_ADDR_LEN))
! 1497: return (&vh->sc_if);
! 1498: }
! 1499: return (NULL);
! 1500: }
! 1501:
! 1502: int
! 1503: carp_input(struct mbuf *m, u_int8_t *shost, u_int8_t *dhost, u_int16_t etype)
! 1504: {
! 1505: struct ether_header eh;
! 1506: struct carp_if *cif = (struct carp_if *)m->m_pkthdr.rcvif->if_carp;
! 1507: struct ifnet *ifp;
! 1508:
! 1509: bcopy(shost, &eh.ether_shost, sizeof(eh.ether_shost));
! 1510: bcopy(dhost, &eh.ether_dhost, sizeof(eh.ether_dhost));
! 1511: eh.ether_type = etype;
! 1512:
! 1513: if ((ifp = carp_ourether(cif, &eh, m->m_pkthdr.rcvif->if_type, 0)))
! 1514: ;
! 1515: else if (m->m_flags & (M_BCAST|M_MCAST)) {
! 1516: struct carp_softc *vh;
! 1517: struct mbuf *m0;
! 1518:
! 1519: /*
! 1520: * XXX Should really check the list of multicast addresses
! 1521: * for each CARP interface _before_ copying.
! 1522: */
! 1523: TAILQ_FOREACH(vh, &cif->vhif_vrs, sc_list) {
! 1524: m0 = m_copym2(m, 0, M_COPYALL, M_DONTWAIT);
! 1525: if (m0 == NULL)
! 1526: continue;
! 1527: m0->m_pkthdr.rcvif = &vh->sc_if;
! 1528: ether_input(&vh->sc_if, &eh, m0);
! 1529: }
! 1530: return (1);
! 1531: }
! 1532:
! 1533: if (ifp == NULL)
! 1534: return (1);
! 1535:
! 1536: m->m_pkthdr.rcvif = ifp;
! 1537:
! 1538: #if NBPFILTER > 0
! 1539: if (ifp->if_bpf)
! 1540: bpf_mtap_hdr(ifp->if_bpf, (char *)&eh, ETHER_HDR_LEN, m,
! 1541: BPF_DIRECTION_IN);
! 1542: #endif
! 1543: ifp->if_ipackets++;
! 1544: ether_input(ifp, &eh, m);
! 1545:
! 1546: return (0);
! 1547: }
! 1548:
! 1549: int
! 1550: carp_lsdrop(struct mbuf *m, sa_family_t af, u_int32_t *src, u_int32_t *dst)
! 1551: {
! 1552: struct carp_softc *sc = m->m_pkthdr.rcvif->if_softc;
! 1553: int match;
! 1554: u_int32_t fold;
! 1555:
! 1556: /*
! 1557: * Never drop carp advertisements.
! 1558: * XXX Bad idea to pass all broadcast / multicast traffic?
! 1559: */
! 1560: if (m->m_flags & (M_BCAST|M_MCAST))
! 1561: return (0);
! 1562:
! 1563: fold = src[0] ^ dst[0];
! 1564: #ifdef INET6
! 1565: if (af == AF_INET6) {
! 1566: int i;
! 1567: for (i = 1; i < 4; i++)
! 1568: fold ^= src[i] ^ dst[i];
! 1569: }
! 1570: #endif
! 1571: if (sc->sc_lscount == 0) /* just to be safe */
! 1572: return (1);
! 1573: match = (1 << (ntohl(fold) % sc->sc_lscount)) & sc->sc_lsmask;
! 1574:
! 1575: return (!match);
! 1576: }
! 1577:
! 1578: void
! 1579: carp_master_down(void *v)
! 1580: {
! 1581: struct carp_softc *sc = v;
! 1582:
! 1583: switch (sc->sc_state) {
! 1584: case INIT:
! 1585: printf("%s: master_down event in INIT state\n",
! 1586: sc->sc_if.if_xname);
! 1587: break;
! 1588: case MASTER:
! 1589: break;
! 1590: case BACKUP:
! 1591: carp_set_state(sc, MASTER);
! 1592: carp_send_ad(sc);
! 1593: carp_send_arp(sc);
! 1594: /* Schedule a delayed ARP request to deal w/ some L3 switches */
! 1595: sc->sc_delayed_arp = 2;
! 1596: #ifdef INET6
! 1597: carp_send_na(sc);
! 1598: #endif /* INET6 */
! 1599: carp_setrun(sc, 0);
! 1600: carp_setroute(sc, RTM_ADD);
! 1601: break;
! 1602: }
! 1603: }
! 1604:
! 1605: /*
! 1606: * When in backup state, af indicates whether to reset the master down timer
! 1607: * for v4 or v6. If it's set to zero, reset the ones which are already pending.
! 1608: */
! 1609: void
! 1610: carp_setrun(struct carp_softc *sc, sa_family_t af)
! 1611: {
! 1612: struct timeval tv;
! 1613:
! 1614: if (sc->sc_carpdev == NULL) {
! 1615: sc->sc_if.if_flags &= ~IFF_RUNNING;
! 1616: carp_set_state(sc, INIT);
! 1617: return;
! 1618: }
! 1619:
! 1620: if (sc->sc_if.if_flags & IFF_UP && sc->sc_vhid > 0 &&
! 1621: (sc->sc_naddrs || sc->sc_naddrs6) && !sc->sc_suppress) {
! 1622: sc->sc_if.if_flags |= IFF_RUNNING;
! 1623: } else {
! 1624: sc->sc_if.if_flags &= ~IFF_RUNNING;
! 1625: carp_setroute(sc, RTM_DELETE);
! 1626: return;
! 1627: }
! 1628:
! 1629: switch (sc->sc_state) {
! 1630: case INIT:
! 1631: carp_set_state(sc, BACKUP);
! 1632: carp_setroute(sc, RTM_DELETE);
! 1633: carp_setrun(sc, 0);
! 1634: break;
! 1635: case BACKUP:
! 1636: timeout_del(&sc->sc_ad_tmo);
! 1637: tv.tv_sec = 3 * sc->sc_advbase;
! 1638: tv.tv_usec = sc->sc_advskew * 1000000 / 256;
! 1639: sc->sc_delayed_arp = -1;
! 1640: switch (af) {
! 1641: #ifdef INET
! 1642: case AF_INET:
! 1643: timeout_add(&sc->sc_md_tmo, tvtohz(&tv));
! 1644: break;
! 1645: #endif /* INET */
! 1646: #ifdef INET6
! 1647: case AF_INET6:
! 1648: timeout_add(&sc->sc_md6_tmo, tvtohz(&tv));
! 1649: break;
! 1650: #endif /* INET6 */
! 1651: default:
! 1652: if (sc->sc_naddrs)
! 1653: timeout_add(&sc->sc_md_tmo, tvtohz(&tv));
! 1654: if (sc->sc_naddrs6)
! 1655: timeout_add(&sc->sc_md6_tmo, tvtohz(&tv));
! 1656: break;
! 1657: }
! 1658: break;
! 1659: case MASTER:
! 1660: tv.tv_sec = sc->sc_advbase;
! 1661: tv.tv_usec = sc->sc_advskew * 1000000 / 256;
! 1662: timeout_add(&sc->sc_ad_tmo, tvtohz(&tv));
! 1663: break;
! 1664: }
! 1665: }
! 1666:
! 1667: void
! 1668: carp_multicast_cleanup(struct carp_softc *sc)
! 1669: {
! 1670: struct ip_moptions *imo = &sc->sc_imo;
! 1671: #ifdef INET6
! 1672: struct ip6_moptions *im6o = &sc->sc_im6o;
! 1673: #endif
! 1674: u_int16_t n = imo->imo_num_memberships;
! 1675:
! 1676: /* Clean up our own multicast memberships */
! 1677: while (n-- > 0) {
! 1678: if (imo->imo_membership[n] != NULL) {
! 1679: in_delmulti(imo->imo_membership[n]);
! 1680: imo->imo_membership[n] = NULL;
! 1681: }
! 1682: }
! 1683: imo->imo_num_memberships = 0;
! 1684: imo->imo_multicast_ifp = NULL;
! 1685:
! 1686: #ifdef INET6
! 1687: while (!LIST_EMPTY(&im6o->im6o_memberships)) {
! 1688: struct in6_multi_mship *imm =
! 1689: LIST_FIRST(&im6o->im6o_memberships);
! 1690:
! 1691: LIST_REMOVE(imm, i6mm_chain);
! 1692: in6_leavegroup(imm);
! 1693: }
! 1694: im6o->im6o_multicast_ifp = NULL;
! 1695: #endif
! 1696:
! 1697: /* And any other multicast memberships */
! 1698: carp_ether_purgemulti(sc);
! 1699: }
! 1700:
! 1701: int
! 1702: carp_set_ifp(struct carp_softc *sc, struct ifnet *ifp)
! 1703: {
! 1704: struct carp_if *cif, *ncif = NULL;
! 1705: struct carp_softc *vr, *after = NULL;
! 1706: int myself = 0, error = 0;
! 1707: int s;
! 1708:
! 1709: if (ifp == sc->sc_carpdev)
! 1710: return (0);
! 1711:
! 1712: if (ifp != NULL) {
! 1713: if ((ifp->if_flags & IFF_MULTICAST) == 0)
! 1714: return (EADDRNOTAVAIL);
! 1715:
! 1716: if (ifp->if_type == IFT_CARP)
! 1717: return (EINVAL);
! 1718:
! 1719: if (ifp->if_carp == NULL) {
! 1720: MALLOC(ncif, struct carp_if *, sizeof(*cif),
! 1721: M_IFADDR, M_NOWAIT);
! 1722: if (ncif == NULL)
! 1723: return (ENOBUFS);
! 1724: if ((error = ifpromisc(ifp, 1))) {
! 1725: FREE(ncif, M_IFADDR);
! 1726: return (error);
! 1727: }
! 1728:
! 1729: ncif->vhif_ifp = ifp;
! 1730: TAILQ_INIT(&ncif->vhif_vrs);
! 1731: } else {
! 1732: cif = (struct carp_if *)ifp->if_carp;
! 1733: TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list)
! 1734: if (vr != sc && vr->sc_vhid == sc->sc_vhid)
! 1735: return (EINVAL);
! 1736: }
! 1737:
! 1738: /* detach from old interface */
! 1739: if (sc->sc_carpdev != NULL)
! 1740: carpdetach(sc);
! 1741:
! 1742: /* join multicast groups */
! 1743: if (sc->sc_naddrs < 0 &&
! 1744: (error = carp_join_multicast(sc)) != 0) {
! 1745: if (ncif != NULL)
! 1746: FREE(ncif, M_IFADDR);
! 1747: return (error);
! 1748: }
! 1749:
! 1750: #ifdef INET6
! 1751: if (sc->sc_naddrs6 < 0 &&
! 1752: (error = carp_join_multicast6(sc)) != 0) {
! 1753: if (ncif != NULL)
! 1754: FREE(ncif, M_IFADDR);
! 1755: carp_multicast_cleanup(sc);
! 1756: return (error);
! 1757: }
! 1758: #endif
! 1759:
! 1760: /* attach carp interface to physical interface */
! 1761: if (ncif != NULL)
! 1762: ifp->if_carp = (caddr_t)ncif;
! 1763: sc->sc_carpdev = ifp;
! 1764: cif = (struct carp_if *)ifp->if_carp;
! 1765: TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list) {
! 1766: if (vr == sc)
! 1767: myself = 1;
! 1768: if (vr->sc_vhid < sc->sc_vhid)
! 1769: after = vr;
! 1770: }
! 1771:
! 1772: if (!myself) {
! 1773: /* We're trying to keep things in order */
! 1774: if (after == NULL) {
! 1775: TAILQ_INSERT_TAIL(&cif->vhif_vrs, sc, sc_list);
! 1776: } else {
! 1777: TAILQ_INSERT_AFTER(&cif->vhif_vrs, after,
! 1778: sc, sc_list);
! 1779: }
! 1780: cif->vhif_nvrs++;
! 1781: }
! 1782: if (sc->sc_naddrs || sc->sc_naddrs6)
! 1783: sc->sc_if.if_flags |= IFF_UP;
! 1784: carp_set_enaddr(sc);
! 1785: s = splnet();
! 1786: sc->lh_cookie = hook_establish(ifp->if_linkstatehooks, 1,
! 1787: carp_carpdev_state, ifp);
! 1788: carp_carpdev_state(ifp);
! 1789: splx(s);
! 1790: } else {
! 1791: carpdetach(sc);
! 1792: sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
! 1793: }
! 1794: return (0);
! 1795: }
! 1796:
! 1797: void
! 1798: carp_set_enaddr(struct carp_softc *sc)
! 1799: {
! 1800: if (sc->sc_vhid != -1 && sc->sc_carpdev) {
! 1801: /* XXX detach ipv6 link-local address? */
! 1802: if (sc->sc_if.if_flags & IFF_LINK2)
! 1803: sc->sc_carplladdr[0] = 1;
! 1804: else
! 1805: sc->sc_carplladdr[0] = 0;
! 1806: sc->sc_carplladdr[1] = 0;
! 1807: sc->sc_carplladdr[2] = 0x5e;
! 1808: sc->sc_carplladdr[3] = 0;
! 1809: sc->sc_carplladdr[4] = 1;
! 1810: sc->sc_carplladdr[5] = sc->sc_vhid;
! 1811: } else
! 1812: bzero(sc->sc_carplladdr, ETHER_ADDR_LEN);
! 1813:
! 1814: /*
! 1815: * Use the carp lladdr if the running one isn't manually set.
! 1816: * Only compare static parts of the lladdr.
! 1817: */
! 1818: if ((bcmp(sc->sc_ac.ac_enaddr + 1, sc->sc_carplladdr + 1,
! 1819: ETHER_ADDR_LEN - 2) == 0) ||
! 1820: (!sc->sc_ac.ac_enaddr[0] && !sc->sc_ac.ac_enaddr[1] &&
! 1821: !sc->sc_ac.ac_enaddr[2] && !sc->sc_ac.ac_enaddr[3] &&
! 1822: !sc->sc_ac.ac_enaddr[4] && !sc->sc_ac.ac_enaddr[5]))
! 1823: bcopy(sc->sc_carplladdr, sc->sc_ac.ac_enaddr, ETHER_ADDR_LEN);
! 1824:
! 1825: /* Make sure the enaddr has changed before further twiddling. */
! 1826: if (bcmp(sc->sc_ac.ac_enaddr, sc->sc_curlladdr, ETHER_ADDR_LEN) != 0) {
! 1827: bcopy(sc->sc_ac.ac_enaddr, LLADDR(sc->sc_if.if_sadl),
! 1828: ETHER_ADDR_LEN);
! 1829: bcopy(sc->sc_ac.ac_enaddr, sc->sc_curlladdr, ETHER_ADDR_LEN);
! 1830: #ifdef INET6
! 1831: /*
! 1832: * (re)attach a link-local address which matches
! 1833: * our new MAC address.
! 1834: */
! 1835: in6_ifattach_linklocal(&sc->sc_if, NULL);
! 1836: #endif
! 1837: carp_set_state(sc, INIT);
! 1838: carp_setrun(sc, 0);
! 1839: }
! 1840: }
! 1841:
! 1842: void
! 1843: carp_addr_updated(void *v)
! 1844: {
! 1845: struct carp_softc *sc = (struct carp_softc *) v;
! 1846: struct ifaddr *ifa;
! 1847: int new_naddrs = 0, new_naddrs6 = 0;
! 1848:
! 1849: TAILQ_FOREACH(ifa, &sc->sc_if.if_addrlist, ifa_list) {
! 1850: if (ifa->ifa_addr->sa_family == AF_INET)
! 1851: new_naddrs++;
! 1852: else if (ifa->ifa_addr->sa_family == AF_INET6 &&
! 1853: !IN6_IS_ADDR_LINKLOCAL(&ifatoia6(ifa)->ia_addr.sin6_addr))
! 1854: new_naddrs6++;
! 1855: }
! 1856:
! 1857: /* Handle a callback after SIOCDIFADDR */
! 1858: if (new_naddrs < sc->sc_naddrs || new_naddrs6 < sc->sc_naddrs6) {
! 1859: struct in_addr mc_addr;
! 1860: struct in_multi *inm;
! 1861:
! 1862: sc->sc_naddrs = new_naddrs;
! 1863: sc->sc_naddrs6 = new_naddrs6;
! 1864:
! 1865: /* Re-establish multicast membership removed by in_control */
! 1866: mc_addr.s_addr = INADDR_CARP_GROUP;
! 1867: IN_LOOKUP_MULTI(mc_addr, &sc->sc_if, inm);
! 1868: if (inm == NULL) {
! 1869: bzero(&sc->sc_imo, sizeof(sc->sc_imo));
! 1870:
! 1871: if (sc->sc_carpdev != NULL && sc->sc_naddrs > 0)
! 1872: carp_join_multicast(sc);
! 1873: }
! 1874:
! 1875: if (sc->sc_naddrs == 0 && sc->sc_naddrs6 == 0) {
! 1876: sc->sc_if.if_flags &= ~IFF_UP;
! 1877: carp_set_state(sc, INIT);
! 1878: } else
! 1879: carp_hmac_prepare(sc);
! 1880: }
! 1881:
! 1882: carp_setrun(sc, 0);
! 1883: }
! 1884:
! 1885: int
! 1886: carp_set_addr(struct carp_softc *sc, struct sockaddr_in *sin)
! 1887: {
! 1888: struct ifnet *ifp = sc->sc_carpdev;
! 1889: struct in_ifaddr *ia, *ia_if;
! 1890: int error = 0;
! 1891:
! 1892: if (sin->sin_addr.s_addr == 0) {
! 1893: if (!(sc->sc_if.if_flags & IFF_UP))
! 1894: carp_set_state(sc, INIT);
! 1895: if (sc->sc_naddrs)
! 1896: sc->sc_if.if_flags |= IFF_UP;
! 1897: carp_setrun(sc, 0);
! 1898: return (0);
! 1899: }
! 1900:
! 1901: /* we have to do this by hand to ensure we don't match on ourselves */
! 1902: ia_if = NULL;
! 1903: for (ia = TAILQ_FIRST(&in_ifaddr); ia;
! 1904: ia = TAILQ_NEXT(ia, ia_list)) {
! 1905:
! 1906: /* and, yeah, we need a multicast-capable iface too */
! 1907: if (ia->ia_ifp != &sc->sc_if &&
! 1908: ia->ia_ifp->if_type != IFT_CARP &&
! 1909: (ia->ia_ifp->if_flags & IFF_MULTICAST) &&
! 1910: (sin->sin_addr.s_addr & ia->ia_subnetmask) ==
! 1911: ia->ia_subnet) {
! 1912: if (!ia_if)
! 1913: ia_if = ia;
! 1914: }
! 1915: }
! 1916:
! 1917: if (ia_if) {
! 1918: ia = ia_if;
! 1919: if (ifp) {
! 1920: if (ifp != ia->ia_ifp)
! 1921: return (EADDRNOTAVAIL);
! 1922: } else {
! 1923: ifp = ia->ia_ifp;
! 1924: }
! 1925: }
! 1926:
! 1927: if ((error = carp_set_ifp(sc, ifp)))
! 1928: return (error);
! 1929:
! 1930: if (sc->sc_carpdev == NULL)
! 1931: return (EADDRNOTAVAIL);
! 1932:
! 1933: if (sc->sc_naddrs == 0 && (error = carp_join_multicast(sc)) != 0)
! 1934: return (error);
! 1935:
! 1936: sc->sc_naddrs++;
! 1937: if (sc->sc_carpdev != NULL)
! 1938: sc->sc_if.if_flags |= IFF_UP;
! 1939:
! 1940: carp_set_state(sc, INIT);
! 1941:
! 1942: /*
! 1943: * Hook if_addrhooks so that we get a callback after in_ifinit has run,
! 1944: * to correct any inappropriate routes that it inserted.
! 1945: */
! 1946: if (sc->ah_cookie == NULL)
! 1947: sc->ah_cookie = hook_establish(sc->sc_if.if_addrhooks, 0,
! 1948: carp_addr_updated, sc);
! 1949:
! 1950: return (0);
! 1951: }
! 1952:
! 1953: int
! 1954: carp_join_multicast(struct carp_softc *sc)
! 1955: {
! 1956: struct ip_moptions *imo = &sc->sc_imo, tmpimo;
! 1957: struct in_addr addr;
! 1958:
! 1959: bzero(&tmpimo, sizeof(tmpimo));
! 1960: addr.s_addr = INADDR_CARP_GROUP;
! 1961: if ((tmpimo.imo_membership[0] =
! 1962: in_addmulti(&addr, &sc->sc_if)) == NULL) {
! 1963: return (ENOBUFS);
! 1964: }
! 1965:
! 1966: imo->imo_membership[0] = tmpimo.imo_membership[0];
! 1967: imo->imo_num_memberships = 1;
! 1968: imo->imo_multicast_ifp = &sc->sc_if;
! 1969: imo->imo_multicast_ttl = CARP_DFLTTL;
! 1970: imo->imo_multicast_loop = 0;
! 1971: return (0);
! 1972: }
! 1973:
! 1974:
! 1975: #ifdef INET6
! 1976: int
! 1977: carp_set_addr6(struct carp_softc *sc, struct sockaddr_in6 *sin6)
! 1978: {
! 1979: struct ifnet *ifp = sc->sc_carpdev;
! 1980: struct in6_ifaddr *ia, *ia_if;
! 1981: int error = 0;
! 1982:
! 1983: if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
! 1984: if (!(sc->sc_if.if_flags & IFF_UP))
! 1985: carp_set_state(sc, INIT);
! 1986: if (sc->sc_naddrs6)
! 1987: sc->sc_if.if_flags |= IFF_UP;
! 1988: carp_setrun(sc, 0);
! 1989: return (0);
! 1990: }
! 1991:
! 1992: /* we have to do this by hand to ensure we don't match on ourselves */
! 1993: ia_if = NULL;
! 1994: for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
! 1995: int i;
! 1996:
! 1997: for (i = 0; i < 4; i++) {
! 1998: if ((sin6->sin6_addr.s6_addr32[i] &
! 1999: ia->ia_prefixmask.sin6_addr.s6_addr32[i]) !=
! 2000: (ia->ia_addr.sin6_addr.s6_addr32[i] &
! 2001: ia->ia_prefixmask.sin6_addr.s6_addr32[i]))
! 2002: break;
! 2003: }
! 2004: /* and, yeah, we need a multicast-capable iface too */
! 2005: if (ia->ia_ifp != &sc->sc_if &&
! 2006: ia->ia_ifp->if_type != IFT_CARP &&
! 2007: (ia->ia_ifp->if_flags & IFF_MULTICAST) &&
! 2008: (i == 4)) {
! 2009: if (!ia_if)
! 2010: ia_if = ia;
! 2011: }
! 2012: }
! 2013:
! 2014: if (ia_if) {
! 2015: ia = ia_if;
! 2016: if (sc->sc_carpdev) {
! 2017: if (sc->sc_carpdev != ia->ia_ifp)
! 2018: return (EADDRNOTAVAIL);
! 2019: } else {
! 2020: ifp = ia->ia_ifp;
! 2021: }
! 2022: }
! 2023:
! 2024: if ((error = carp_set_ifp(sc, ifp)))
! 2025: return (error);
! 2026:
! 2027: if (sc->sc_carpdev == NULL)
! 2028: return (EADDRNOTAVAIL);
! 2029:
! 2030: if (sc->sc_naddrs6 == 0 && (error = carp_join_multicast6(sc)) != 0)
! 2031: return (error);
! 2032:
! 2033: if (!IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
! 2034: sc->sc_naddrs6++;
! 2035: if (sc->sc_carpdev != NULL && sc->sc_naddrs6)
! 2036: sc->sc_if.if_flags |= IFF_UP;
! 2037: carp_set_state(sc, INIT);
! 2038: carp_setrun(sc, 0);
! 2039:
! 2040: return (0);
! 2041: }
! 2042:
! 2043: int
! 2044: carp_join_multicast6(struct carp_softc *sc)
! 2045: {
! 2046: struct in6_multi_mship *imm, *imm2;
! 2047: struct ip6_moptions *im6o = &sc->sc_im6o;
! 2048: struct sockaddr_in6 addr6;
! 2049: int error;
! 2050:
! 2051: /* Join IPv6 CARP multicast group */
! 2052: bzero(&addr6, sizeof(addr6));
! 2053: addr6.sin6_family = AF_INET6;
! 2054: addr6.sin6_len = sizeof(addr6);
! 2055: addr6.sin6_addr.s6_addr16[0] = htons(0xff02);
! 2056: addr6.sin6_addr.s6_addr16[1] = htons(sc->sc_if.if_index);
! 2057: addr6.sin6_addr.s6_addr8[15] = 0x12;
! 2058: if ((imm = in6_joingroup(&sc->sc_if,
! 2059: &addr6.sin6_addr, &error)) == NULL) {
! 2060: return (error);
! 2061: }
! 2062: /* join solicited multicast address */
! 2063: bzero(&addr6.sin6_addr, sizeof(addr6.sin6_addr));
! 2064: addr6.sin6_addr.s6_addr16[0] = htons(0xff02);
! 2065: addr6.sin6_addr.s6_addr16[1] = htons(sc->sc_if.if_index);
! 2066: addr6.sin6_addr.s6_addr32[1] = 0;
! 2067: addr6.sin6_addr.s6_addr32[2] = htonl(1);
! 2068: addr6.sin6_addr.s6_addr32[3] = 0;
! 2069: addr6.sin6_addr.s6_addr8[12] = 0xff;
! 2070: if ((imm2 = in6_joingroup(&sc->sc_if,
! 2071: &addr6.sin6_addr, &error)) == NULL) {
! 2072: in6_leavegroup(imm);
! 2073: return (error);
! 2074: }
! 2075:
! 2076: /* apply v6 multicast membership */
! 2077: im6o->im6o_multicast_ifp = &sc->sc_if;
! 2078: if (imm)
! 2079: LIST_INSERT_HEAD(&im6o->im6o_memberships, imm,
! 2080: i6mm_chain);
! 2081: if (imm2)
! 2082: LIST_INSERT_HEAD(&im6o->im6o_memberships, imm2,
! 2083: i6mm_chain);
! 2084:
! 2085: return (0);
! 2086: }
! 2087:
! 2088: #endif /* INET6 */
! 2089:
! 2090: int
! 2091: carp_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr)
! 2092: {
! 2093: struct proc *p = curproc; /* XXX */
! 2094: struct carp_softc *sc = ifp->if_softc, *vr;
! 2095: struct carpreq carpr;
! 2096: struct ifaddr *ifa = (struct ifaddr *)addr;
! 2097: struct ifreq *ifr = (struct ifreq *)addr;
! 2098: struct ifnet *cdev = NULL;
! 2099: int error = 0;
! 2100:
! 2101: switch (cmd) {
! 2102: case SIOCSIFADDR:
! 2103: switch (ifa->ifa_addr->sa_family) {
! 2104: #ifdef INET
! 2105: case AF_INET:
! 2106: sc->sc_if.if_flags |= IFF_UP;
! 2107: bcopy(ifa->ifa_addr, ifa->ifa_dstaddr,
! 2108: sizeof(struct sockaddr));
! 2109: error = carp_set_addr(sc, satosin(ifa->ifa_addr));
! 2110: break;
! 2111: #endif /* INET */
! 2112: #ifdef INET6
! 2113: case AF_INET6:
! 2114: sc->sc_if.if_flags |= IFF_UP;
! 2115: error = carp_set_addr6(sc, satosin6(ifa->ifa_addr));
! 2116: break;
! 2117: #endif /* INET6 */
! 2118: default:
! 2119: error = EAFNOSUPPORT;
! 2120: break;
! 2121: }
! 2122: break;
! 2123:
! 2124: case SIOCSIFFLAGS:
! 2125: if (sc->sc_state != INIT && !(ifr->ifr_flags & IFF_UP)) {
! 2126: timeout_del(&sc->sc_ad_tmo);
! 2127: timeout_del(&sc->sc_md_tmo);
! 2128: timeout_del(&sc->sc_md6_tmo);
! 2129: if (sc->sc_state == MASTER) {
! 2130: /* we need the interface up to bow out */
! 2131: sc->sc_if.if_flags |= IFF_UP;
! 2132: sc->sc_bow_out = 1;
! 2133: carp_send_ad(sc);
! 2134: }
! 2135: sc->sc_if.if_flags &= ~IFF_UP;
! 2136: carp_set_state(sc, INIT);
! 2137: carp_setrun(sc, 0);
! 2138: } else if (sc->sc_state == INIT && (ifr->ifr_flags & IFF_UP)) {
! 2139: sc->sc_if.if_flags |= IFF_UP;
! 2140: carp_setrun(sc, 0);
! 2141: }
! 2142: carp_set_enaddr(sc); /* for changes on LINK2 */
! 2143: if (ifr->ifr_flags & IFF_LINK0)
! 2144: carp_update_lsmask(sc);
! 2145: break;
! 2146:
! 2147: case SIOCSVH:
! 2148: if ((error = suser(p, p->p_acflag)) != 0)
! 2149: break;
! 2150: if ((error = copyin(ifr->ifr_data, &carpr, sizeof carpr)))
! 2151: break;
! 2152: error = 1;
! 2153: if (carpr.carpr_carpdev[0] != '\0' &&
! 2154: (cdev = ifunit(carpr.carpr_carpdev)) == NULL)
! 2155: return (EINVAL);
! 2156: if ((error = carp_set_ifp(sc, cdev)))
! 2157: return (error);
! 2158: if (sc->sc_state != INIT && carpr.carpr_state != sc->sc_state) {
! 2159: switch (carpr.carpr_state) {
! 2160: case BACKUP:
! 2161: timeout_del(&sc->sc_ad_tmo);
! 2162: carp_set_state(sc, BACKUP);
! 2163: carp_setrun(sc, 0);
! 2164: carp_setroute(sc, RTM_DELETE);
! 2165: break;
! 2166: case MASTER:
! 2167: carp_master_down(sc);
! 2168: break;
! 2169: default:
! 2170: break;
! 2171: }
! 2172: }
! 2173: if (carpr.carpr_vhid > 0 && carpr.carpr_vhid != sc->sc_vhid) {
! 2174: if (carpr.carpr_vhid > 255) {
! 2175: error = EINVAL;
! 2176: break;
! 2177: }
! 2178: if (sc->sc_carpdev) {
! 2179: struct carp_if *cif;
! 2180: cif = (struct carp_if *)sc->sc_carpdev->if_carp;
! 2181: TAILQ_FOREACH(vr, &cif->vhif_vrs, sc_list)
! 2182: if (vr != sc &&
! 2183: vr->sc_vhid == carpr.carpr_vhid)
! 2184: return (EINVAL);
! 2185: }
! 2186: if (carpr.carpr_vhid != sc->sc_vhid) {
! 2187: sc->sc_vhid = carpr.carpr_vhid;
! 2188: carp_set_enaddr(sc);
! 2189: carp_set_state(sc, INIT);
! 2190: }
! 2191: error--;
! 2192: }
! 2193: if (carpr.carpr_advbase > 0 || carpr.carpr_advskew > 0) {
! 2194: if (carpr.carpr_advskew >= 255) {
! 2195: error = EINVAL;
! 2196: break;
! 2197: }
! 2198: if (carpr.carpr_advbase > 255) {
! 2199: error = EINVAL;
! 2200: break;
! 2201: }
! 2202: sc->sc_advbase = carpr.carpr_advbase;
! 2203: sc->sc_advskew = carpr.carpr_advskew;
! 2204: error--;
! 2205: }
! 2206: bcopy(carpr.carpr_key, sc->sc_key, sizeof(sc->sc_key));
! 2207: if (error > 0)
! 2208: error = EINVAL;
! 2209: else {
! 2210: error = 0;
! 2211: carp_setrun(sc, 0);
! 2212: }
! 2213: break;
! 2214:
! 2215: case SIOCGVH:
! 2216: bzero(&carpr, sizeof(carpr));
! 2217: if (sc->sc_carpdev != NULL)
! 2218: strlcpy(carpr.carpr_carpdev, sc->sc_carpdev->if_xname,
! 2219: IFNAMSIZ);
! 2220: carpr.carpr_state = sc->sc_state;
! 2221: carpr.carpr_vhid = sc->sc_vhid;
! 2222: carpr.carpr_advbase = sc->sc_advbase;
! 2223: carpr.carpr_advskew = sc->sc_advskew;
! 2224: if (suser(p, p->p_acflag) == 0)
! 2225: bcopy(sc->sc_key, carpr.carpr_key,
! 2226: sizeof(carpr.carpr_key));
! 2227: error = copyout(&carpr, ifr->ifr_data, sizeof(carpr));
! 2228: break;
! 2229:
! 2230: case SIOCADDMULTI:
! 2231: error = carp_ether_addmulti(sc, ifr);
! 2232: break;
! 2233:
! 2234: case SIOCDELMULTI:
! 2235: error = carp_ether_delmulti(sc, ifr);
! 2236: break;
! 2237: case SIOCAIFGROUP:
! 2238: case SIOCDIFGROUP:
! 2239: if (sc->sc_suppress)
! 2240: carp_ifgroup_ioctl(ifp, cmd, addr);
! 2241: break;
! 2242: case SIOCSIFGATTR:
! 2243: carp_ifgattr_ioctl(ifp, cmd, addr);
! 2244: break;
! 2245: default:
! 2246: error = EINVAL;
! 2247: }
! 2248:
! 2249: if (bcmp(sc->sc_ac.ac_enaddr, sc->sc_curlladdr, ETHER_ADDR_LEN) != 0)
! 2250: carp_set_enaddr(sc);
! 2251: carp_hmac_prepare(sc);
! 2252: return (error);
! 2253: }
! 2254:
! 2255: void
! 2256: carp_ifgroup_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr)
! 2257: {
! 2258: struct ifgroupreq *ifgr = (struct ifgroupreq *)addr;
! 2259: struct ifg_list *ifgl;
! 2260:
! 2261: if (!strcmp(ifgr->ifgr_group, IFG_ALL))
! 2262: return;
! 2263: TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
! 2264: if (!strcmp(ifgl->ifgl_group->ifg_group, ifgr->ifgr_group)) {
! 2265: if (cmd == SIOCAIFGROUP)
! 2266: ifgl->ifgl_group->ifg_carp_demoted++;
! 2267: else if (cmd == SIOCDIFGROUP &&
! 2268: ifgl->ifgl_group->ifg_carp_demoted)
! 2269: ifgl->ifgl_group->ifg_carp_demoted--;
! 2270: }
! 2271: }
! 2272:
! 2273: void
! 2274: carp_ifgattr_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr)
! 2275: {
! 2276: struct ifgroupreq *ifgr = (struct ifgroupreq *)addr;
! 2277: struct carp_softc *sc = ifp->if_softc;
! 2278:
! 2279: if (ifgr->ifgr_attrib.ifg_carp_demoted > 0 && (sc->sc_if.if_flags &
! 2280: (IFF_UP|IFF_RUNNING)) == (IFF_UP|IFF_RUNNING) &&
! 2281: sc->sc_state == MASTER)
! 2282: carp_send_ad(sc);
! 2283: }
! 2284:
! 2285: /*
! 2286: * Start output on carp interface. This function should never be called.
! 2287: */
! 2288: void
! 2289: carp_start(struct ifnet *ifp)
! 2290: {
! 2291: #ifdef DEBUG
! 2292: printf("%s: start called\n", ifp->if_xname);
! 2293: #endif
! 2294: }
! 2295:
! 2296: int
! 2297: carp_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *sa,
! 2298: struct rtentry *rt)
! 2299: {
! 2300: struct carp_softc *sc = ((struct carp_softc *)ifp->if_softc);
! 2301:
! 2302: if (sc->sc_carpdev != NULL && sc->sc_state == MASTER)
! 2303: return (sc->sc_carpdev->if_output(ifp, m, sa, rt));
! 2304: else {
! 2305: m_freem(m);
! 2306: return (ENETUNREACH);
! 2307: }
! 2308: }
! 2309:
! 2310: void
! 2311: carp_set_state(struct carp_softc *sc, int state)
! 2312: {
! 2313: if (sc->sc_state == state)
! 2314: return;
! 2315:
! 2316: sc->sc_state = state;
! 2317: carp_update_lsmask(sc);
! 2318:
! 2319: switch (state) {
! 2320: case BACKUP:
! 2321: sc->sc_if.if_link_state = LINK_STATE_DOWN;
! 2322: break;
! 2323: case MASTER:
! 2324: sc->sc_if.if_link_state = LINK_STATE_UP;
! 2325: break;
! 2326: default:
! 2327: sc->sc_if.if_link_state = LINK_STATE_UNKNOWN;
! 2328: break;
! 2329: }
! 2330: if_link_state_change(&sc->sc_if);
! 2331: }
! 2332:
! 2333: void
! 2334: carp_group_demote_adj(struct ifnet *ifp, int adj)
! 2335: {
! 2336: struct ifg_list *ifgl;
! 2337: int *dm;
! 2338: struct carp_softc *nil = NULL;
! 2339:
! 2340: TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
! 2341: if (!strcmp(ifgl->ifgl_group->ifg_group, IFG_ALL))
! 2342: continue;
! 2343: dm = &ifgl->ifgl_group->ifg_carp_demoted;
! 2344:
! 2345: if (*dm + adj >= 0)
! 2346: *dm += adj;
! 2347: else
! 2348: *dm = 0;
! 2349:
! 2350: if (adj > 0 && *dm == 1)
! 2351: carp_send_ad_all();
! 2352: CARP_LOG(nil, ("%s demoted group %s to %d", ifp->if_xname,
! 2353: ifgl->ifgl_group->ifg_group, *dm));
! 2354: }
! 2355: }
! 2356:
! 2357: int
! 2358: carp_group_demote_count(struct carp_softc *sc)
! 2359: {
! 2360: struct ifg_list *ifgl;
! 2361: int count = 0;
! 2362:
! 2363: TAILQ_FOREACH(ifgl, &sc->sc_if.if_groups, ifgl_next)
! 2364: count += ifgl->ifgl_group->ifg_carp_demoted;
! 2365:
! 2366: return (count);
! 2367: }
! 2368:
! 2369: void
! 2370: carp_carpdev_state(void *v)
! 2371: {
! 2372: struct carp_if *cif;
! 2373: struct carp_softc *sc;
! 2374: struct ifnet *ifp = v;
! 2375:
! 2376: if (ifp->if_type == IFT_CARP)
! 2377: return;
! 2378:
! 2379: cif = (struct carp_if *)ifp->if_carp;
! 2380:
! 2381: TAILQ_FOREACH(sc, &cif->vhif_vrs, sc_list) {
! 2382: int suppressed = sc->sc_suppress;
! 2383:
! 2384: if (sc->sc_carpdev->if_link_state == LINK_STATE_DOWN ||
! 2385: !(sc->sc_carpdev->if_flags & IFF_UP)) {
! 2386: sc->sc_if.if_flags &= ~IFF_RUNNING;
! 2387: timeout_del(&sc->sc_ad_tmo);
! 2388: timeout_del(&sc->sc_md_tmo);
! 2389: timeout_del(&sc->sc_md6_tmo);
! 2390: carp_set_state(sc, INIT);
! 2391: sc->sc_suppress = 1;
! 2392: carp_setrun(sc, 0);
! 2393: if (!suppressed)
! 2394: carp_group_demote_adj(&sc->sc_if, 1);
! 2395: } else {
! 2396: carp_set_state(sc, INIT);
! 2397: sc->sc_suppress = 0;
! 2398: carp_setrun(sc, 0);
! 2399: if (suppressed)
! 2400: carp_group_demote_adj(&sc->sc_if, -1);
! 2401: }
! 2402: }
! 2403: }
! 2404:
! 2405: int
! 2406: carp_ether_addmulti(struct carp_softc *sc, struct ifreq *ifr)
! 2407: {
! 2408: struct ifnet *ifp;
! 2409: struct carp_mc_entry *mc;
! 2410: u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
! 2411: int error;
! 2412:
! 2413: ifp = sc->sc_carpdev;
! 2414: if (ifp == NULL)
! 2415: return (EINVAL);
! 2416:
! 2417: error = ether_addmulti(ifr, (struct arpcom *)&sc->sc_ac);
! 2418: if (error != ENETRESET)
! 2419: return (error);
! 2420:
! 2421: /*
! 2422: * This is new multicast address. We have to tell parent
! 2423: * about it. Also, remember this multicast address so that
! 2424: * we can delete them on unconfigure.
! 2425: */
! 2426: MALLOC(mc, struct carp_mc_entry *, sizeof(struct carp_mc_entry),
! 2427: M_DEVBUF, M_NOWAIT);
! 2428: if (mc == NULL) {
! 2429: error = ENOMEM;
! 2430: goto alloc_failed;
! 2431: }
! 2432:
! 2433: /*
! 2434: * As ether_addmulti() returns ENETRESET, following two
! 2435: * statement shouldn't fail.
! 2436: */
! 2437: (void)ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
! 2438: ETHER_LOOKUP_MULTI(addrlo, addrhi, &sc->sc_ac, mc->mc_enm);
! 2439: memcpy(&mc->mc_addr, &ifr->ifr_addr, ifr->ifr_addr.sa_len);
! 2440: LIST_INSERT_HEAD(&sc->carp_mc_listhead, mc, mc_entries);
! 2441:
! 2442: error = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, (caddr_t)ifr);
! 2443: if (error != 0)
! 2444: goto ioctl_failed;
! 2445:
! 2446: return (error);
! 2447:
! 2448: ioctl_failed:
! 2449: LIST_REMOVE(mc, mc_entries);
! 2450: FREE(mc, M_DEVBUF);
! 2451: alloc_failed:
! 2452: (void)ether_delmulti(ifr, (struct arpcom *)&sc->sc_ac);
! 2453:
! 2454: return (error);
! 2455: }
! 2456:
! 2457: int
! 2458: carp_ether_delmulti(struct carp_softc *sc, struct ifreq *ifr)
! 2459: {
! 2460: struct ifnet *ifp;
! 2461: struct ether_multi *enm;
! 2462: struct carp_mc_entry *mc;
! 2463: u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
! 2464: int error;
! 2465:
! 2466: ifp = sc->sc_carpdev;
! 2467: if (ifp == NULL)
! 2468: return (EINVAL);
! 2469:
! 2470: /*
! 2471: * Find a key to lookup carp_mc_entry. We have to do this
! 2472: * before calling ether_delmulti for obvious reason.
! 2473: */
! 2474: if ((error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi)) != 0)
! 2475: return (error);
! 2476: ETHER_LOOKUP_MULTI(addrlo, addrhi, &sc->sc_ac, enm);
! 2477: if (enm == NULL)
! 2478: return (EINVAL);
! 2479:
! 2480: LIST_FOREACH(mc, &sc->carp_mc_listhead, mc_entries)
! 2481: if (mc->mc_enm == enm)
! 2482: break;
! 2483:
! 2484: /* We won't delete entries we didn't add */
! 2485: if (mc == NULL)
! 2486: return (EINVAL);
! 2487:
! 2488: error = ether_delmulti(ifr, (struct arpcom *)&sc->sc_ac);
! 2489: if (error != ENETRESET)
! 2490: return (error);
! 2491:
! 2492: /* We no longer use this multicast address. Tell parent so. */
! 2493: error = (*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
! 2494: if (error == 0) {
! 2495: /* And forget about this address. */
! 2496: LIST_REMOVE(mc, mc_entries);
! 2497: FREE(mc, M_DEVBUF);
! 2498: } else
! 2499: (void)ether_addmulti(ifr, (struct arpcom *)&sc->sc_ac);
! 2500: return (error);
! 2501: }
! 2502:
! 2503: /*
! 2504: * Delete any multicast address we have asked to add from parent
! 2505: * interface. Called when the carp is being unconfigured.
! 2506: */
! 2507: void
! 2508: carp_ether_purgemulti(struct carp_softc *sc)
! 2509: {
! 2510: struct ifnet *ifp = sc->sc_carpdev; /* Parent. */
! 2511: struct carp_mc_entry *mc;
! 2512: union {
! 2513: struct ifreq ifreq;
! 2514: struct {
! 2515: char ifr_name[IFNAMSIZ];
! 2516: struct sockaddr_storage ifr_ss;
! 2517: } ifreq_storage;
! 2518: } u;
! 2519: struct ifreq *ifr = &u.ifreq;
! 2520:
! 2521: if (ifp == NULL)
! 2522: return;
! 2523:
! 2524: memcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ);
! 2525: while ((mc = LIST_FIRST(&sc->carp_mc_listhead)) != NULL) {
! 2526: memcpy(&ifr->ifr_addr, &mc->mc_addr, mc->mc_addr.ss_len);
! 2527: (void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
! 2528: LIST_REMOVE(mc, mc_entries);
! 2529: FREE(mc, M_DEVBUF);
! 2530: }
! 2531: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ip_carp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet