1 /*- 2 * Copyright (c) 2002 Michael Shalayeff. 3 * Copyright (c) 2003 Ryan McBride. 4 * Copyright (c) 2011 Gleb Smirnoff <glebius@FreeBSD.org> 5 * 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 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include "opt_bpf.h" 33 #include "opt_inet.h" 34 #include "opt_inet6.h" 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/bus.h> 39 #include <sys/jail.h> 40 #include <sys/kernel.h> 41 #include <sys/limits.h> 42 #include <sys/malloc.h> 43 #include <sys/mbuf.h> 44 #include <sys/module.h> 45 #include <sys/priv.h> 46 #include <sys/proc.h> 47 #include <sys/protosw.h> 48 #include <sys/socket.h> 49 #include <sys/sockio.h> 50 #include <sys/sysctl.h> 51 #include <sys/syslog.h> 52 #include <sys/taskqueue.h> 53 54 #include <net/ethernet.h> 55 #include <net/fddi.h> 56 #include <net/if.h> 57 #include <net/if_dl.h> 58 #include <net/if_llatbl.h> 59 #include <net/if_types.h> 60 #include <net/iso88025.h> 61 #include <net/route.h> 62 #include <net/vnet.h> 63 64 #if defined(INET) || defined(INET6) 65 #include <netinet/in.h> 66 #include <netinet/in_var.h> 67 #include <netinet/ip_carp.h> 68 #include <netinet/ip.h> 69 #include <machine/in_cksum.h> 70 #endif 71 #ifdef INET 72 #include <netinet/ip_var.h> 73 #include <netinet/if_ether.h> 74 #endif 75 76 #ifdef INET6 77 #include <netinet/icmp6.h> 78 #include <netinet/ip6.h> 79 #include <netinet6/ip6protosw.h> 80 #include <netinet6/in6_var.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 88 static MALLOC_DEFINE(M_CARP, "CARP", "CARP addresses"); 89 90 struct carp_softc { 91 struct ifnet *sc_carpdev; /* Pointer to parent ifnet. */ 92 struct ifaddr **sc_ifas; /* Our ifaddrs. */ 93 struct sockaddr_dl sc_addr; /* Our link level address. */ 94 struct callout sc_ad_tmo; /* Advertising timeout. */ 95 #ifdef INET 96 struct callout sc_md_tmo; /* Master down timeout. */ 97 #endif 98 #ifdef INET6 99 struct callout sc_md6_tmo; /* XXX: Master down timeout. */ 100 #endif 101 struct mtx sc_mtx; 102 103 int sc_vhid; 104 int sc_advskew; 105 int sc_advbase; 106 107 int sc_naddrs; 108 int sc_naddrs6; 109 int sc_ifasiz; 110 enum { INIT = 0, BACKUP, MASTER } sc_state; 111 int sc_suppress; 112 int sc_sendad_errors; 113 #define CARP_SENDAD_MAX_ERRORS 3 114 int sc_sendad_success; 115 #define CARP_SENDAD_MIN_SUCCESS 3 116 117 int sc_init_counter; 118 uint64_t sc_counter; 119 120 /* authentication */ 121 #define CARP_HMAC_PAD 64 122 unsigned char sc_key[CARP_KEY_LEN]; 123 unsigned char sc_pad[CARP_HMAC_PAD]; 124 SHA1_CTX sc_sha1; 125 126 TAILQ_ENTRY(carp_softc) sc_list; /* On the carp_if list. */ 127 LIST_ENTRY(carp_softc) sc_next; /* On the global list. */ 128 }; 129 130 struct carp_if { 131 #ifdef INET 132 int cif_naddrs; 133 #endif 134 #ifdef INET6 135 int cif_naddrs6; 136 #endif 137 TAILQ_HEAD(, carp_softc) cif_vrs; 138 #ifdef INET 139 struct ip_moptions cif_imo; 140 #endif 141 #ifdef INET6 142 struct ip6_moptions cif_im6o; 143 #endif 144 struct ifnet *cif_ifp; 145 struct mtx cif_mtx; 146 }; 147 148 #define CARP_INET 0 149 #define CARP_INET6 1 150 static int proto_reg[] = {-1, -1}; 151 152 /* 153 * Brief design of carp(4). 154 * 155 * Any carp-capable ifnet may have a list of carp softcs hanging off 156 * its ifp->if_carp pointer. Each softc represents one unique virtual 157 * host id, or vhid. The softc has a back pointer to the ifnet. All 158 * softcs are joined in a global list, which has quite limited use. 159 * 160 * Any interface address that takes part in CARP negotiation has a 161 * pointer to the softc of its vhid, ifa->ifa_carp. That could be either 162 * AF_INET or AF_INET6 address. 163 * 164 * Although, one can get the softc's backpointer to ifnet and traverse 165 * through its ifp->if_addrhead queue to find all interface addresses 166 * involved in CARP, we keep a growable array of ifaddr pointers. This 167 * allows us to avoid grabbing the IF_ADDR_LOCK() in many traversals that 168 * do calls into the network stack, thus avoiding LORs. 169 * 170 * Locking: 171 * 172 * Each softc has a lock sc_mtx. It is used to synchronise carp_input_c(), 173 * callout-driven events and ioctl()s. 174 * 175 * To traverse the list of softcs on an ifnet we use CIF_LOCK(), to 176 * traverse the global list we use the mutex carp_mtx. 177 * 178 * Known issues with locking: 179 * 180 * - There is no protection for races between two ioctl() requests, 181 * neither SIOCSVH, nor SIOCAIFADDR & SIOCAIFADDR_IN6. I think that all 182 * interface ioctl()s should be serialized right in net/if.c. 183 * - Sending ad, we put the pointer to the softc in an mtag, and no reference 184 * counting is done on the softc. 185 * - On module unload we may race (?) with packet processing thread 186 * dereferencing our function pointers. 187 */ 188 189 static int carp_allow = 1; /* Accept incoming CARP packets. */ 190 static int carp_preempt = 0; /* Preempt slower nodes. */ 191 static int carp_log = 1; /* Log level. */ 192 static int carp_demotion = 0; /* Global advskew demotion. */ 193 static int carp_senderr_adj = CARP_MAXSKEW; /* Send error demotion factor */ 194 static int carp_ifdown_adj = CARP_MAXSKEW; /* Iface down demotion factor */ 195 196 SYSCTL_NODE(_net_inet, IPPROTO_CARP, carp, CTLFLAG_RW, 0, "CARP"); 197 SYSCTL_INT(_net_inet_carp, OID_AUTO, allow, CTLFLAG_RW, &carp_allow, 0, 198 "Accept incoming CARP packets"); 199 SYSCTL_INT(_net_inet_carp, OID_AUTO, preempt, CTLFLAG_RW, &carp_preempt, 0, 200 "High-priority backup preemption mode"); 201 SYSCTL_INT(_net_inet_carp, OID_AUTO, log, CTLFLAG_RW, &carp_log, 0, 202 "CARP log level"); 203 SYSCTL_INT(_net_inet_carp, OID_AUTO, demotion, CTLFLAG_RW, &carp_demotion, 0, 204 "Demotion factor (skew of advskew)"); 205 SYSCTL_INT(_net_inet_carp, OID_AUTO, senderr_demotion_factor, CTLFLAG_RW, 206 &carp_senderr_adj, 0, "Send error demotion factor adjustment"); 207 SYSCTL_INT(_net_inet_carp, OID_AUTO, ifdown_demotion_factor, CTLFLAG_RW, 208 &carp_ifdown_adj, 0, "Interface down demotion factor adjustment"); 209 210 static struct carpstats carpstats; 211 SYSCTL_STRUCT(_net_inet_carp, OID_AUTO, stats, CTLFLAG_RW, &carpstats, 212 carpstats, "CARP statistics (struct carpstats, netinet/ip_carp.h)"); 213 214 #define CARP_LOCK_INIT(sc) mtx_init(&(sc)->sc_mtx, "carp_softc", \ 215 NULL, MTX_DEF) 216 #define CARP_LOCK_DESTROY(sc) mtx_destroy(&(sc)->sc_mtx) 217 #define CARP_LOCK_ASSERT(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) 218 #define CARP_LOCK(sc) mtx_lock(&(sc)->sc_mtx) 219 #define CARP_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) 220 #define CIF_LOCK_INIT(cif) mtx_init(&(cif)->cif_mtx, "carp_if", \ 221 NULL, MTX_DEF) 222 #define CIF_LOCK_DESTROY(cif) mtx_destroy(&(cif)->cif_mtx) 223 #define CIF_LOCK_ASSERT(cif) mtx_assert(&(cif)->cif_mtx, MA_OWNED) 224 #define CIF_LOCK(cif) mtx_lock(&(cif)->cif_mtx) 225 #define CIF_UNLOCK(cif) mtx_unlock(&(cif)->cif_mtx) 226 #define CIF_FREE(cif) do { \ 227 CIF_LOCK_ASSERT(cif); \ 228 if (TAILQ_EMPTY(&(cif)->cif_vrs)) \ 229 carp_free_if(cif); \ 230 else \ 231 CIF_UNLOCK(cif); \ 232 } while (0) 233 234 #define CARP_LOG(...) do { \ 235 if (carp_log > 0) \ 236 log(LOG_INFO, "carp: " __VA_ARGS__); \ 237 } while (0) 238 239 #define CARP_DEBUG(...) do { \ 240 if (carp_log > 1) \ 241 log(LOG_DEBUG, __VA_ARGS__); \ 242 } while (0) 243 244 #define IFNET_FOREACH_IFA(ifp, ifa) \ 245 IF_ADDR_LOCK_ASSERT(ifp); \ 246 TAILQ_FOREACH((ifa), &(ifp)->if_addrhead, ifa_link) \ 247 if ((ifa)->ifa_carp != NULL) 248 249 #define CARP_FOREACH_IFA(sc, ifa) \ 250 CARP_LOCK_ASSERT(sc); \ 251 for (int _i = 0; \ 252 _i < (sc)->sc_naddrs + (sc)->sc_naddrs6 && \ 253 ((ifa) = sc->sc_ifas[_i]) != NULL; \ 254 ++_i) 255 256 #define IFNET_FOREACH_CARP(ifp, sc) \ 257 CIF_LOCK_ASSERT(ifp->if_carp); \ 258 TAILQ_FOREACH((sc), &(ifp)->if_carp->cif_vrs, sc_list) 259 260 #define DEMOTE_ADVSKEW(sc) \ 261 (((sc)->sc_advskew + carp_demotion > CARP_MAXSKEW) ? \ 262 CARP_MAXSKEW : ((sc)->sc_advskew + carp_demotion)) 263 264 static void carp_input_c(struct mbuf *, struct carp_header *, sa_family_t); 265 static struct carp_softc 266 *carp_alloc(struct ifnet *); 267 static void carp_detach_locked(struct ifaddr *); 268 static void carp_destroy(struct carp_softc *); 269 static struct carp_if 270 *carp_alloc_if(struct ifnet *); 271 static void carp_free_if(struct carp_if *); 272 static void carp_set_state(struct carp_softc *, int); 273 static void carp_sc_state(struct carp_softc *); 274 static void carp_setrun(struct carp_softc *, sa_family_t); 275 static void carp_master_down(void *); 276 static void carp_master_down_locked(struct carp_softc *); 277 static void carp_send_ad(void *); 278 static void carp_send_ad_locked(struct carp_softc *); 279 static void carp_addroute(struct carp_softc *); 280 static void carp_ifa_addroute(struct ifaddr *); 281 static void carp_delroute(struct carp_softc *); 282 static void carp_ifa_delroute(struct ifaddr *); 283 static void carp_send_ad_all(void *, int); 284 static void carp_demote_adj(int, char *); 285 286 static LIST_HEAD(, carp_softc) carp_list; 287 static struct mtx carp_mtx; 288 static struct task carp_sendall_task = 289 TASK_INITIALIZER(0, carp_send_ad_all, NULL); 290 291 static __inline uint16_t 292 carp_cksum(struct mbuf *m, int len) 293 { 294 return (in_cksum(m, len)); 295 } 296 297 static void 298 carp_hmac_prepare(struct carp_softc *sc) 299 { 300 uint8_t version = CARP_VERSION, type = CARP_ADVERTISEMENT; 301 uint8_t vhid = sc->sc_vhid & 0xff; 302 struct ifaddr *ifa; 303 int i, found; 304 #ifdef INET 305 struct in_addr last, cur, in; 306 #endif 307 #ifdef INET6 308 struct in6_addr last6, cur6, in6; 309 #endif 310 311 CARP_LOCK_ASSERT(sc); 312 313 /* Compute ipad from key. */ 314 bzero(sc->sc_pad, sizeof(sc->sc_pad)); 315 bcopy(sc->sc_key, sc->sc_pad, sizeof(sc->sc_key)); 316 for (i = 0; i < sizeof(sc->sc_pad); i++) 317 sc->sc_pad[i] ^= 0x36; 318 319 /* Precompute first part of inner hash. */ 320 SHA1Init(&sc->sc_sha1); 321 SHA1Update(&sc->sc_sha1, sc->sc_pad, sizeof(sc->sc_pad)); 322 SHA1Update(&sc->sc_sha1, (void *)&version, sizeof(version)); 323 SHA1Update(&sc->sc_sha1, (void *)&type, sizeof(type)); 324 SHA1Update(&sc->sc_sha1, (void *)&vhid, sizeof(vhid)); 325 #ifdef INET 326 cur.s_addr = 0; 327 do { 328 found = 0; 329 last = cur; 330 cur.s_addr = 0xffffffff; 331 CARP_FOREACH_IFA(sc, ifa) { 332 in.s_addr = ifatoia(ifa)->ia_addr.sin_addr.s_addr; 333 if (ifa->ifa_addr->sa_family == AF_INET && 334 ntohl(in.s_addr) > ntohl(last.s_addr) && 335 ntohl(in.s_addr) < ntohl(cur.s_addr)) { 336 cur.s_addr = in.s_addr; 337 found++; 338 } 339 } 340 if (found) 341 SHA1Update(&sc->sc_sha1, (void *)&cur, sizeof(cur)); 342 } while (found); 343 #endif /* INET */ 344 #ifdef INET6 345 memset(&cur6, 0, sizeof(cur6)); 346 do { 347 found = 0; 348 last6 = cur6; 349 memset(&cur6, 0xff, sizeof(cur6)); 350 CARP_FOREACH_IFA(sc, ifa) { 351 in6 = ifatoia6(ifa)->ia_addr.sin6_addr; 352 if (IN6_IS_SCOPE_EMBED(&in6)) 353 in6.s6_addr16[1] = 0; 354 if (ifa->ifa_addr->sa_family == AF_INET6 && 355 memcmp(&in6, &last6, sizeof(in6)) > 0 && 356 memcmp(&in6, &cur6, sizeof(in6)) < 0) { 357 cur6 = in6; 358 found++; 359 } 360 } 361 if (found) 362 SHA1Update(&sc->sc_sha1, (void *)&cur6, sizeof(cur6)); 363 } while (found); 364 #endif /* INET6 */ 365 366 /* convert ipad to opad */ 367 for (i = 0; i < sizeof(sc->sc_pad); i++) 368 sc->sc_pad[i] ^= 0x36 ^ 0x5c; 369 } 370 371 static void 372 carp_hmac_generate(struct carp_softc *sc, uint32_t counter[2], 373 unsigned char md[20]) 374 { 375 SHA1_CTX sha1ctx; 376 377 CARP_LOCK_ASSERT(sc); 378 379 /* fetch first half of inner hash */ 380 bcopy(&sc->sc_sha1, &sha1ctx, sizeof(sha1ctx)); 381 382 SHA1Update(&sha1ctx, (void *)counter, sizeof(sc->sc_counter)); 383 SHA1Final(md, &sha1ctx); 384 385 /* outer hash */ 386 SHA1Init(&sha1ctx); 387 SHA1Update(&sha1ctx, sc->sc_pad, sizeof(sc->sc_pad)); 388 SHA1Update(&sha1ctx, md, 20); 389 SHA1Final(md, &sha1ctx); 390 } 391 392 static int 393 carp_hmac_verify(struct carp_softc *sc, uint32_t counter[2], 394 unsigned char md[20]) 395 { 396 unsigned char md2[20]; 397 398 CARP_LOCK_ASSERT(sc); 399 400 carp_hmac_generate(sc, counter, md2); 401 402 return (bcmp(md, md2, sizeof(md2))); 403 } 404 405 /* 406 * process input packet. 407 * we have rearranged checks order compared to the rfc, 408 * but it seems more efficient this way or not possible otherwise. 409 */ 410 #ifdef INET 411 void 412 carp_input(struct mbuf *m, int hlen) 413 { 414 struct ip *ip = mtod(m, struct ip *); 415 struct carp_header *ch; 416 int iplen, len; 417 418 CARPSTATS_INC(carps_ipackets); 419 420 if (!carp_allow) { 421 m_freem(m); 422 return; 423 } 424 425 /* verify that the IP TTL is 255. */ 426 if (ip->ip_ttl != CARP_DFLTTL) { 427 CARPSTATS_INC(carps_badttl); 428 CARP_DEBUG("%s: received ttl %d != 255 on %s\n", __func__, 429 ip->ip_ttl, 430 m->m_pkthdr.rcvif->if_xname); 431 m_freem(m); 432 return; 433 } 434 435 iplen = ip->ip_hl << 2; 436 437 if (m->m_pkthdr.len < iplen + sizeof(*ch)) { 438 CARPSTATS_INC(carps_badlen); 439 CARP_DEBUG("%s: received len %zd < sizeof(struct carp_header) " 440 "on %s\n", __func__, m->m_len - sizeof(struct ip), 441 m->m_pkthdr.rcvif->if_xname); 442 m_freem(m); 443 return; 444 } 445 446 if (iplen + sizeof(*ch) < m->m_len) { 447 if ((m = m_pullup(m, iplen + sizeof(*ch))) == NULL) { 448 CARPSTATS_INC(carps_hdrops); 449 CARP_DEBUG("%s: pullup failed\n", __func__); 450 return; 451 } 452 ip = mtod(m, struct ip *); 453 } 454 ch = (struct carp_header *)((char *)ip + iplen); 455 456 /* 457 * verify that the received packet length is 458 * equal to the CARP header 459 */ 460 len = iplen + sizeof(*ch); 461 if (len > m->m_pkthdr.len) { 462 CARPSTATS_INC(carps_badlen); 463 CARP_DEBUG("%s: packet too short %d on %s\n", __func__, 464 m->m_pkthdr.len, 465 m->m_pkthdr.rcvif->if_xname); 466 m_freem(m); 467 return; 468 } 469 470 if ((m = m_pullup(m, len)) == NULL) { 471 CARPSTATS_INC(carps_hdrops); 472 return; 473 } 474 ip = mtod(m, struct ip *); 475 ch = (struct carp_header *)((char *)ip + iplen); 476 477 /* verify the CARP checksum */ 478 m->m_data += iplen; 479 if (carp_cksum(m, len - iplen)) { 480 CARPSTATS_INC(carps_badsum); 481 CARP_DEBUG("%s: checksum failed on %s\n", __func__, 482 m->m_pkthdr.rcvif->if_xname); 483 m_freem(m); 484 return; 485 } 486 m->m_data -= iplen; 487 488 carp_input_c(m, ch, AF_INET); 489 } 490 #endif 491 492 #ifdef INET6 493 int 494 carp6_input(struct mbuf **mp, int *offp, int proto) 495 { 496 struct mbuf *m = *mp; 497 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); 498 struct carp_header *ch; 499 u_int len; 500 501 CARPSTATS_INC(carps_ipackets6); 502 503 if (!carp_allow) { 504 m_freem(m); 505 return (IPPROTO_DONE); 506 } 507 508 /* check if received on a valid carp interface */ 509 if (m->m_pkthdr.rcvif->if_carp == NULL) { 510 CARPSTATS_INC(carps_badif); 511 CARP_DEBUG("%s: packet received on non-carp interface: %s\n", 512 __func__, m->m_pkthdr.rcvif->if_xname); 513 m_freem(m); 514 return (IPPROTO_DONE); 515 } 516 517 /* verify that the IP TTL is 255 */ 518 if (ip6->ip6_hlim != CARP_DFLTTL) { 519 CARPSTATS_INC(carps_badttl); 520 CARP_DEBUG("%s: received ttl %d != 255 on %s\n", __func__, 521 ip6->ip6_hlim, m->m_pkthdr.rcvif->if_xname); 522 m_freem(m); 523 return (IPPROTO_DONE); 524 } 525 526 /* verify that we have a complete carp packet */ 527 len = m->m_len; 528 IP6_EXTHDR_GET(ch, struct carp_header *, m, *offp, sizeof(*ch)); 529 if (ch == NULL) { 530 CARPSTATS_INC(carps_badlen); 531 CARP_DEBUG("%s: packet size %u too small\n", __func__, len); 532 return (IPPROTO_DONE); 533 } 534 535 536 /* verify the CARP checksum */ 537 m->m_data += *offp; 538 if (carp_cksum(m, sizeof(*ch))) { 539 CARPSTATS_INC(carps_badsum); 540 CARP_DEBUG("%s: checksum failed, on %s\n", __func__, 541 m->m_pkthdr.rcvif->if_xname); 542 m_freem(m); 543 return (IPPROTO_DONE); 544 } 545 m->m_data -= *offp; 546 547 carp_input_c(m, ch, AF_INET6); 548 return (IPPROTO_DONE); 549 } 550 #endif /* INET6 */ 551 552 static void 553 carp_input_c(struct mbuf *m, struct carp_header *ch, sa_family_t af) 554 { 555 struct ifnet *ifp = m->m_pkthdr.rcvif; 556 struct ifaddr *ifa; 557 struct carp_softc *sc; 558 uint64_t tmp_counter; 559 struct timeval sc_tv, ch_tv; 560 561 /* verify that the VHID is valid on the receiving interface */ 562 IF_ADDR_RLOCK(ifp); 563 IFNET_FOREACH_IFA(ifp, ifa) 564 if (ifa->ifa_addr->sa_family == af && 565 ifa->ifa_carp->sc_vhid == ch->carp_vhid) { 566 ifa_ref(ifa); 567 break; 568 } 569 IF_ADDR_RUNLOCK(ifp); 570 571 if (ifa == NULL) { 572 CARPSTATS_INC(carps_badvhid); 573 m_freem(m); 574 return; 575 } 576 577 /* verify the CARP version. */ 578 if (ch->carp_version != CARP_VERSION) { 579 CARPSTATS_INC(carps_badver); 580 CARP_DEBUG("%s: invalid version %d\n", ifp->if_xname, 581 ch->carp_version); 582 ifa_free(ifa); 583 m_freem(m); 584 return; 585 } 586 587 sc = ifa->ifa_carp; 588 CARP_LOCK(sc); 589 ifa_free(ifa); 590 591 if (carp_hmac_verify(sc, ch->carp_counter, ch->carp_md)) { 592 CARPSTATS_INC(carps_badauth); 593 CARP_DEBUG("%s: incorrect hash for VHID %u@%s\n", __func__, 594 sc->sc_vhid, ifp->if_xname); 595 goto out; 596 } 597 598 tmp_counter = ntohl(ch->carp_counter[0]); 599 tmp_counter = tmp_counter<<32; 600 tmp_counter += ntohl(ch->carp_counter[1]); 601 602 /* XXX Replay protection goes here */ 603 604 sc->sc_init_counter = 0; 605 sc->sc_counter = tmp_counter; 606 607 sc_tv.tv_sec = sc->sc_advbase; 608 sc_tv.tv_usec = DEMOTE_ADVSKEW(sc) * 1000000 / 256; 609 ch_tv.tv_sec = ch->carp_advbase; 610 ch_tv.tv_usec = ch->carp_advskew * 1000000 / 256; 611 612 switch (sc->sc_state) { 613 case INIT: 614 break; 615 case MASTER: 616 /* 617 * If we receive an advertisement from a master who's going to 618 * be more frequent than us, go into BACKUP state. 619 */ 620 if (timevalcmp(&sc_tv, &ch_tv, >) || 621 timevalcmp(&sc_tv, &ch_tv, ==)) { 622 callout_stop(&sc->sc_ad_tmo); 623 CARP_LOG("VHID %u@%s: MASTER -> BACKUP " 624 "(more frequent advertisement received)\n", 625 sc->sc_vhid, 626 sc->sc_carpdev->if_xname); 627 carp_set_state(sc, BACKUP); 628 carp_setrun(sc, 0); 629 carp_delroute(sc); 630 } 631 break; 632 case BACKUP: 633 /* 634 * If we're pre-empting masters who advertise slower than us, 635 * and this one claims to be slower, treat him as down. 636 */ 637 if (carp_preempt && timevalcmp(&sc_tv, &ch_tv, <)) { 638 CARP_LOG("VHID %u@%s: BACKUP -> MASTER " 639 "(preempting a slower master)\n", 640 sc->sc_vhid, 641 sc->sc_carpdev->if_xname); 642 carp_master_down_locked(sc); 643 break; 644 } 645 646 /* 647 * If the master is going to advertise at such a low frequency 648 * that he's guaranteed to time out, we'd might as well just 649 * treat him as timed out now. 650 */ 651 sc_tv.tv_sec = sc->sc_advbase * 3; 652 if (timevalcmp(&sc_tv, &ch_tv, <)) { 653 CARP_LOG("VHID %u@%s: BACKUP -> MASTER " 654 "(master timed out)\n", 655 sc->sc_vhid, 656 sc->sc_carpdev->if_xname); 657 carp_master_down_locked(sc); 658 break; 659 } 660 661 /* 662 * Otherwise, we reset the counter and wait for the next 663 * advertisement. 664 */ 665 carp_setrun(sc, af); 666 break; 667 } 668 669 out: 670 CARP_UNLOCK(sc); 671 m_freem(m); 672 } 673 674 static int 675 carp_prepare_ad(struct mbuf *m, struct carp_softc *sc, struct carp_header *ch) 676 { 677 struct m_tag *mtag; 678 679 if (sc->sc_init_counter) { 680 /* this could also be seconds since unix epoch */ 681 sc->sc_counter = arc4random(); 682 sc->sc_counter = sc->sc_counter << 32; 683 sc->sc_counter += arc4random(); 684 } else 685 sc->sc_counter++; 686 687 ch->carp_counter[0] = htonl((sc->sc_counter>>32)&0xffffffff); 688 ch->carp_counter[1] = htonl(sc->sc_counter&0xffffffff); 689 690 carp_hmac_generate(sc, ch->carp_counter, ch->carp_md); 691 692 /* Tag packet for carp_output */ 693 if ((mtag = m_tag_get(PACKET_TAG_CARP, sizeof(struct carp_softc *), 694 M_NOWAIT)) == NULL) { 695 m_freem(m); 696 CARPSTATS_INC(carps_onomem); 697 return (ENOMEM); 698 } 699 bcopy(&sc, mtag + 1, sizeof(sc)); 700 m_tag_prepend(m, mtag); 701 702 return (0); 703 } 704 705 /* 706 * To avoid LORs and possible recursions this function shouldn't 707 * be called directly, but scheduled via taskqueue. 708 */ 709 static void 710 carp_send_ad_all(void *ctx __unused, int pending __unused) 711 { 712 struct carp_softc *sc; 713 714 mtx_lock(&carp_mtx); 715 LIST_FOREACH(sc, &carp_list, sc_next) 716 if (sc->sc_state == MASTER) { 717 CARP_LOCK(sc); 718 CURVNET_SET(sc->sc_carpdev->if_vnet); 719 carp_send_ad_locked(sc); 720 CURVNET_RESTORE(); 721 CARP_UNLOCK(sc); 722 } 723 mtx_unlock(&carp_mtx); 724 } 725 726 /* Send a periodic advertisement, executed in callout context. */ 727 static void 728 carp_send_ad(void *v) 729 { 730 struct carp_softc *sc = v; 731 732 CARP_LOCK_ASSERT(sc); 733 CURVNET_SET(sc->sc_carpdev->if_vnet); 734 carp_send_ad_locked(sc); 735 CURVNET_RESTORE(); 736 CARP_UNLOCK(sc); 737 } 738 739 static void 740 carp_send_ad_locked(struct carp_softc *sc) 741 { 742 struct carp_header ch; 743 struct timeval tv; 744 struct sockaddr sa; 745 struct ifaddr *ifa; 746 struct carp_header *ch_ptr; 747 struct mbuf *m; 748 int len, advskew; 749 750 CARP_LOCK_ASSERT(sc); 751 752 advskew = DEMOTE_ADVSKEW(sc); 753 tv.tv_sec = sc->sc_advbase; 754 tv.tv_usec = advskew * 1000000 / 256; 755 756 ch.carp_version = CARP_VERSION; 757 ch.carp_type = CARP_ADVERTISEMENT; 758 ch.carp_vhid = sc->sc_vhid; 759 ch.carp_advbase = sc->sc_advbase; 760 ch.carp_advskew = advskew; 761 ch.carp_authlen = 7; /* XXX DEFINE */ 762 ch.carp_pad1 = 0; /* must be zero */ 763 ch.carp_cksum = 0; 764 765 /* XXXGL: OpenBSD picks first ifaddr with needed family. */ 766 767 #ifdef INET 768 if (sc->sc_naddrs) { 769 struct ip *ip; 770 771 MGETHDR(m, M_NOWAIT, MT_HEADER); 772 if (m == NULL) { 773 CARPSTATS_INC(carps_onomem); 774 /* XXX maybe less ? */ 775 callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 776 carp_send_ad, sc); 777 return; 778 } 779 len = sizeof(*ip) + sizeof(ch); 780 m->m_pkthdr.len = len; 781 m->m_pkthdr.rcvif = NULL; 782 m->m_len = len; 783 MH_ALIGN(m, m->m_len); 784 m->m_flags |= M_MCAST; 785 ip = mtod(m, struct ip *); 786 ip->ip_v = IPVERSION; 787 ip->ip_hl = sizeof(*ip) >> 2; 788 ip->ip_tos = IPTOS_LOWDELAY; 789 ip->ip_len = len; 790 ip->ip_id = ip_newid(); 791 ip->ip_off = IP_DF; 792 ip->ip_ttl = CARP_DFLTTL; 793 ip->ip_p = IPPROTO_CARP; 794 ip->ip_sum = 0; 795 796 bzero(&sa, sizeof(sa)); 797 sa.sa_family = AF_INET; 798 ifa = ifaof_ifpforaddr(&sa, sc->sc_carpdev); 799 if (ifa != NULL) { 800 ip->ip_src.s_addr = 801 ifatoia(ifa)->ia_addr.sin_addr.s_addr; 802 ifa_free(ifa); 803 } else 804 ip->ip_src.s_addr = 0; 805 ip->ip_dst.s_addr = htonl(INADDR_CARP_GROUP); 806 807 ch_ptr = (struct carp_header *)(&ip[1]); 808 bcopy(&ch, ch_ptr, sizeof(ch)); 809 if (carp_prepare_ad(m, sc, ch_ptr)) 810 return; 811 812 m->m_data += sizeof(*ip); 813 ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip)); 814 m->m_data -= sizeof(*ip); 815 816 CARPSTATS_INC(carps_opackets); 817 818 if (ip_output(m, NULL, NULL, IP_RAWOUTPUT, 819 &sc->sc_carpdev->if_carp->cif_imo, NULL)) { 820 if (sc->sc_sendad_errors < INT_MAX) 821 sc->sc_sendad_errors++; 822 if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS) 823 carp_demote_adj(carp_senderr_adj, "send error"); 824 sc->sc_sendad_success = 0; 825 } else { 826 if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) { 827 if (++sc->sc_sendad_success >= 828 CARP_SENDAD_MIN_SUCCESS) { 829 carp_demote_adj(-carp_senderr_adj, 830 "send ok"); 831 sc->sc_sendad_errors = 0; 832 } 833 } else 834 sc->sc_sendad_errors = 0; 835 } 836 } 837 #endif /* INET */ 838 #ifdef INET6 839 if (sc->sc_naddrs6) { 840 struct ip6_hdr *ip6; 841 842 MGETHDR(m, M_NOWAIT, MT_HEADER); 843 if (m == NULL) { 844 CARPSTATS_INC(carps_onomem); 845 /* XXX maybe less ? */ 846 callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 847 carp_send_ad, sc); 848 return; 849 } 850 len = sizeof(*ip6) + sizeof(ch); 851 m->m_pkthdr.len = len; 852 m->m_pkthdr.rcvif = NULL; 853 m->m_len = len; 854 MH_ALIGN(m, m->m_len); 855 m->m_flags |= M_MCAST; 856 ip6 = mtod(m, struct ip6_hdr *); 857 bzero(ip6, sizeof(*ip6)); 858 ip6->ip6_vfc |= IPV6_VERSION; 859 ip6->ip6_hlim = CARP_DFLTTL; 860 ip6->ip6_nxt = IPPROTO_CARP; 861 bzero(&sa, sizeof(sa)); 862 863 /* set the source address */ 864 sa.sa_family = AF_INET6; 865 ifa = ifaof_ifpforaddr(&sa, sc->sc_carpdev); 866 if (ifa != NULL) { 867 bcopy(IFA_IN6(ifa), &ip6->ip6_src, 868 sizeof(struct in6_addr)); 869 ifa_free(ifa); 870 } else 871 /* This should never happen with IPv6. */ 872 bzero(&ip6->ip6_src, sizeof(struct in6_addr)); 873 874 /* Set the multicast destination. */ 875 ip6->ip6_dst.s6_addr16[0] = htons(0xff02); 876 ip6->ip6_dst.s6_addr8[15] = 0x12; 877 if (in6_setscope(&ip6->ip6_dst, sc->sc_carpdev, NULL) != 0) { 878 m_freem(m); 879 CARP_DEBUG("%s: in6_setscope failed\n", __func__); 880 return; 881 } 882 883 ch_ptr = (struct carp_header *)(&ip6[1]); 884 bcopy(&ch, ch_ptr, sizeof(ch)); 885 if (carp_prepare_ad(m, sc, ch_ptr)) 886 return; 887 888 m->m_data += sizeof(*ip6); 889 ch_ptr->carp_cksum = carp_cksum(m, len - sizeof(*ip6)); 890 m->m_data -= sizeof(*ip6); 891 892 CARPSTATS_INC(carps_opackets6); 893 894 if (ip6_output(m, NULL, NULL, 0, 895 &sc->sc_carpdev->if_carp->cif_im6o, NULL, NULL)) { 896 if (sc->sc_sendad_errors < INT_MAX) 897 sc->sc_sendad_errors++; 898 if (sc->sc_sendad_errors == CARP_SENDAD_MAX_ERRORS) 899 carp_demote_adj(carp_senderr_adj, 900 "send6 error"); 901 sc->sc_sendad_success = 0; 902 } else { 903 if (sc->sc_sendad_errors >= CARP_SENDAD_MAX_ERRORS) { 904 if (++sc->sc_sendad_success >= 905 CARP_SENDAD_MIN_SUCCESS) { 906 carp_demote_adj(-carp_senderr_adj, 907 "send6 ok"); 908 sc->sc_sendad_errors = 0; 909 } 910 } else 911 sc->sc_sendad_errors = 0; 912 } 913 } 914 #endif /* INET6 */ 915 916 callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), carp_send_ad, sc); 917 } 918 919 static void 920 carp_addroute(struct carp_softc *sc) 921 { 922 struct ifaddr *ifa; 923 924 CARP_FOREACH_IFA(sc, ifa) 925 carp_ifa_addroute(ifa); 926 } 927 928 static void 929 carp_ifa_addroute(struct ifaddr *ifa) 930 { 931 932 switch (ifa->ifa_addr->sa_family) { 933 #ifdef INET 934 case AF_INET: 935 in_addprefix(ifatoia(ifa), RTF_UP); 936 ifa_add_loopback_route(ifa, 937 (struct sockaddr *)&ifatoia(ifa)->ia_addr); 938 break; 939 #endif 940 #ifdef INET6 941 case AF_INET6: 942 ifa_add_loopback_route(ifa, 943 (struct sockaddr *)&ifatoia6(ifa)->ia_addr); 944 in6_ifaddloop(ifa); 945 break; 946 #endif 947 } 948 } 949 950 static void 951 carp_delroute(struct carp_softc *sc) 952 { 953 struct ifaddr *ifa; 954 955 CARP_FOREACH_IFA(sc, ifa) 956 carp_ifa_delroute(ifa); 957 } 958 959 static void 960 carp_ifa_delroute(struct ifaddr *ifa) 961 { 962 963 switch (ifa->ifa_addr->sa_family) { 964 #ifdef INET 965 case AF_INET: 966 ifa_del_loopback_route(ifa, 967 (struct sockaddr *)&ifatoia(ifa)->ia_addr); 968 in_scrubprefix(ifatoia(ifa), LLE_STATIC); 969 break; 970 #endif 971 #ifdef INET6 972 case AF_INET6: 973 ifa_del_loopback_route(ifa, 974 (struct sockaddr *)&ifatoia6(ifa)->ia_addr); 975 in6_ifremloop(ifa); 976 break; 977 #endif 978 } 979 } 980 981 #ifdef INET 982 /* 983 * Broadcast a gratuitous ARP request containing 984 * the virtual router MAC address for each IP address 985 * associated with the virtual router. 986 */ 987 static void 988 carp_send_arp(struct carp_softc *sc) 989 { 990 struct ifaddr *ifa; 991 992 CARP_FOREACH_IFA(sc, ifa) 993 if (ifa->ifa_addr->sa_family == AF_INET) 994 arp_ifinit2(sc->sc_carpdev, ifa, LLADDR(&sc->sc_addr)); 995 } 996 997 int 998 carp_iamatch(struct ifaddr *ifa, uint8_t **enaddr) 999 { 1000 struct carp_softc *sc = ifa->ifa_carp; 1001 1002 if (sc->sc_state == MASTER) { 1003 *enaddr = LLADDR(&sc->sc_addr); 1004 return (1); 1005 } 1006 1007 return (0); 1008 } 1009 #endif 1010 1011 #ifdef INET6 1012 static void 1013 carp_send_na(struct carp_softc *sc) 1014 { 1015 static struct in6_addr mcast = IN6ADDR_LINKLOCAL_ALLNODES_INIT; 1016 struct ifaddr *ifa; 1017 struct in6_addr *in6; 1018 1019 CARP_FOREACH_IFA(sc, ifa) { 1020 if (ifa->ifa_addr->sa_family != AF_INET6) 1021 continue; 1022 1023 in6 = IFA_IN6(ifa); 1024 nd6_na_output(sc->sc_carpdev, &mcast, in6, 1025 ND_NA_FLAG_OVERRIDE, 1, NULL); 1026 DELAY(1000); /* XXX */ 1027 } 1028 } 1029 1030 struct ifaddr * 1031 carp_iamatch6(struct ifnet *ifp, struct in6_addr *taddr) 1032 { 1033 struct ifaddr *ifa; 1034 1035 IF_ADDR_RLOCK(ifp); 1036 IFNET_FOREACH_IFA(ifp, ifa) 1037 if (ifa->ifa_addr->sa_family == AF_INET6 && 1038 ifa->ifa_carp->sc_state == MASTER && 1039 IN6_ARE_ADDR_EQUAL(taddr, IFA_IN6(ifa))) { 1040 ifa_ref(ifa); 1041 IF_ADDR_RUNLOCK(ifp); 1042 return (ifa); 1043 } 1044 IF_ADDR_RUNLOCK(ifp); 1045 1046 return (NULL); 1047 } 1048 1049 caddr_t 1050 carp_macmatch6(struct ifnet *ifp, struct mbuf *m, const struct in6_addr *taddr) 1051 { 1052 struct ifaddr *ifa; 1053 1054 IF_ADDR_RLOCK(ifp); 1055 IFNET_FOREACH_IFA(ifp, ifa) 1056 if (ifa->ifa_addr->sa_family == AF_INET6 && 1057 IN6_ARE_ADDR_EQUAL(taddr, IFA_IN6(ifa))) { 1058 struct carp_softc *sc = ifa->ifa_carp; 1059 struct m_tag *mtag; 1060 1061 IF_ADDR_RUNLOCK(ifp); 1062 1063 mtag = m_tag_get(PACKET_TAG_CARP, 1064 sizeof(struct carp_softc *), M_NOWAIT); 1065 if (mtag == NULL) 1066 /* Better a bit than nothing. */ 1067 return (LLADDR(&sc->sc_addr)); 1068 1069 bcopy(&sc, mtag + 1, sizeof(sc)); 1070 m_tag_prepend(m, mtag); 1071 1072 return (LLADDR(&sc->sc_addr)); 1073 } 1074 IF_ADDR_RUNLOCK(ifp); 1075 1076 return (NULL); 1077 } 1078 #endif /* INET6 */ 1079 1080 int 1081 carp_forus(struct ifnet *ifp, u_char *dhost) 1082 { 1083 struct carp_softc *sc; 1084 uint8_t *ena = dhost; 1085 1086 if (ena[0] || ena[1] || ena[2] != 0x5e || ena[3] || ena[4] != 1) 1087 return (0); 1088 1089 CIF_LOCK(ifp->if_carp); 1090 IFNET_FOREACH_CARP(ifp, sc) { 1091 CARP_LOCK(sc); 1092 if (sc->sc_state == MASTER && !bcmp(dhost, LLADDR(&sc->sc_addr), 1093 ETHER_ADDR_LEN)) { 1094 CARP_UNLOCK(sc); 1095 CIF_UNLOCK(ifp->if_carp); 1096 return (1); 1097 } 1098 CARP_UNLOCK(sc); 1099 } 1100 CIF_UNLOCK(ifp->if_carp); 1101 1102 return (0); 1103 } 1104 1105 /* Master down timeout event, executed in callout context. */ 1106 static void 1107 carp_master_down(void *v) 1108 { 1109 struct carp_softc *sc = v; 1110 1111 CARP_LOCK_ASSERT(sc); 1112 1113 CURVNET_SET(sc->sc_carpdev->if_vnet); 1114 if (sc->sc_state == BACKUP) { 1115 CARP_LOG("VHID %u@%s: BACKUP -> MASTER (master down)\n", 1116 sc->sc_vhid, 1117 sc->sc_carpdev->if_xname); 1118 carp_master_down_locked(sc); 1119 } 1120 CURVNET_RESTORE(); 1121 1122 CARP_UNLOCK(sc); 1123 } 1124 1125 static void 1126 carp_master_down_locked(struct carp_softc *sc) 1127 { 1128 1129 CARP_LOCK_ASSERT(sc); 1130 1131 switch (sc->sc_state) { 1132 case BACKUP: 1133 carp_set_state(sc, MASTER); 1134 carp_send_ad_locked(sc); 1135 #ifdef INET 1136 carp_send_arp(sc); 1137 #endif 1138 #ifdef INET6 1139 carp_send_na(sc); 1140 #endif 1141 carp_setrun(sc, 0); 1142 carp_addroute(sc); 1143 break; 1144 case INIT: 1145 case MASTER: 1146 #ifdef INVARIANTS 1147 panic("carp: VHID %u@%s: master_down event in %s state\n", 1148 sc->sc_vhid, 1149 sc->sc_carpdev->if_xname, 1150 sc->sc_state ? "MASTER" : "INIT"); 1151 #endif 1152 break; 1153 } 1154 } 1155 1156 /* 1157 * When in backup state, af indicates whether to reset the master down timer 1158 * for v4 or v6. If it's set to zero, reset the ones which are already pending. 1159 */ 1160 static void 1161 carp_setrun(struct carp_softc *sc, sa_family_t af) 1162 { 1163 struct timeval tv; 1164 1165 CARP_LOCK_ASSERT(sc); 1166 1167 if ((sc->sc_carpdev->if_flags & IFF_UP) == 0 || 1168 sc->sc_carpdev->if_link_state != LINK_STATE_UP || 1169 (sc->sc_naddrs == 0 && sc->sc_naddrs6 == 0)) 1170 return; 1171 1172 switch (sc->sc_state) { 1173 case INIT: 1174 CARP_LOG("VHID %u@%s: INIT -> BACKUP\n", 1175 sc->sc_vhid, 1176 sc->sc_carpdev->if_xname); 1177 carp_set_state(sc, BACKUP); 1178 carp_setrun(sc, 0); 1179 break; 1180 case BACKUP: 1181 callout_stop(&sc->sc_ad_tmo); 1182 tv.tv_sec = 3 * sc->sc_advbase; 1183 tv.tv_usec = sc->sc_advskew * 1000000 / 256; 1184 switch (af) { 1185 #ifdef INET 1186 case AF_INET: 1187 callout_reset(&sc->sc_md_tmo, tvtohz(&tv), 1188 carp_master_down, sc); 1189 break; 1190 #endif 1191 #ifdef INET6 1192 case AF_INET6: 1193 callout_reset(&sc->sc_md6_tmo, tvtohz(&tv), 1194 carp_master_down, sc); 1195 break; 1196 #endif 1197 default: 1198 #ifdef INET 1199 if (sc->sc_naddrs) 1200 callout_reset(&sc->sc_md_tmo, tvtohz(&tv), 1201 carp_master_down, sc); 1202 #endif 1203 #ifdef INET6 1204 if (sc->sc_naddrs6) 1205 callout_reset(&sc->sc_md6_tmo, tvtohz(&tv), 1206 carp_master_down, sc); 1207 #endif 1208 break; 1209 } 1210 break; 1211 case MASTER: 1212 tv.tv_sec = sc->sc_advbase; 1213 tv.tv_usec = sc->sc_advskew * 1000000 / 256; 1214 callout_reset(&sc->sc_ad_tmo, tvtohz(&tv), 1215 carp_send_ad, sc); 1216 break; 1217 } 1218 } 1219 1220 /* 1221 * Setup multicast structures. 1222 */ 1223 static int 1224 carp_multicast_setup(struct carp_if *cif, sa_family_t sa) 1225 { 1226 struct ifnet *ifp = cif->cif_ifp; 1227 int error = 0; 1228 1229 CIF_LOCK_ASSERT(cif); 1230 1231 switch (sa) { 1232 #ifdef INET 1233 case AF_INET: 1234 { 1235 struct ip_moptions *imo = &cif->cif_imo; 1236 struct in_addr addr; 1237 1238 if (imo->imo_membership) 1239 return (0); 1240 1241 imo->imo_membership = (struct in_multi **)malloc( 1242 (sizeof(struct in_multi *) * IP_MIN_MEMBERSHIPS), M_CARP, 1243 M_NOWAIT); 1244 if (imo->imo_membership == NULL) 1245 return (ENOMEM); 1246 imo->imo_mfilters = NULL; 1247 imo->imo_max_memberships = IP_MIN_MEMBERSHIPS; 1248 imo->imo_multicast_vif = -1; 1249 1250 addr.s_addr = htonl(INADDR_CARP_GROUP); 1251 if ((error = in_joingroup(ifp, &addr, NULL, 1252 &imo->imo_membership[0])) != 0) { 1253 free(imo->imo_membership, M_CARP); 1254 break; 1255 } 1256 imo->imo_num_memberships++; 1257 imo->imo_multicast_ifp = ifp; 1258 imo->imo_multicast_ttl = CARP_DFLTTL; 1259 imo->imo_multicast_loop = 0; 1260 break; 1261 } 1262 #endif 1263 #ifdef INET6 1264 case AF_INET6: 1265 { 1266 struct ip6_moptions *im6o = &cif->cif_im6o; 1267 struct in6_addr in6; 1268 struct in6_multi *in6m; 1269 1270 if (im6o->im6o_membership) 1271 return (0); 1272 1273 im6o->im6o_membership = (struct in6_multi **)malloc( 1274 (sizeof(struct in6_multi *) * IPV6_MIN_MEMBERSHIPS), M_CARP, 1275 M_ZERO | M_NOWAIT); 1276 if (im6o->im6o_membership == NULL) 1277 return (ENOMEM); 1278 im6o->im6o_mfilters = NULL; 1279 im6o->im6o_max_memberships = IPV6_MIN_MEMBERSHIPS; 1280 im6o->im6o_multicast_hlim = CARP_DFLTTL; 1281 im6o->im6o_multicast_ifp = ifp; 1282 1283 /* Join IPv6 CARP multicast group. */ 1284 bzero(&in6, sizeof(in6)); 1285 in6.s6_addr16[0] = htons(0xff02); 1286 in6.s6_addr8[15] = 0x12; 1287 if ((error = in6_setscope(&in6, ifp, NULL)) != 0) { 1288 free(im6o->im6o_membership, M_CARP); 1289 break; 1290 } 1291 in6m = NULL; 1292 if ((error = in6_mc_join(ifp, &in6, NULL, &in6m, 0)) != 0) { 1293 free(im6o->im6o_membership, M_CARP); 1294 break; 1295 } 1296 im6o->im6o_membership[0] = in6m; 1297 im6o->im6o_num_memberships++; 1298 1299 /* Join solicited multicast address. */ 1300 bzero(&in6, sizeof(in6)); 1301 in6.s6_addr16[0] = htons(0xff02); 1302 in6.s6_addr32[1] = 0; 1303 in6.s6_addr32[2] = htonl(1); 1304 in6.s6_addr32[3] = 0; 1305 in6.s6_addr8[12] = 0xff; 1306 if ((error = in6_setscope(&in6, ifp, NULL)) != 0) { 1307 in6_mc_leave(im6o->im6o_membership[0], NULL); 1308 free(im6o->im6o_membership, M_CARP); 1309 break; 1310 } 1311 in6m = NULL; 1312 if ((error = in6_mc_join(ifp, &in6, NULL, &in6m, 0)) != 0) { 1313 in6_mc_leave(im6o->im6o_membership[0], NULL); 1314 free(im6o->im6o_membership, M_CARP); 1315 break; 1316 } 1317 im6o->im6o_membership[1] = in6m; 1318 im6o->im6o_num_memberships++; 1319 break; 1320 } 1321 #endif 1322 } 1323 1324 return (error); 1325 } 1326 1327 /* 1328 * Free multicast structures. 1329 */ 1330 static void 1331 carp_multicast_cleanup(struct carp_if *cif, sa_family_t sa) 1332 { 1333 1334 CIF_LOCK_ASSERT(cif); 1335 switch (sa) { 1336 #ifdef INET 1337 case AF_INET: 1338 if (cif->cif_naddrs == 0) { 1339 struct ip_moptions *imo = &cif->cif_imo; 1340 1341 in_leavegroup(imo->imo_membership[0], NULL); 1342 KASSERT(imo->imo_mfilters == NULL, 1343 ("%s: imo_mfilters != NULL", __func__)); 1344 free(imo->imo_membership, M_CARP); 1345 imo->imo_membership = NULL; 1346 1347 } 1348 break; 1349 #endif 1350 #ifdef INET6 1351 case AF_INET6: 1352 if (cif->cif_naddrs6 == 0) { 1353 struct ip6_moptions *im6o = &cif->cif_im6o; 1354 1355 in6_mc_leave(im6o->im6o_membership[0], NULL); 1356 in6_mc_leave(im6o->im6o_membership[1], NULL); 1357 KASSERT(im6o->im6o_mfilters == NULL, 1358 ("%s: im6o_mfilters != NULL", __func__)); 1359 free(im6o->im6o_membership, M_CARP); 1360 im6o->im6o_membership = NULL; 1361 } 1362 break; 1363 #endif 1364 } 1365 } 1366 1367 int 1368 carp_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *sa) 1369 { 1370 struct m_tag *mtag; 1371 struct carp_softc *sc; 1372 1373 if (!sa) 1374 return (0); 1375 1376 switch (sa->sa_family) { 1377 #ifdef INET 1378 case AF_INET: 1379 break; 1380 #endif 1381 #ifdef INET6 1382 case AF_INET6: 1383 break; 1384 #endif 1385 default: 1386 return (0); 1387 } 1388 1389 mtag = m_tag_find(m, PACKET_TAG_CARP, NULL); 1390 if (mtag == NULL) 1391 return (0); 1392 1393 bcopy(mtag + 1, &sc, sizeof(sc)); 1394 1395 /* Set the source MAC address to the Virtual Router MAC Address. */ 1396 switch (ifp->if_type) { 1397 case IFT_ETHER: 1398 case IFT_BRIDGE: 1399 case IFT_L2VLAN: { 1400 struct ether_header *eh; 1401 1402 eh = mtod(m, struct ether_header *); 1403 eh->ether_shost[0] = 0; 1404 eh->ether_shost[1] = 0; 1405 eh->ether_shost[2] = 0x5e; 1406 eh->ether_shost[3] = 0; 1407 eh->ether_shost[4] = 1; 1408 eh->ether_shost[5] = sc->sc_vhid; 1409 } 1410 break; 1411 case IFT_FDDI: { 1412 struct fddi_header *fh; 1413 1414 fh = mtod(m, struct fddi_header *); 1415 fh->fddi_shost[0] = 0; 1416 fh->fddi_shost[1] = 0; 1417 fh->fddi_shost[2] = 0x5e; 1418 fh->fddi_shost[3] = 0; 1419 fh->fddi_shost[4] = 1; 1420 fh->fddi_shost[5] = sc->sc_vhid; 1421 } 1422 break; 1423 case IFT_ISO88025: { 1424 struct iso88025_header *th; 1425 th = mtod(m, struct iso88025_header *); 1426 th->iso88025_shost[0] = 3; 1427 th->iso88025_shost[1] = 0; 1428 th->iso88025_shost[2] = 0x40 >> (sc->sc_vhid - 1); 1429 th->iso88025_shost[3] = 0x40000 >> (sc->sc_vhid - 1); 1430 th->iso88025_shost[4] = 0; 1431 th->iso88025_shost[5] = 0; 1432 } 1433 break; 1434 default: 1435 printf("%s: carp is not supported for the %d interface type\n", 1436 ifp->if_xname, ifp->if_type); 1437 return (EOPNOTSUPP); 1438 } 1439 1440 return (0); 1441 } 1442 1443 static struct carp_softc* 1444 carp_alloc(struct ifnet *ifp) 1445 { 1446 struct carp_softc *sc; 1447 struct carp_if *cif; 1448 1449 if ((cif = ifp->if_carp) == NULL) { 1450 cif = carp_alloc_if(ifp); 1451 if (cif == NULL) 1452 return (NULL); 1453 } 1454 1455 sc = malloc(sizeof(*sc), M_CARP, M_WAITOK|M_ZERO); 1456 1457 sc->sc_advbase = CARP_DFLTINTV; 1458 sc->sc_vhid = -1; /* required setting */ 1459 sc->sc_init_counter = 1; 1460 sc->sc_state = INIT; 1461 1462 sc->sc_ifasiz = sizeof(struct ifaddr *); 1463 sc->sc_ifas = malloc(sc->sc_ifasiz, M_CARP, M_WAITOK|M_ZERO); 1464 sc->sc_carpdev = ifp; 1465 1466 CARP_LOCK_INIT(sc); 1467 #ifdef INET 1468 callout_init_mtx(&sc->sc_md_tmo, &sc->sc_mtx, CALLOUT_RETURNUNLOCKED); 1469 #endif 1470 #ifdef INET6 1471 callout_init_mtx(&sc->sc_md6_tmo, &sc->sc_mtx, CALLOUT_RETURNUNLOCKED); 1472 #endif 1473 callout_init_mtx(&sc->sc_ad_tmo, &sc->sc_mtx, CALLOUT_RETURNUNLOCKED); 1474 1475 CIF_LOCK(cif); 1476 TAILQ_INSERT_TAIL(&cif->cif_vrs, sc, sc_list); 1477 CIF_UNLOCK(cif); 1478 1479 mtx_lock(&carp_mtx); 1480 LIST_INSERT_HEAD(&carp_list, sc, sc_next); 1481 mtx_unlock(&carp_mtx); 1482 1483 return (sc); 1484 } 1485 1486 static int 1487 carp_grow_ifas(struct carp_softc *sc) 1488 { 1489 struct ifaddr **new; 1490 1491 CARP_LOCK_ASSERT(sc); 1492 1493 new = malloc(sc->sc_ifasiz * 2, M_CARP, M_NOWAIT|M_ZERO); 1494 if (new == NULL) 1495 return (ENOMEM); 1496 bcopy(sc->sc_ifas, new, sc->sc_ifasiz); 1497 free(sc->sc_ifas, M_CARP); 1498 sc->sc_ifas = new; 1499 sc->sc_ifasiz *= 2; 1500 1501 return (0); 1502 } 1503 1504 static void 1505 carp_destroy(struct carp_softc *sc) 1506 { 1507 struct ifnet *ifp = sc->sc_carpdev; 1508 struct carp_if *cif = ifp->if_carp; 1509 1510 CIF_LOCK_ASSERT(cif); 1511 1512 TAILQ_REMOVE(&cif->cif_vrs, sc, sc_list); 1513 1514 mtx_lock(&carp_mtx); 1515 LIST_REMOVE(sc, sc_next); 1516 mtx_unlock(&carp_mtx); 1517 1518 CARP_LOCK(sc); 1519 if (sc->sc_suppress) 1520 carp_demote_adj(-carp_ifdown_adj, "vhid removed"); 1521 callout_drain(&sc->sc_ad_tmo); 1522 #ifdef INET 1523 callout_drain(&sc->sc_md_tmo); 1524 #endif 1525 #ifdef INET6 1526 callout_drain(&sc->sc_md6_tmo); 1527 #endif 1528 CARP_LOCK_DESTROY(sc); 1529 1530 free(sc->sc_ifas, M_CARP); 1531 free(sc, M_CARP); 1532 } 1533 1534 static struct carp_if* 1535 carp_alloc_if(struct ifnet *ifp) 1536 { 1537 struct carp_if *cif; 1538 1539 cif = malloc(sizeof(*cif), M_CARP, M_WAITOK|M_ZERO); 1540 1541 if (ifpromisc(ifp, 1) != 0) 1542 goto cleanup; 1543 1544 CIF_LOCK_INIT(cif); 1545 cif->cif_ifp = ifp; 1546 TAILQ_INIT(&cif->cif_vrs); 1547 1548 IF_ADDR_WLOCK(ifp); 1549 ifp->if_carp = cif; 1550 if_ref(ifp); 1551 IF_ADDR_WUNLOCK(ifp); 1552 1553 return (cif); 1554 1555 cleanup: 1556 free(cif, M_CARP); 1557 1558 return (NULL); 1559 } 1560 1561 static void 1562 carp_free_if(struct carp_if *cif) 1563 { 1564 struct ifnet *ifp = cif->cif_ifp; 1565 1566 CIF_LOCK_ASSERT(cif); 1567 KASSERT(TAILQ_EMPTY(&cif->cif_vrs), ("%s: softc list not empty", 1568 __func__)); 1569 1570 IF_ADDR_WLOCK(ifp); 1571 ifp->if_carp = NULL; 1572 if_rele(ifp); 1573 IF_ADDR_WUNLOCK(ifp); 1574 1575 CIF_LOCK_DESTROY(cif); 1576 1577 ifpromisc(ifp, 0); 1578 1579 free(cif, M_CARP); 1580 } 1581 1582 static void 1583 carp_carprcp(struct carpreq *carpr, struct carp_softc *sc, int priv) 1584 { 1585 1586 CARP_LOCK(sc); 1587 carpr->carpr_state = sc->sc_state; 1588 carpr->carpr_vhid = sc->sc_vhid; 1589 carpr->carpr_advbase = sc->sc_advbase; 1590 carpr->carpr_advskew = sc->sc_advskew; 1591 if (priv) 1592 bcopy(sc->sc_key, carpr->carpr_key, sizeof(carpr->carpr_key)); 1593 else 1594 bzero(carpr->carpr_key, sizeof(carpr->carpr_key)); 1595 CARP_UNLOCK(sc); 1596 } 1597 1598 int 1599 carp_ioctl(struct ifreq *ifr, u_long cmd, struct thread *td) 1600 { 1601 struct carpreq carpr; 1602 struct ifnet *ifp; 1603 struct carp_softc *sc = NULL; 1604 int error = 0, locked = 0; 1605 1606 if ((error = copyin(ifr->ifr_data, &carpr, sizeof carpr))) 1607 return (error); 1608 1609 ifp = ifunit_ref(ifr->ifr_name); 1610 if (ifp == NULL) 1611 return (ENXIO); 1612 1613 switch (ifp->if_type) { 1614 case IFT_ETHER: 1615 case IFT_L2VLAN: 1616 case IFT_BRIDGE: 1617 case IFT_FDDI: 1618 case IFT_ISO88025: 1619 break; 1620 default: 1621 error = EOPNOTSUPP; 1622 goto out; 1623 } 1624 1625 if ((ifp->if_flags & IFF_MULTICAST) == 0) { 1626 error = EADDRNOTAVAIL; 1627 goto out; 1628 } 1629 1630 switch (cmd) { 1631 case SIOCSVH: 1632 if ((error = priv_check(td, PRIV_NETINET_CARP))) 1633 break; 1634 if (carpr.carpr_vhid <= 0 || carpr.carpr_vhid > CARP_MAXVHID || 1635 carpr.carpr_advbase < 0 || carpr.carpr_advskew < 0) { 1636 error = EINVAL; 1637 break; 1638 } 1639 1640 if (ifp->if_carp) { 1641 CIF_LOCK(ifp->if_carp); 1642 IFNET_FOREACH_CARP(ifp, sc) 1643 if (sc->sc_vhid == carpr.carpr_vhid) 1644 break; 1645 CIF_UNLOCK(ifp->if_carp); 1646 } 1647 if (sc == NULL) { 1648 sc = carp_alloc(ifp); 1649 if (sc == NULL) { 1650 error = EINVAL; /* XXX: ifpromisc failed */ 1651 break; 1652 } 1653 1654 CARP_LOCK(sc); 1655 sc->sc_vhid = carpr.carpr_vhid; 1656 LLADDR(&sc->sc_addr)[0] = 0; 1657 LLADDR(&sc->sc_addr)[1] = 0; 1658 LLADDR(&sc->sc_addr)[2] = 0x5e; 1659 LLADDR(&sc->sc_addr)[3] = 0; 1660 LLADDR(&sc->sc_addr)[4] = 1; 1661 LLADDR(&sc->sc_addr)[5] = sc->sc_vhid; 1662 } else 1663 CARP_LOCK(sc); 1664 locked = 1; 1665 if (carpr.carpr_advbase > 0) { 1666 if (carpr.carpr_advbase > 255 || 1667 carpr.carpr_advbase < CARP_DFLTINTV) { 1668 error = EINVAL; 1669 break; 1670 } 1671 sc->sc_advbase = carpr.carpr_advbase; 1672 } 1673 if (carpr.carpr_advskew > 0) { 1674 if (carpr.carpr_advskew >= 255) { 1675 error = EINVAL; 1676 break; 1677 } 1678 sc->sc_advskew = carpr.carpr_advskew; 1679 } 1680 if (carpr.carpr_key[0] != '\0') { 1681 bcopy(carpr.carpr_key, sc->sc_key, sizeof(sc->sc_key)); 1682 carp_hmac_prepare(sc); 1683 } 1684 if (sc->sc_state != INIT && 1685 carpr.carpr_state != sc->sc_state) { 1686 switch (carpr.carpr_state) { 1687 case BACKUP: 1688 callout_stop(&sc->sc_ad_tmo); 1689 carp_set_state(sc, BACKUP); 1690 carp_setrun(sc, 0); 1691 carp_delroute(sc); 1692 break; 1693 case MASTER: 1694 carp_master_down_locked(sc); 1695 break; 1696 default: 1697 break; 1698 } 1699 } 1700 break; 1701 1702 case SIOCGVH: 1703 { 1704 int priveleged; 1705 1706 if (carpr.carpr_vhid < 0 || carpr.carpr_vhid > CARP_MAXVHID) { 1707 error = EINVAL; 1708 break; 1709 } 1710 if (carpr.carpr_count < 1) { 1711 error = EMSGSIZE; 1712 break; 1713 } 1714 if (ifp->if_carp == NULL) { 1715 error = ENOENT; 1716 break; 1717 } 1718 1719 priveleged = (priv_check(td, PRIV_NETINET_CARP) == 0); 1720 if (carpr.carpr_vhid != 0) { 1721 CIF_LOCK(ifp->if_carp); 1722 IFNET_FOREACH_CARP(ifp, sc) 1723 if (sc->sc_vhid == carpr.carpr_vhid) 1724 break; 1725 CIF_UNLOCK(ifp->if_carp); 1726 if (sc == NULL) { 1727 error = ENOENT; 1728 break; 1729 } 1730 carp_carprcp(&carpr, sc, priveleged); 1731 error = copyout(&carpr, ifr->ifr_data, sizeof(carpr)); 1732 } else { 1733 int i, count; 1734 1735 count = 0; 1736 CIF_LOCK(ifp->if_carp); 1737 IFNET_FOREACH_CARP(ifp, sc) 1738 count++; 1739 1740 if (count > carpr.carpr_count) { 1741 CIF_UNLOCK(ifp->if_carp); 1742 error = EMSGSIZE; 1743 break; 1744 } 1745 1746 i = 0; 1747 IFNET_FOREACH_CARP(ifp, sc) { 1748 carp_carprcp(&carpr, sc, priveleged); 1749 carpr.carpr_count = count; 1750 error = copyout(&carpr, ifr->ifr_data + 1751 (i * sizeof(carpr)), sizeof(carpr)); 1752 if (error) { 1753 CIF_UNLOCK(ifp->if_carp); 1754 break; 1755 } 1756 i++; 1757 } 1758 CIF_UNLOCK(ifp->if_carp); 1759 } 1760 break; 1761 } 1762 default: 1763 error = EINVAL; 1764 } 1765 1766 out: 1767 if (locked) 1768 CARP_UNLOCK(sc); 1769 if_rele(ifp); 1770 1771 return (error); 1772 } 1773 1774 static int 1775 carp_get_vhid(struct ifaddr *ifa) 1776 { 1777 1778 if (ifa == NULL || ifa->ifa_carp == NULL) 1779 return (0); 1780 1781 return (ifa->ifa_carp->sc_vhid); 1782 } 1783 1784 int 1785 carp_attach(struct ifaddr *ifa, int vhid) 1786 { 1787 struct ifnet *ifp = ifa->ifa_ifp; 1788 struct carp_if *cif = ifp->if_carp; 1789 struct carp_softc *sc; 1790 int index, error; 1791 1792 if (ifp->if_carp == NULL) 1793 return (ENOPROTOOPT); 1794 1795 switch (ifa->ifa_addr->sa_family) { 1796 #ifdef INET 1797 case AF_INET: 1798 #endif 1799 #ifdef INET6 1800 case AF_INET6: 1801 #endif 1802 break; 1803 default: 1804 return (EPROTOTYPE); 1805 } 1806 1807 CIF_LOCK(cif); 1808 IFNET_FOREACH_CARP(ifp, sc) 1809 if (sc->sc_vhid == vhid) 1810 break; 1811 if (sc == NULL) { 1812 CIF_UNLOCK(cif); 1813 return (ENOENT); 1814 } 1815 1816 if (ifa->ifa_carp) { 1817 if (ifa->ifa_carp->sc_vhid != vhid) 1818 carp_detach_locked(ifa); 1819 else { 1820 CIF_UNLOCK(cif); 1821 return (0); 1822 } 1823 } 1824 1825 error = carp_multicast_setup(cif, ifa->ifa_addr->sa_family); 1826 if (error) { 1827 CIF_FREE(cif); 1828 return (error); 1829 } 1830 1831 CARP_LOCK(sc); 1832 index = sc->sc_naddrs + sc->sc_naddrs6 + 1; 1833 if (index > sc->sc_ifasiz / sizeof(struct ifaddr *)) 1834 if ((error = carp_grow_ifas(sc)) != 0) { 1835 carp_multicast_cleanup(cif, 1836 ifa->ifa_addr->sa_family); 1837 CARP_UNLOCK(sc); 1838 CIF_FREE(cif); 1839 return (error); 1840 } 1841 1842 switch (ifa->ifa_addr->sa_family) { 1843 #ifdef INET 1844 case AF_INET: 1845 cif->cif_naddrs++; 1846 sc->sc_naddrs++; 1847 break; 1848 #endif 1849 #ifdef INET6 1850 case AF_INET6: 1851 cif->cif_naddrs6++; 1852 sc->sc_naddrs6++; 1853 break; 1854 #endif 1855 } 1856 1857 ifa_ref(ifa); 1858 sc->sc_ifas[index - 1] = ifa; 1859 ifa->ifa_carp = sc; 1860 1861 carp_hmac_prepare(sc); 1862 carp_sc_state(sc); 1863 1864 CARP_UNLOCK(sc); 1865 CIF_UNLOCK(cif); 1866 1867 return (0); 1868 } 1869 1870 void 1871 carp_detach(struct ifaddr *ifa) 1872 { 1873 struct ifnet *ifp = ifa->ifa_ifp; 1874 struct carp_if *cif = ifp->if_carp; 1875 1876 CIF_LOCK(cif); 1877 carp_detach_locked(ifa); 1878 CIF_FREE(cif); 1879 } 1880 1881 static void 1882 carp_detach_locked(struct ifaddr *ifa) 1883 { 1884 struct ifnet *ifp = ifa->ifa_ifp; 1885 struct carp_if *cif = ifp->if_carp; 1886 struct carp_softc *sc = ifa->ifa_carp; 1887 int i, index; 1888 1889 KASSERT(sc != NULL, ("%s: %p not attached", __func__, ifa)); 1890 1891 CIF_LOCK_ASSERT(cif); 1892 CARP_LOCK(sc); 1893 1894 /* Shift array. */ 1895 index = sc->sc_naddrs + sc->sc_naddrs6; 1896 for (i = 0; i < index; i++) 1897 if (sc->sc_ifas[i] == ifa) 1898 break; 1899 KASSERT(i < index, ("%s: %p no backref", __func__, ifa)); 1900 for (; i < index - 1; i++) 1901 sc->sc_ifas[i] = sc->sc_ifas[i+1]; 1902 sc->sc_ifas[index - 1] = NULL; 1903 1904 switch (ifa->ifa_addr->sa_family) { 1905 #ifdef INET 1906 case AF_INET: 1907 cif->cif_naddrs--; 1908 sc->sc_naddrs--; 1909 break; 1910 #endif 1911 #ifdef INET6 1912 case AF_INET6: 1913 cif->cif_naddrs6--; 1914 sc->sc_naddrs6--; 1915 break; 1916 #endif 1917 } 1918 1919 carp_ifa_delroute(ifa); 1920 carp_multicast_cleanup(cif, ifa->ifa_addr->sa_family); 1921 1922 ifa->ifa_carp = NULL; 1923 ifa_free(ifa); 1924 1925 carp_hmac_prepare(sc); 1926 carp_sc_state(sc); 1927 1928 if (sc->sc_naddrs == 0 && sc->sc_naddrs6 == 0) { 1929 CARP_UNLOCK(sc); 1930 carp_destroy(sc); 1931 } else 1932 CARP_UNLOCK(sc); 1933 } 1934 1935 static void 1936 carp_set_state(struct carp_softc *sc, int state) 1937 { 1938 1939 CARP_LOCK_ASSERT(sc); 1940 1941 if (sc->sc_state != state) { 1942 const char *carp_states[] = { CARP_STATES }; 1943 char subsys[IFNAMSIZ+5]; 1944 1945 sc->sc_state = state; 1946 1947 snprintf(subsys, IFNAMSIZ+5, "%u@%s", sc->sc_vhid, 1948 sc->sc_carpdev->if_xname); 1949 devctl_notify("CARP", subsys, carp_states[state], NULL); 1950 } 1951 } 1952 1953 static void 1954 carp_linkstate(struct ifnet *ifp) 1955 { 1956 struct carp_softc *sc; 1957 1958 CIF_LOCK(ifp->if_carp); 1959 IFNET_FOREACH_CARP(ifp, sc) { 1960 CARP_LOCK(sc); 1961 carp_sc_state(sc); 1962 CARP_UNLOCK(sc); 1963 } 1964 CIF_UNLOCK(ifp->if_carp); 1965 } 1966 1967 static void 1968 carp_sc_state(struct carp_softc *sc) 1969 { 1970 1971 CARP_LOCK_ASSERT(sc); 1972 1973 if (sc->sc_carpdev->if_link_state != LINK_STATE_UP || 1974 !(sc->sc_carpdev->if_flags & IFF_UP)) { 1975 callout_stop(&sc->sc_ad_tmo); 1976 #ifdef INET 1977 callout_stop(&sc->sc_md_tmo); 1978 #endif 1979 #ifdef INET6 1980 callout_stop(&sc->sc_md6_tmo); 1981 #endif 1982 carp_set_state(sc, INIT); 1983 carp_setrun(sc, 0); 1984 if (!sc->sc_suppress) 1985 carp_demote_adj(carp_ifdown_adj, "interface down"); 1986 sc->sc_suppress = 1; 1987 } else { 1988 carp_set_state(sc, INIT); 1989 carp_setrun(sc, 0); 1990 if (sc->sc_suppress) 1991 carp_demote_adj(-carp_ifdown_adj, "interface up"); 1992 sc->sc_suppress = 0; 1993 } 1994 } 1995 1996 static void 1997 carp_demote_adj(int adj, char *reason) 1998 { 1999 carp_demotion += adj; 2000 CARP_LOG("demoted by %d to %d (%s)\n", adj, carp_demotion, reason); 2001 taskqueue_enqueue(taskqueue_swi, &carp_sendall_task); 2002 } 2003 2004 #ifdef INET 2005 extern struct domain inetdomain; 2006 static struct protosw in_carp_protosw = { 2007 .pr_type = SOCK_RAW, 2008 .pr_domain = &inetdomain, 2009 .pr_protocol = IPPROTO_CARP, 2010 .pr_flags = PR_ATOMIC|PR_ADDR, 2011 .pr_input = carp_input, 2012 .pr_output = (pr_output_t *)rip_output, 2013 .pr_ctloutput = rip_ctloutput, 2014 .pr_usrreqs = &rip_usrreqs 2015 }; 2016 #endif 2017 2018 #ifdef INET6 2019 extern struct domain inet6domain; 2020 static struct ip6protosw in6_carp_protosw = { 2021 .pr_type = SOCK_RAW, 2022 .pr_domain = &inet6domain, 2023 .pr_protocol = IPPROTO_CARP, 2024 .pr_flags = PR_ATOMIC|PR_ADDR, 2025 .pr_input = carp6_input, 2026 .pr_output = rip6_output, 2027 .pr_ctloutput = rip6_ctloutput, 2028 .pr_usrreqs = &rip6_usrreqs 2029 }; 2030 #endif 2031 2032 static void 2033 carp_mod_cleanup(void) 2034 { 2035 2036 #ifdef INET 2037 if (proto_reg[CARP_INET] == 0) { 2038 (void)ipproto_unregister(IPPROTO_CARP); 2039 pf_proto_unregister(PF_INET, IPPROTO_CARP, SOCK_RAW); 2040 proto_reg[CARP_INET] = -1; 2041 } 2042 carp_iamatch_p = NULL; 2043 #endif 2044 #ifdef INET6 2045 if (proto_reg[CARP_INET6] == 0) { 2046 (void)ip6proto_unregister(IPPROTO_CARP); 2047 pf_proto_unregister(PF_INET6, IPPROTO_CARP, SOCK_RAW); 2048 proto_reg[CARP_INET6] = -1; 2049 } 2050 carp_iamatch6_p = NULL; 2051 carp_macmatch6_p = NULL; 2052 #endif 2053 carp_ioctl_p = NULL; 2054 carp_attach_p = NULL; 2055 carp_detach_p = NULL; 2056 carp_get_vhid_p = NULL; 2057 carp_linkstate_p = NULL; 2058 carp_forus_p = NULL; 2059 carp_output_p = NULL; 2060 carp_demote_adj_p = NULL; 2061 mtx_unlock(&carp_mtx); 2062 taskqueue_drain(taskqueue_swi, &carp_sendall_task); 2063 mtx_destroy(&carp_mtx); 2064 } 2065 2066 static int 2067 carp_mod_load(void) 2068 { 2069 int err; 2070 2071 mtx_init(&carp_mtx, "carp_mtx", NULL, MTX_DEF); 2072 LIST_INIT(&carp_list); 2073 carp_get_vhid_p = carp_get_vhid; 2074 carp_forus_p = carp_forus; 2075 carp_output_p = carp_output; 2076 carp_linkstate_p = carp_linkstate; 2077 carp_ioctl_p = carp_ioctl; 2078 carp_attach_p = carp_attach; 2079 carp_detach_p = carp_detach; 2080 carp_demote_adj_p = carp_demote_adj; 2081 #ifdef INET6 2082 carp_iamatch6_p = carp_iamatch6; 2083 carp_macmatch6_p = carp_macmatch6; 2084 proto_reg[CARP_INET6] = pf_proto_register(PF_INET6, 2085 (struct protosw *)&in6_carp_protosw); 2086 if (proto_reg[CARP_INET6]) { 2087 printf("carp: error %d attaching to PF_INET6\n", 2088 proto_reg[CARP_INET6]); 2089 carp_mod_cleanup(); 2090 return (proto_reg[CARP_INET6]); 2091 } 2092 err = ip6proto_register(IPPROTO_CARP); 2093 if (err) { 2094 printf("carp: error %d registering with INET6\n", err); 2095 carp_mod_cleanup(); 2096 return (err); 2097 } 2098 #endif 2099 #ifdef INET 2100 carp_iamatch_p = carp_iamatch; 2101 proto_reg[CARP_INET] = pf_proto_register(PF_INET, &in_carp_protosw); 2102 if (proto_reg[CARP_INET]) { 2103 printf("carp: error %d attaching to PF_INET\n", 2104 proto_reg[CARP_INET]); 2105 carp_mod_cleanup(); 2106 return (proto_reg[CARP_INET]); 2107 } 2108 err = ipproto_register(IPPROTO_CARP); 2109 if (err) { 2110 printf("carp: error %d registering with INET\n", err); 2111 carp_mod_cleanup(); 2112 return (err); 2113 } 2114 #endif 2115 return (0); 2116 } 2117 2118 static int 2119 carp_modevent(module_t mod, int type, void *data) 2120 { 2121 switch (type) { 2122 case MOD_LOAD: 2123 return carp_mod_load(); 2124 /* NOTREACHED */ 2125 case MOD_UNLOAD: 2126 mtx_lock(&carp_mtx); 2127 if (LIST_EMPTY(&carp_list)) 2128 carp_mod_cleanup(); 2129 else { 2130 mtx_unlock(&carp_mtx); 2131 return (EBUSY); 2132 } 2133 break; 2134 2135 default: 2136 return (EINVAL); 2137 } 2138 2139 return (0); 2140 } 2141 2142 static moduledata_t carp_mod = { 2143 "carp", 2144 carp_modevent, 2145 0 2146 }; 2147 2148 DECLARE_MODULE(carp, carp_mod, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY); 2149