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