]> git.proxmox.com Git - mirror_frr.git/blob - vrrpd/vrrp.c
Merge pull request #4877 from mjstapp/dplane_neighs
[mirror_frr.git] / vrrpd / vrrp.c
1 /*
2 * VRRP global definitions and state machine.
3 * Copyright (C) 2018-2019 Cumulus Networks, Inc.
4 * Quentin Young
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20 #include <zebra.h>
21
22 #include "lib/hash.h"
23 #include "lib/hook.h"
24 #include "lib/if.h"
25 #include "lib/linklist.h"
26 #include "lib/memory.h"
27 #include "lib/network.h"
28 #include "lib/prefix.h"
29 #include "lib/sockopt.h"
30 #include "lib/sockunion.h"
31 #include "lib/vrf.h"
32 #include "lib/vty.h"
33
34 #include "vrrp.h"
35 #include "vrrp_arp.h"
36 #include "vrrp_debug.h"
37 #include "vrrp_ndisc.h"
38 #include "vrrp_packet.h"
39 #include "vrrp_zebra.h"
40
41 #define VRRP_LOGPFX "[CORE] "
42
43 DEFINE_MTYPE_STATIC(VRRPD, VRRP_IP, "VRRP IP address")
44 DEFINE_MTYPE_STATIC(VRRPD, VRRP_RTR, "VRRP Router")
45
46 /* statics */
47 struct hash *vrrp_vrouters_hash;
48 bool vrrp_autoconfig_is_on;
49 int vrrp_autoconfig_version;
50
51 struct vrrp_defaults vd;
52
53 const char *vrrp_state_names[3] = {
54 [VRRP_STATE_INITIALIZE] = "Initialize",
55 [VRRP_STATE_MASTER] = "Master",
56 [VRRP_STATE_BACKUP] = "Backup",
57 };
58
59 const char *vrrp_event_names[2] = {
60 [VRRP_EVENT_STARTUP] = "Startup",
61 [VRRP_EVENT_SHUTDOWN] = "Shutdown",
62 };
63
64
65 /* Utility functions ------------------------------------------------------- */
66
67 /*
68 * Sets an ethaddr to RFC-defined Virtual Router MAC address.
69 *
70 * mac
71 * ethaddr to set
72 *
73 * v6
74 * Whether this is a V6 or V4 Virtual Router MAC
75 *
76 * vrid
77 * Virtual Router Identifier
78 */
79 static void vrrp_mac_set(struct ethaddr *mac, bool v6, uint8_t vrid)
80 {
81 /*
82 * V4: 00-00-5E-00-01-{VRID}
83 * V6: 00-00-5E-00-02-{VRID}
84 */
85 mac->octet[0] = 0x00;
86 mac->octet[1] = 0x00;
87 mac->octet[2] = 0x5E;
88 mac->octet[3] = 0x00;
89 mac->octet[4] = v6 ? 0x02 : 0x01;
90 mac->octet[5] = vrid;
91 }
92
93 /*
94 * Recalculates and sets skew_time and master_down_interval based
95 * values.
96 *
97 * r
98 * VRRP Router to operate on
99 */
100 static void vrrp_recalculate_timers(struct vrrp_router *r)
101 {
102 uint16_t mdiadv = r->vr->version == 3 ? r->master_adver_interval
103 : r->vr->advertisement_interval;
104 uint16_t skm = (r->vr->version == 3) ? r->master_adver_interval : 100;
105
106 r->skew_time = ((256 - r->vr->priority) * skm) / 256;
107 r->master_down_interval = 3 * mdiadv;
108 r->master_down_interval += r->skew_time;
109 }
110
111 /*
112 * Determines if a VRRP router is the owner of the specified address.
113 *
114 * The determining factor for whether an interface is the address owner is
115 * simply whether the address is assigned to the VRRP base interface by someone
116 * other than vrrpd.
117 *
118 * This function should always return the correct answer regardless of
119 * master/backup status.
120 *
121 * ifp
122 * The interface to check owernship of. This should be the base interface of
123 * a VRRP router.
124 *
125 * vr
126 * Virtual Router
127 *
128 * Returns:
129 * whether or not vr owns the specified address
130 */
131 static bool vrrp_is_owner(struct interface *ifp, struct ipaddr *addr)
132 {
133 /*
134 * This code sanity checks implicit ownership configuration. Ideally,
135 * the way we determine address ownership status for this VRRP router
136 * is by looking at whether our VIPs are also assigned to the base
137 * interface, and therefore count as "real" addresses. This frees the
138 * user from having to manually configure priority 255 to indicate
139 * address ownership. However, this means one of the VIPs will be used
140 * as the source address for VRRP advertisements, which in turn means
141 * that other VRRP routers will be receiving packets with a source
142 * address they themselves have. This causes lots of different issues
143 * so for now we're disabling this and forcing the user to configure
144 * priority 255 to indicate ownership.
145 */
146
147 return false;
148
149 #if 0
150 struct prefix p;
151
152 p.family = IS_IPADDR_V4(addr) ? AF_INET : AF_INET6;
153 p.prefixlen = IS_IPADDR_V4(addr) ? IPV4_MAX_BITLEN : IPV6_MAX_BITLEN;
154 memcpy(&p.u, &addr->ip, sizeof(addr->ip));
155
156 return !!connected_lookup_prefix_exact(ifp, &p);
157 #endif
158 }
159
160 /*
161 * Whether an interface has a MAC address that matches the VRRP RFC.
162 *
163 * ifp
164 * Interface to check
165 *
166 * Returns:
167 * Whether the interface has a VRRP mac or not
168 */
169 static bool vrrp_ifp_has_vrrp_mac(struct interface *ifp)
170 {
171 struct ethaddr vmac4;
172 struct ethaddr vmac6;
173
174 vrrp_mac_set(&vmac4, 0, 0x00);
175 vrrp_mac_set(&vmac6, 1, 0x00);
176
177 return !memcmp(ifp->hw_addr, vmac4.octet, sizeof(vmac4.octet) - 1)
178 || !memcmp(ifp->hw_addr, vmac6.octet, sizeof(vmac6.octet) - 1);
179 }
180
181 /*
182 * Lookup a Virtual Router instance given a macvlan subinterface.
183 *
184 * The VRID is extracted from the interface MAC and the 2-tuple (iface, vrid)
185 * is used to look up any existing instances that match the interface. It does
186 * not matter whether the instance is already bound to the interface or not.
187 *
188 * mvl_ifp
189 * Interface pointer to use to lookup. Should be a macvlan device.
190 *
191 * Returns:
192 * Virtual Router, if found
193 * NULL otherwise
194 */
195 static struct vrrp_vrouter *vrrp_lookup_by_if_mvl(struct interface *mvl_ifp)
196 {
197 struct interface *p;
198
199 if (!mvl_ifp || mvl_ifp->link_ifindex == 0
200 || !vrrp_ifp_has_vrrp_mac(mvl_ifp)) {
201 if (mvl_ifp && mvl_ifp->link_ifindex == 0)
202 DEBUGD(&vrrp_dbg_zebra,
203 VRRP_LOGPFX
204 "Interface %s has no parent ifindex; disregarding",
205 mvl_ifp->name);
206 if (mvl_ifp && !vrrp_ifp_has_vrrp_mac(mvl_ifp))
207 DEBUGD(&vrrp_dbg_zebra,
208 VRRP_LOGPFX
209 "Interface %s has a non-VRRP MAC; disregarding",
210 mvl_ifp->name);
211 return NULL;
212 }
213
214 p = if_lookup_by_index(mvl_ifp->link_ifindex, VRF_DEFAULT);
215 uint8_t vrid = mvl_ifp->hw_addr[5];
216
217 return vrrp_lookup(p, vrid);
218 }
219
220 /*
221 * Lookup the Virtual Router instances configured on a particular interface.
222 *
223 * ifp
224 * Interface pointer to use to lookup. Should not be a macvlan device.
225 *
226 * Returns:
227 * List of virtual routers found
228 */
229 static struct list *vrrp_lookup_by_if(struct interface *ifp)
230 {
231 struct list *l = hash_to_list(vrrp_vrouters_hash);
232 struct listnode *ln, *nn;
233 struct vrrp_vrouter *vr;
234
235 for (ALL_LIST_ELEMENTS(l, ln, nn, vr))
236 if (vr->ifp != ifp)
237 list_delete_node(l, ln);
238
239 return l;
240 }
241
242 /*
243 * Lookup any Virtual Router instances associated with a particular interface.
244 * This is a combination of the results from vrrp_lookup_by_if_mvl and
245 * vrrp_lookup_by_if.
246 *
247 * Suppose the system interface list looks like the following:
248 *
249 * eth0
250 * \- eth0-v0 00:00:5e:00:01:01
251 * \- eth0-v1 00:00:5e:00:02:01
252 * \- eth0-v2 00:00:5e:00:01:0a
253 *
254 * Passing eth0-v2 to this function will give you the VRRP instance configured
255 * on eth0 with VRID 10. Passing eth0-v0 or eth0-v1 will give you the VRRP
256 * instance configured on eth0 with VRID 1. Passing eth0 will give you both.
257 *
258 * ifp
259 * Interface pointer to use to lookup. Can be any interface.
260 *
261 * Returns:
262 * List of virtual routers found
263 */
264 static struct list *vrrp_lookup_by_if_any(struct interface *ifp)
265 {
266 struct vrrp_vrouter *vr;
267 struct list *vrs;
268
269 vr = vrrp_lookup_by_if_mvl(ifp);
270 vrs = vr ? list_new() : vrrp_lookup_by_if(ifp);
271
272 if (vr)
273 listnode_add(vrs, vr);
274
275 return vrs;
276 }
277
278 /* Configuration controllers ----------------------------------------------- */
279
280 void vrrp_check_start(struct vrrp_vrouter *vr)
281 {
282 struct vrrp_router *r;
283 bool start;
284 const char *whynot = NULL;
285
286 if (vr->shutdown || vr->ifp == NULL)
287 return;
288
289 r = vr->v4;
290 /* Must not already be started */
291 start = r->fsm.state == VRRP_STATE_INITIALIZE;
292 /* Must have a parent interface */
293 start = start && (vr->ifp != NULL);
294 whynot = (!start && !whynot) ? "No base interface" : NULL;
295 #if 0
296 /* Parent interface must be up */
297 start = start && if_is_operative(vr->ifp);
298 #endif
299 /* Parent interface must have at least one v4 */
300 start = start && vr->ifp->connected->count > 1;
301 whynot = (!start && !whynot) ? "No primary IPv4 address" : NULL;
302 /* Must have a macvlan interface */
303 start = start && (r->mvl_ifp != NULL);
304 whynot = (!start && !whynot) ? "No VRRP interface" : NULL;
305 #if 0
306 /* Macvlan interface must be admin up */
307 start = start && CHECK_FLAG(r->mvl_ifp->flags, IFF_UP);
308 #endif
309 /* Must have at least one VIP configured */
310 start = start && r->addrs->count > 0;
311 whynot =
312 (!start && !whynot) ? "No Virtual IP address configured" : NULL;
313 if (start)
314 vrrp_event(r, VRRP_EVENT_STARTUP);
315 else if (whynot)
316 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
317 "Refusing to start Virtual Router: %s",
318 vr->vrid, family2str(r->family), whynot);
319
320 r = vr->v6;
321 /* Must not already be started */
322 start = r->fsm.state == VRRP_STATE_INITIALIZE;
323 /* Must not be v2 */
324 start = start && vr->version != 2;
325 whynot = (!start && !whynot) ? "VRRPv2 does not support v6" : NULL;
326 /* Must have a parent interface */
327 start = start && (vr->ifp != NULL);
328 whynot = (!start && !whynot) ? "No base interface" : NULL;
329 #if 0
330 /* Parent interface must be up */
331 start = start && if_is_operative(vr->ifp);
332 #endif
333 /* Must have a macvlan interface */
334 start = start && (r->mvl_ifp != NULL);
335 whynot = (!start && !whynot) ? "No VRRP interface" : NULL;
336 #if 0
337 /* Macvlan interface must be admin up */
338 start = start && CHECK_FLAG(r->mvl_ifp->flags, IFF_UP);
339 /* Macvlan interface must have a link local */
340 start = start && connected_get_linklocal(r->mvl_ifp);
341 whynot =
342 (!start && !whynot) ? "No link local address configured" : NULL;
343 /* Macvlan interface must have a v6 IP besides the link local */
344 start = start && (r->mvl_ifp->connected->count >= 2);
345 whynot = (!start && !whynot)
346 ? "No Virtual IP configured on macvlan device"
347 : NULL;
348 #endif
349 /* Must have at least one VIP configured */
350 start = start && r->addrs->count > 0;
351 whynot =
352 (!start && !whynot) ? "No Virtual IP address configured" : NULL;
353 if (start)
354 vrrp_event(r, VRRP_EVENT_STARTUP);
355 else if (whynot)
356 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
357 "Refusing to start Virtual Router: %s",
358 vr->vrid, family2str(r->family), whynot);
359 }
360
361 void vrrp_set_priority(struct vrrp_vrouter *vr, uint8_t priority)
362 {
363 vr->priority = priority;
364 vr->v4->priority = priority;
365 vr->v6->priority = priority;
366 }
367
368 void vrrp_set_advertisement_interval(struct vrrp_vrouter *vr,
369 uint16_t advertisement_interval)
370 {
371 if (vr->advertisement_interval == advertisement_interval)
372 return;
373
374 vr->advertisement_interval = advertisement_interval;
375 vrrp_recalculate_timers(vr->v4);
376 vrrp_recalculate_timers(vr->v6);
377 }
378
379 static bool vrrp_has_ip(struct vrrp_vrouter *vr, struct ipaddr *ip)
380 {
381 struct vrrp_router *r = ip->ipa_type == IPADDR_V4 ? vr->v4 : vr->v6;
382 struct listnode *ln;
383 struct ipaddr *iter;
384
385 for (ALL_LIST_ELEMENTS_RO(r->addrs, ln, iter))
386 if (!memcmp(&iter->ip, &ip->ip, IPADDRSZ(ip)))
387 return true;
388
389 return false;
390 }
391
392 int vrrp_add_ip(struct vrrp_router *r, struct ipaddr *ip)
393 {
394 int af = (ip->ipa_type == IPADDR_V6) ? AF_INET6 : AF_INET;
395
396 assert(r->family == af);
397 assert(!(r->vr->version == 2 && ip->ipa_type == IPADDR_V6));
398
399 if (vrrp_has_ip(r->vr, ip))
400 return 0;
401
402 if (!vrrp_is_owner(r->vr->ifp, ip) && r->is_owner) {
403 char ipbuf[INET6_ADDRSTRLEN];
404
405 inet_ntop(r->family, &ip->ip, ipbuf, sizeof(ipbuf));
406 zlog_err(
407 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
408 "This VRRP router is not the address owner of %s, but is the address owner of other addresses; this config is unsupported.",
409 r->vr->vrid, family2str(r->family), ipbuf);
410 return -1;
411 }
412
413 struct ipaddr *new = XCALLOC(MTYPE_VRRP_IP, sizeof(struct ipaddr));
414
415 *new = *ip;
416 listnode_add(r->addrs, new);
417
418 if (r->fsm.state == VRRP_STATE_MASTER) {
419 switch (r->family) {
420 case AF_INET:
421 vrrp_garp_send(r, &new->ipaddr_v4);
422 break;
423 case AF_INET6:
424 vrrp_ndisc_una_send(r, new);
425 break;
426 }
427 }
428
429 return 0;
430 }
431
432 int vrrp_add_ipv4(struct vrrp_vrouter *vr, struct in_addr v4)
433 {
434 struct ipaddr ip;
435
436 ip.ipa_type = IPADDR_V4;
437 ip.ipaddr_v4 = v4;
438 return vrrp_add_ip(vr->v4, &ip);
439 }
440
441 int vrrp_add_ipv6(struct vrrp_vrouter *vr, struct in6_addr v6)
442 {
443 assert(vr->version != 2);
444
445 struct ipaddr ip;
446
447 ip.ipa_type = IPADDR_V6;
448 ip.ipaddr_v6 = v6;
449 return vrrp_add_ip(vr->v6, &ip);
450 }
451
452 int vrrp_del_ip(struct vrrp_router *r, struct ipaddr *ip)
453 {
454 struct listnode *ln, *nn;
455 struct ipaddr *iter;
456 int ret = 0;
457
458 if (!vrrp_has_ip(r->vr, ip))
459 return 0;
460
461 for (ALL_LIST_ELEMENTS(r->addrs, ln, nn, iter))
462 if (!memcmp(&iter->ip, &ip->ip, IPADDRSZ(ip)))
463 list_delete_node(r->addrs, ln);
464
465 /*
466 * NB: Deleting the last address and then issuing a shutdown will cause
467 * transmission of a priority 0 VRRP Advertisement - as per the RFC -
468 * but it will have no addresses. This is not forbidden in the RFC but
469 * might confuse other implementations.
470 */
471 if (r->addrs->count == 0 && r->fsm.state != VRRP_STATE_INITIALIZE)
472 ret = vrrp_event(r, VRRP_EVENT_SHUTDOWN);
473
474 return ret;
475 }
476
477 int vrrp_del_ipv6(struct vrrp_vrouter *vr, struct in6_addr v6)
478 {
479 struct ipaddr ip;
480
481 ip.ipa_type = IPADDR_V6;
482 ip.ipaddr_v6 = v6;
483 return vrrp_del_ip(vr->v6, &ip);
484 }
485
486 int vrrp_del_ipv4(struct vrrp_vrouter *vr, struct in_addr v4)
487 {
488 struct ipaddr ip;
489
490 ip.ipa_type = IPADDR_V4;
491 ip.ipaddr_v4 = v4;
492 return vrrp_del_ip(vr->v4, &ip);
493 }
494
495
496 /* Creation and destruction ------------------------------------------------ */
497
498 static void vrrp_router_addr_list_del_cb(void *val)
499 {
500 struct ipaddr *ip = val;
501
502 XFREE(MTYPE_VRRP_IP, ip);
503 }
504
505 /*
506 * Search for a suitable macvlan subinterface we can attach to, and if found,
507 * attach to it.
508 *
509 * r
510 * Router to attach to interface
511 *
512 * Returns:
513 * Whether an interface was successfully attached
514 */
515 static bool vrrp_attach_interface(struct vrrp_router *r)
516 {
517 /* Search for existing interface with computed MAC address */
518 struct interface **ifps;
519
520 size_t ifps_cnt = if_lookup_by_hwaddr(
521 r->vmac.octet, sizeof(r->vmac.octet), &ifps, VRF_DEFAULT);
522
523 /*
524 * Filter to only those macvlan interfaces whose parent is the base
525 * interface this VRRP router is configured on.
526 *
527 * If there are still multiple interfaces we just select the first one,
528 * as it should be functionally identical to the others.
529 */
530 unsigned int candidates = 0;
531 struct interface *selection = NULL;
532
533 for (unsigned int i = 0; i < ifps_cnt; i++) {
534 if (ifps[i]->link_ifindex != r->vr->ifp->ifindex)
535 ifps[i] = NULL;
536 else {
537 selection = selection ? selection : ifps[i];
538 candidates++;
539 }
540 }
541
542 if (ifps_cnt)
543 XFREE(MTYPE_TMP, ifps);
544
545 char ethstr[ETHER_ADDR_STRLEN];
546
547 prefix_mac2str(&r->vmac, ethstr, sizeof(ethstr));
548
549 assert(!!selection == !!candidates);
550
551 if (candidates == 0)
552 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
553 "Interface: None (no interface found w/ MAC %s)",
554 r->vr->vrid, family2str(r->family), ethstr);
555 else if (candidates > 1)
556 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
557 "Interface: Multiple interfaces found; using %s",
558 r->vr->vrid, family2str(r->family), selection->name);
559 else
560 zlog_info(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
561 "Interface: %s",
562 r->vr->vrid, family2str(r->family), selection->name);
563
564 r->mvl_ifp = selection;
565
566 return !!r->mvl_ifp;
567 }
568
569 static struct vrrp_router *vrrp_router_create(struct vrrp_vrouter *vr,
570 int family)
571 {
572 struct vrrp_router *r =
573 XCALLOC(MTYPE_VRRP_RTR, sizeof(struct vrrp_router));
574
575 r->family = family;
576 r->sock_rx = -1;
577 r->sock_tx = -1;
578 r->vr = vr;
579 r->addrs = list_new();
580 r->addrs->del = vrrp_router_addr_list_del_cb;
581 r->priority = vr->priority;
582 r->fsm.state = VRRP_STATE_INITIALIZE;
583 vrrp_mac_set(&r->vmac, family == AF_INET6, vr->vrid);
584
585 vrrp_attach_interface(r);
586
587 return r;
588 }
589
590 static void vrrp_router_destroy(struct vrrp_router *r)
591 {
592 if (r->is_active)
593 vrrp_event(r, VRRP_EVENT_SHUTDOWN);
594
595 if (r->sock_rx >= 0)
596 close(r->sock_rx);
597 if (r->sock_tx >= 0)
598 close(r->sock_tx);
599
600 /* FIXME: also delete list elements */
601 list_delete(&r->addrs);
602 XFREE(MTYPE_VRRP_RTR, r);
603 }
604
605 struct vrrp_vrouter *vrrp_vrouter_create(struct interface *ifp, uint8_t vrid,
606 uint8_t version)
607 {
608 struct vrrp_vrouter *vr = vrrp_lookup(ifp, vrid);
609
610 if (vr)
611 return vr;
612
613 if (version != 2 && version != 3)
614 return NULL;
615
616 vr = XCALLOC(MTYPE_VRRP_RTR, sizeof(struct vrrp_vrouter));
617
618 vr->ifp = ifp;
619 vr->version = version;
620 vr->vrid = vrid;
621 vr->priority = vd.priority;
622 vr->preempt_mode = vd.preempt_mode;
623 vr->accept_mode = vd.accept_mode;
624 vr->shutdown = vd.shutdown;
625
626 vr->v4 = vrrp_router_create(vr, AF_INET);
627 vr->v6 = vrrp_router_create(vr, AF_INET6);
628
629 vrrp_set_advertisement_interval(vr, vd.advertisement_interval);
630
631 hash_get(vrrp_vrouters_hash, vr, hash_alloc_intern);
632
633 return vr;
634 }
635
636 void vrrp_vrouter_destroy(struct vrrp_vrouter *vr)
637 {
638 vrrp_router_destroy(vr->v4);
639 vrrp_router_destroy(vr->v6);
640 hash_release(vrrp_vrouters_hash, vr);
641 XFREE(MTYPE_VRRP_RTR, vr);
642 }
643
644 struct vrrp_vrouter *vrrp_lookup(struct interface *ifp, uint8_t vrid)
645 {
646 struct vrrp_vrouter vr;
647
648 vr.vrid = vrid;
649 vr.ifp = ifp;
650
651 return hash_lookup(vrrp_vrouters_hash, &vr);
652 }
653
654 /* Network ----------------------------------------------------------------- */
655
656 /* Forward decls */
657 static void vrrp_change_state(struct vrrp_router *r, int to);
658 static int vrrp_adver_timer_expire(struct thread *thread);
659 static int vrrp_master_down_timer_expire(struct thread *thread);
660
661 /*
662 * Finds the first connected address of the appropriate family on a VRRP
663 * router's interface and binds the Tx socket of the VRRP router to that
664 * address.
665 *
666 * Also sets src field of vrrp_router.
667 *
668 * r
669 * VRRP router to operate on
670 *
671 * Returns:
672 * 0 on success
673 * -1 on failure
674 */
675 static int vrrp_bind_to_primary_connected(struct vrrp_router *r)
676 {
677 char ipstr[INET6_ADDRSTRLEN];
678 struct interface *ifp;
679
680 /*
681 * A slight quirk: the RFC specifies that advertisements under IPv6 must
682 * be transmitted using the link local address of the source interface
683 */
684 ifp = r->family == AF_INET ? r->vr->ifp : r->mvl_ifp;
685
686 struct listnode *ln;
687 struct connected *c = NULL;
688
689 for (ALL_LIST_ELEMENTS_RO(ifp->connected, ln, c))
690 if (c->address->family == r->family) {
691 if (r->family == AF_INET6
692 && IN6_IS_ADDR_LINKLOCAL(&c->address->u.prefix6))
693 break;
694 else if (r->family == AF_INET)
695 break;
696 }
697
698 if (c == NULL) {
699 zlog_err(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
700 "Failed to find address to bind on %s",
701 r->vr->vrid, family2str(r->family), ifp->name);
702 return -1;
703 }
704
705 union sockunion su;
706
707 memset(&su, 0x00, sizeof(su));
708
709 switch (r->family) {
710 case AF_INET:
711 r->src.ipa_type = IPADDR_V4;
712 r->src.ipaddr_v4 = c->address->u.prefix4;
713 su.sin.sin_family = AF_INET;
714 su.sin.sin_addr = c->address->u.prefix4;
715 break;
716 case AF_INET6:
717 r->src.ipa_type = IPADDR_V6;
718 r->src.ipaddr_v6 = c->address->u.prefix6;
719 su.sin6.sin6_family = AF_INET6;
720 su.sin6.sin6_scope_id = ifp->ifindex;
721 su.sin6.sin6_addr = c->address->u.prefix6;
722 break;
723 }
724
725 int ret = 0;
726
727 sockopt_reuseaddr(r->sock_tx);
728 if (bind(r->sock_tx, (const struct sockaddr *)&su, sizeof(su)) < 0) {
729 zlog_err(
730 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
731 "Failed to bind Tx socket to primary IP address %s: %s",
732 r->vr->vrid, family2str(r->family),
733 inet_ntop(r->family,
734 (const void *)&c->address->u.prefix, ipstr,
735 sizeof(ipstr)),
736 safe_strerror(errno));
737 ret = -1;
738 } else {
739 DEBUGD(&vrrp_dbg_sock,
740 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
741 "Bound Tx socket to primary IP address %s",
742 r->vr->vrid, family2str(r->family),
743 inet_ntop(r->family, (const void *)&c->address->u.prefix,
744 ipstr, sizeof(ipstr)));
745 }
746
747 return ret;
748 }
749
750
751 /*
752 * Create and multicast a VRRP ADVERTISEMENT message.
753 *
754 * r
755 * VRRP Router for which to send ADVERTISEMENT
756 */
757 static void vrrp_send_advertisement(struct vrrp_router *r)
758 {
759 struct vrrp_pkt *pkt;
760 ssize_t pktsz;
761 struct ipaddr *addrs[r->addrs->count];
762 union sockunion dest;
763
764 if (r->src.ipa_type == IPADDR_NONE
765 && vrrp_bind_to_primary_connected(r) < 0)
766 return;
767
768 list_to_array(r->addrs, (void **)addrs, r->addrs->count);
769
770 pktsz = vrrp_pkt_adver_build(&pkt, &r->src, r->vr->version, r->vr->vrid,
771 r->priority, r->vr->advertisement_interval,
772 r->addrs->count, (struct ipaddr **)&addrs);
773
774 if (DEBUG_MODE_CHECK(&vrrp_dbg_pkt, DEBUG_MODE_ALL))
775 zlog_hexdump(pkt, (size_t)pktsz);
776
777 const char *group = r->family == AF_INET ? VRRP_MCASTV4_GROUP_STR
778 : VRRP_MCASTV6_GROUP_STR;
779 (void)str2sockunion(group, &dest);
780
781 ssize_t sent = sendto(r->sock_tx, pkt, (size_t)pktsz, 0, &dest.sa,
782 sockunion_sizeof(&dest));
783
784 vrrp_pkt_free(pkt);
785
786 if (sent < 0) {
787 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
788 "Failed to send VRRP Advertisement: %s",
789 r->vr->vrid, family2str(r->family),
790 safe_strerror(errno));
791 } else {
792 ++r->stats.adver_tx_cnt;
793 }
794 }
795
796 /*
797 * Receive and parse VRRP advertisement.
798 *
799 * By the time we get here all fields have been validated for basic correctness
800 * and the packet is a valid VRRP packet.
801 *
802 * However, we have not validated whether the VRID is correct for this virtual
803 * router, nor whether the priority is correct (i.e. is not 255 when we are the
804 * address owner), nor whether the advertisement interval equals our own
805 * configured value (this check is only performed in VRRPv2).
806 *
807 * r
808 * VRRP Router associated with the socket this advertisement was received on
809 *
810 * src
811 * Source address of sender
812 *
813 * pkt
814 * The advertisement they sent
815 *
816 * pktsize
817 * Size of advertisement
818 *
819 * Returns:
820 * -1 if advertisement is invalid
821 * 0 otherwise
822 */
823 static int vrrp_recv_advertisement(struct vrrp_router *r, struct ipaddr *src,
824 struct vrrp_pkt *pkt, size_t pktsize)
825 {
826 char sipstr[INET6_ADDRSTRLEN];
827 char dipstr[INET6_ADDRSTRLEN];
828
829 ipaddr2str(src, sipstr, sizeof(sipstr));
830 ipaddr2str(&r->src, dipstr, sizeof(dipstr));
831
832 char dumpbuf[BUFSIZ];
833
834 vrrp_pkt_adver_dump(dumpbuf, sizeof(dumpbuf), pkt);
835 DEBUGD(&vrrp_dbg_proto,
836 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
837 "Received VRRP Advertisement from %s:\n%s",
838 r->vr->vrid, family2str(r->family), sipstr, dumpbuf);
839
840 /* Check that VRID matches our configured VRID */
841 if (pkt->hdr.vrid != r->vr->vrid) {
842 DEBUGD(&vrrp_dbg_proto,
843 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
844 "Datagram invalid: Advertisement contains VRID %" PRIu8
845 " which does not match our instance",
846 r->vr->vrid, family2str(r->family), pkt->hdr.vrid);
847 return -1;
848 }
849
850 /* Verify that we are not the IPvX address owner */
851 if (r->is_owner) {
852 DEBUGD(&vrrp_dbg_proto,
853 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
854 "Datagram invalid: Received advertisement but we are the address owner",
855 r->vr->vrid, family2str(r->family));
856 return -1;
857 }
858
859 /* If v2, verify that adver time matches ours */
860 bool adveq = (pkt->hdr.v2.adver_int
861 == MAX(r->vr->advertisement_interval / 100, 1));
862 if (r->vr->version == 2 && !adveq) {
863 DEBUGD(&vrrp_dbg_proto,
864 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
865 "Datagram invalid: Received advertisement with advertisement interval %" PRIu8
866 " unequal to our configured value %u",
867 r->vr->vrid, family2str(r->family),
868 pkt->hdr.v2.adver_int,
869 MAX(r->vr->advertisement_interval / 100, 1));
870 return -1;
871 }
872
873
874 /* Check that # IPs received matches our # configured IPs */
875 if (pkt->hdr.naddr != r->addrs->count)
876 DEBUGD(&vrrp_dbg_proto,
877 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
878 "Datagram has %" PRIu8
879 " addresses, but this VRRP instance has %u",
880 r->vr->vrid, family2str(r->family), pkt->hdr.naddr,
881 r->addrs->count);
882
883 ++r->stats.adver_rx_cnt;
884
885 int addrcmp;
886
887 switch (r->fsm.state) {
888 case VRRP_STATE_MASTER:
889 addrcmp = memcmp(&src->ip, &r->src.ip, IPADDRSZ(src));
890
891 if (pkt->hdr.priority == 0) {
892 vrrp_send_advertisement(r);
893 THREAD_OFF(r->t_adver_timer);
894 thread_add_timer_msec(
895 master, vrrp_adver_timer_expire, r,
896 r->vr->advertisement_interval * 10,
897 &r->t_adver_timer);
898 } else if (pkt->hdr.priority > r->priority
899 || ((pkt->hdr.priority == r->priority)
900 && addrcmp > 0)) {
901 zlog_info(
902 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
903 "Received advertisement from %s w/ priority %" PRIu8
904 "; switching to Backup",
905 r->vr->vrid, family2str(r->family), sipstr,
906 pkt->hdr.priority);
907 THREAD_OFF(r->t_adver_timer);
908 if (r->vr->version == 3) {
909 r->master_adver_interval =
910 htons(pkt->hdr.v3.adver_int);
911 }
912 vrrp_recalculate_timers(r);
913 THREAD_OFF(r->t_master_down_timer);
914 thread_add_timer_msec(master,
915 vrrp_master_down_timer_expire, r,
916 r->master_down_interval * 10,
917 &r->t_master_down_timer);
918 vrrp_change_state(r, VRRP_STATE_BACKUP);
919 } else {
920 /* Discard advertisement */
921 DEBUGD(&vrrp_dbg_proto,
922 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
923 "Discarding advertisement from %s (%" PRIu8
924 " <= %" PRIu8 " & %s <= %s)",
925 r->vr->vrid, family2str(r->family), sipstr,
926 pkt->hdr.priority, r->priority, sipstr, dipstr);
927 }
928 break;
929 case VRRP_STATE_BACKUP:
930 if (pkt->hdr.priority == 0) {
931 THREAD_OFF(r->t_master_down_timer);
932 thread_add_timer_msec(
933 master, vrrp_master_down_timer_expire, r,
934 r->skew_time * 10, &r->t_master_down_timer);
935 } else if (r->vr->preempt_mode == false
936 || pkt->hdr.priority >= r->priority) {
937 if (r->vr->version == 3) {
938 r->master_adver_interval =
939 ntohs(pkt->hdr.v3.adver_int);
940 }
941 vrrp_recalculate_timers(r);
942 THREAD_OFF(r->t_master_down_timer);
943 thread_add_timer_msec(master,
944 vrrp_master_down_timer_expire, r,
945 r->master_down_interval * 10,
946 &r->t_master_down_timer);
947 } else if (r->vr->preempt_mode == true
948 && pkt->hdr.priority < r->priority) {
949 /* Discard advertisement */
950 DEBUGD(&vrrp_dbg_proto,
951 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
952 "Discarding advertisement from %s (%" PRIu8
953 " < %" PRIu8 " & preempt = true)",
954 r->vr->vrid, family2str(r->family), sipstr,
955 pkt->hdr.priority, r->priority);
956 }
957 break;
958 case VRRP_STATE_INITIALIZE:
959 zlog_err(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
960 "Received ADVERTISEMENT in state %s; this is a bug",
961 r->vr->vrid, family2str(r->family),
962 vrrp_state_names[r->fsm.state]);
963 break;
964 }
965
966 return 0;
967 }
968
969 /*
970 * Read and process next IPvX datagram.
971 */
972 static int vrrp_read(struct thread *thread)
973 {
974 struct vrrp_router *r = thread->arg;
975
976 struct vrrp_pkt *pkt;
977 ssize_t pktsize;
978 ssize_t nbytes;
979 bool resched;
980 char errbuf[BUFSIZ];
981 struct sockaddr_storage sa;
982 uint8_t control[64];
983 struct ipaddr src = {};
984
985 struct msghdr m = {};
986 struct iovec iov;
987
988 iov.iov_base = r->ibuf;
989 iov.iov_len = sizeof(r->ibuf);
990 m.msg_name = &sa;
991 m.msg_namelen = sizeof(sa);
992 m.msg_iov = &iov;
993 m.msg_iovlen = 1;
994 m.msg_control = control;
995 m.msg_controllen = sizeof(control);
996
997 nbytes = recvmsg(r->sock_rx, &m, MSG_DONTWAIT);
998
999 if ((nbytes < 0 && ERRNO_IO_RETRY(errno))) {
1000 resched = true;
1001 goto done;
1002 } else if (nbytes <= 0) {
1003 vrrp_event(r, VRRP_EVENT_SHUTDOWN);
1004 resched = false;
1005 goto done;
1006 }
1007
1008 if (DEBUG_MODE_CHECK(&vrrp_dbg_pkt, DEBUG_MODE_ALL)) {
1009 DEBUGD(&vrrp_dbg_pkt,
1010 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1011 "Datagram rx: ",
1012 r->vr->vrid, family2str(r->family));
1013 zlog_hexdump(r->ibuf, nbytes);
1014 }
1015
1016 pktsize = vrrp_pkt_parse_datagram(r->family, r->vr->version, &m, nbytes,
1017 &src, &pkt, errbuf, sizeof(errbuf));
1018
1019 if (pktsize < 0)
1020 DEBUGD(&vrrp_dbg_pkt,
1021 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1022 "Datagram invalid: %s",
1023 r->vr->vrid, family2str(r->family), errbuf);
1024 else
1025 vrrp_recv_advertisement(r, &src, pkt, pktsize);
1026
1027 resched = true;
1028
1029 done:
1030 memset(r->ibuf, 0x00, sizeof(r->ibuf));
1031
1032 if (resched)
1033 thread_add_read(master, vrrp_read, r, r->sock_rx, &r->t_read);
1034
1035 return 0;
1036 }
1037
1038 /*
1039 * Creates and configures VRRP router sockets.
1040 *
1041 * This function:
1042 * - Creates two sockets, one for Tx, one for Rx
1043 * - Joins the Rx socket to the appropriate VRRP multicast group
1044 * - Sets the Tx socket to set the TTL (v4) or Hop Limit (v6) field to 255 for
1045 * all transmitted IPvX packets
1046 * - Requests the kernel to deliver IPv6 header values needed to validate VRRP
1047 * packets
1048 *
1049 * If any of the above fail, the sockets are closed. The only exception is if
1050 * the TTL / Hop Limit settings fail; these are logged, but configuration
1051 * proceeds.
1052 *
1053 * The first connected address on the Virtual Router's interface is used as the
1054 * interface address.
1055 *
1056 * r
1057 * VRRP Router for which to create listen socket
1058 *
1059 * Returns:
1060 * 0 on success
1061 * -1 on failure
1062 */
1063 static int vrrp_socket(struct vrrp_router *r)
1064 {
1065 int ret;
1066 bool failed = false;
1067
1068 frr_with_privs(&vrrp_privs) {
1069 r->sock_rx = socket(r->family, SOCK_RAW, IPPROTO_VRRP);
1070 r->sock_tx = socket(r->family, SOCK_RAW, IPPROTO_VRRP);
1071 }
1072
1073 if (r->sock_rx < 0 || r->sock_tx < 0) {
1074 const char *rxtx = r->sock_rx < 0 ? "Rx" : "Tx";
1075
1076 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1077 "Can't create VRRP %s socket",
1078 r->vr->vrid, family2str(r->family), rxtx);
1079 failed = true;
1080 goto done;
1081 }
1082
1083 /* Configure sockets */
1084 if (r->family == AF_INET) {
1085 /* Set Tx socket to always Tx with TTL set to 255 */
1086 int ttl = 255;
1087
1088 ret = setsockopt(r->sock_tx, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
1089 sizeof(ttl));
1090 if (ret < 0) {
1091 zlog_warn(
1092 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1093 "Failed to set outgoing multicast TTL count to 255; RFC 5798 compliant implementations will drop our packets",
1094 r->vr->vrid, family2str(r->family));
1095 }
1096
1097 /* Set Tx socket DSCP byte */
1098 setsockopt_ipv4_tos(r->sock_tx, IPTOS_PREC_INTERNETCONTROL);
1099
1100 /* Turn off multicast loop on Tx */
1101 setsockopt_ipv4_multicast_loop(r->sock_tx, 0);
1102
1103 /* Bind Rx socket to exact interface */
1104 frr_with_privs(&vrrp_privs) {
1105 ret = setsockopt(r->sock_rx, SOL_SOCKET,
1106 SO_BINDTODEVICE, r->vr->ifp->name,
1107 strlen(r->vr->ifp->name));
1108 }
1109 if (ret) {
1110 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1111 "Failed to bind Rx socket to %s: %s",
1112 r->vr->vrid, family2str(r->family),
1113 r->vr->ifp->name, safe_strerror(errno));
1114 failed = true;
1115 goto done;
1116 }
1117 DEBUGD(&vrrp_dbg_sock,
1118 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1119 "Bound Rx socket to %s",
1120 r->vr->vrid, family2str(r->family), r->vr->ifp->name);
1121
1122 /* Bind Rx socket to v4 multicast address */
1123 struct sockaddr_in sa = {0};
1124
1125 sa.sin_family = AF_INET;
1126 sa.sin_addr.s_addr = htonl(VRRP_MCASTV4_GROUP);
1127 if (bind(r->sock_rx, (struct sockaddr *)&sa, sizeof(sa))) {
1128 zlog_err(
1129 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1130 "Failed to bind Rx socket to VRRP multicast group: %s",
1131 r->vr->vrid, family2str(r->family),
1132 safe_strerror(errno));
1133 failed = true;
1134 goto done;
1135 }
1136 DEBUGD(&vrrp_dbg_sock,
1137 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1138 "Bound Rx socket to VRRP multicast group",
1139 r->vr->vrid, family2str(r->family));
1140
1141 /* Join Rx socket to VRRP IPv4 multicast group */
1142 assert(listhead(r->vr->ifp->connected));
1143 struct connected *c = listhead(r->vr->ifp->connected)->data;
1144 struct in_addr v4 = c->address->u.prefix4;
1145
1146 ret = setsockopt_ipv4_multicast(r->sock_rx, IP_ADD_MEMBERSHIP,
1147 v4, htonl(VRRP_MCASTV4_GROUP),
1148 r->vr->ifp->ifindex);
1149 if (ret < 0) {
1150 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID
1151 "Failed to join VRRP %s multicast group",
1152 r->vr->vrid, family2str(r->family));
1153 failed = true;
1154 goto done;
1155 }
1156 DEBUGD(&vrrp_dbg_sock,
1157 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1158 "Joined VRRP multicast group",
1159 r->vr->vrid, family2str(r->family));
1160
1161 /* Set outgoing interface for advertisements */
1162 struct ip_mreqn mreqn = {};
1163
1164 mreqn.imr_ifindex = r->mvl_ifp->ifindex;
1165 ret = setsockopt(r->sock_tx, IPPROTO_IP, IP_MULTICAST_IF,
1166 (void *)&mreqn, sizeof(mreqn));
1167 if (ret < 0) {
1168 zlog_warn(
1169 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1170 "Could not set %s as outgoing multicast interface",
1171 r->vr->vrid, family2str(r->family),
1172 r->mvl_ifp->name);
1173 failed = true;
1174 goto done;
1175 }
1176 DEBUGD(&vrrp_dbg_sock,
1177 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1178 "Set %s as outgoing multicast interface",
1179 r->vr->vrid, family2str(r->family), r->mvl_ifp->name);
1180
1181 /* Select and bind source address */
1182 if (vrrp_bind_to_primary_connected(r) < 0) {
1183 failed = true;
1184 goto done;
1185 }
1186
1187 } else if (r->family == AF_INET6) {
1188 /* Always transmit IPv6 packets with hop limit set to 255 */
1189 ret = setsockopt_ipv6_multicast_hops(r->sock_tx, 255);
1190 if (ret < 0) {
1191 zlog_warn(
1192 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1193 "Failed to set outgoing multicast hop count to 255; RFC 5798 compliant implementations will drop our packets",
1194 r->vr->vrid, family2str(r->family));
1195 }
1196
1197 /* Set Tx socket DSCP byte */
1198 setsockopt_ipv6_tclass(r->sock_tx, IPTOS_PREC_INTERNETCONTROL);
1199
1200 /* Request hop limit delivery */
1201 setsockopt_ipv6_hoplimit(r->sock_rx, 1);
1202 if (ret < 0) {
1203 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1204 "Failed to request IPv6 Hop Limit delivery",
1205 r->vr->vrid, family2str(r->family));
1206 failed = true;
1207 goto done;
1208 }
1209
1210 /* Turn off multicast loop on Tx */
1211 setsockopt_ipv6_multicast_loop(r->sock_tx, 0);
1212
1213 /* Bind Rx socket to exact interface */
1214 frr_with_privs(&vrrp_privs) {
1215 ret = setsockopt(r->sock_rx, SOL_SOCKET,
1216 SO_BINDTODEVICE, r->vr->ifp->name,
1217 strlen(r->vr->ifp->name));
1218 }
1219 if (ret) {
1220 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1221 "Failed to bind Rx socket to %s: %s",
1222 r->vr->vrid, family2str(r->family),
1223 r->vr->ifp->name, safe_strerror(errno));
1224 failed = true;
1225 goto done;
1226 }
1227 DEBUGD(&vrrp_dbg_sock,
1228 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1229 "Bound Rx socket to %s",
1230 r->vr->vrid, family2str(r->family), r->vr->ifp->name);
1231
1232 /* Bind Rx socket to v6 multicast address */
1233 struct sockaddr_in6 sa = {0};
1234
1235 sa.sin6_family = AF_INET6;
1236 inet_pton(AF_INET6, VRRP_MCASTV6_GROUP_STR, &sa.sin6_addr);
1237 if (bind(r->sock_rx, (struct sockaddr *)&sa, sizeof(sa))) {
1238 zlog_err(
1239 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1240 "Failed to bind Rx socket to VRRP multicast group: %s",
1241 r->vr->vrid, family2str(r->family),
1242 safe_strerror(errno));
1243 failed = true;
1244 goto done;
1245 }
1246 DEBUGD(&vrrp_dbg_sock,
1247 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1248 "Bound Rx socket to VRRP multicast group",
1249 r->vr->vrid, family2str(r->family));
1250
1251 /* Join VRRP IPv6 multicast group */
1252 struct ipv6_mreq mreq;
1253
1254 inet_pton(AF_INET6, VRRP_MCASTV6_GROUP_STR,
1255 &mreq.ipv6mr_multiaddr);
1256 mreq.ipv6mr_interface = r->vr->ifp->ifindex;
1257 ret = setsockopt(r->sock_rx, IPPROTO_IPV6, IPV6_JOIN_GROUP,
1258 &mreq, sizeof(mreq));
1259 if (ret < 0) {
1260 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1261 "Failed to join VRRP multicast group",
1262 r->vr->vrid, family2str(r->family));
1263 failed = true;
1264 goto done;
1265 }
1266 DEBUGD(&vrrp_dbg_sock,
1267 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1268 "Joined VRRP multicast group",
1269 r->vr->vrid, family2str(r->family));
1270
1271 /* Set outgoing interface for advertisements */
1272 ret = setsockopt(r->sock_tx, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1273 &r->mvl_ifp->ifindex, sizeof(ifindex_t));
1274 if (ret < 0) {
1275 zlog_warn(
1276 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1277 "Could not set %s as outgoing multicast interface",
1278 r->vr->vrid, family2str(r->family),
1279 r->mvl_ifp->name);
1280 failed = true;
1281 goto done;
1282 }
1283 DEBUGD(&vrrp_dbg_sock,
1284 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1285 "Set %s as outgoing multicast interface",
1286 r->vr->vrid, family2str(r->family), r->mvl_ifp->name);
1287 }
1288
1289 done:
1290 ret = 0;
1291 if (failed) {
1292 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1293 "Failed to initialize VRRP router",
1294 r->vr->vrid, family2str(r->family));
1295 if (r->sock_rx >= 0) {
1296 close(r->sock_rx);
1297 r->sock_rx = -1;
1298 }
1299 if (r->sock_tx >= 0) {
1300 close(r->sock_tx);
1301 r->sock_tx = -1;
1302 }
1303 ret = -1;
1304 }
1305
1306 return ret;
1307 }
1308
1309
1310 /* State machine ----------------------------------------------------------- */
1311
1312 DEFINE_HOOK(vrrp_change_state_hook, (struct vrrp_router *r, int to), (r, to));
1313
1314 /*
1315 * Handle any necessary actions during state change to MASTER state.
1316 *
1317 * r
1318 * VRRP Router to operate on
1319 */
1320 static void vrrp_change_state_master(struct vrrp_router *r)
1321 {
1322 /* Enable ND Router Advertisements */
1323 if (r->family == AF_INET6)
1324 vrrp_zebra_radv_set(r, true);
1325
1326 /* Set protodown off */
1327 vrrp_zclient_send_interface_protodown(r->mvl_ifp, false);
1328
1329 /*
1330 * If protodown is already off, we can send our stuff, otherwise we
1331 * have to delay until the interface is all the way up
1332 */
1333 if (if_is_operative(r->mvl_ifp)) {
1334 vrrp_send_advertisement(r);
1335
1336 if (r->family == AF_INET)
1337 vrrp_garp_send_all(r);
1338 else if (r->family == AF_INET6)
1339 vrrp_ndisc_una_send_all(r);
1340 } else {
1341 DEBUGD(&vrrp_dbg_proto,
1342 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1343 "Delaying VRRP advertisement until interface is up",
1344 r->vr->vrid, family2str(r->family));
1345 r->advert_pending = true;
1346
1347 if (r->family == AF_INET) {
1348 DEBUGD(&vrrp_dbg_proto,
1349 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1350 "Delaying VRRP gratuitous ARPs until interface is up",
1351 r->vr->vrid, family2str(r->family));
1352 r->garp_pending = true;
1353 } else if (r->family == AF_INET6) {
1354 DEBUGD(&vrrp_dbg_proto,
1355 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1356 "Delaying VRRP unsolicited neighbor advertisement until interface is up",
1357 r->vr->vrid, family2str(r->family));
1358 r->ndisc_pending = true;
1359 }
1360 }
1361 }
1362
1363 /*
1364 * Handle any necessary actions during state change to BACKUP state.
1365 *
1366 * r
1367 * Virtual Router to operate on
1368 */
1369 static void vrrp_change_state_backup(struct vrrp_router *r)
1370 {
1371 /* Disable ND Router Advertisements */
1372 if (r->family == AF_INET6)
1373 vrrp_zebra_radv_set(r, false);
1374
1375 /* Disable Adver_Timer */
1376 THREAD_OFF(r->t_adver_timer);
1377
1378 r->advert_pending = false;
1379 r->garp_pending = false;
1380 r->ndisc_pending = false;
1381 memset(&r->src, 0x00, sizeof(r->src));
1382
1383 vrrp_zclient_send_interface_protodown(r->mvl_ifp, true);
1384 }
1385
1386 /*
1387 * Handle any necessary actions during state change to INITIALIZE state.
1388 *
1389 * This is not called for initial startup, only when transitioning from MASTER
1390 * or BACKUP.
1391 *
1392 * r
1393 * VRRP Router to operate on
1394 */
1395 static void vrrp_change_state_initialize(struct vrrp_router *r)
1396 {
1397 r->master_adver_interval = 0;
1398 vrrp_recalculate_timers(r);
1399
1400 r->advert_pending = false;
1401 r->garp_pending = false;
1402 r->ndisc_pending = false;
1403
1404 /* Disable ND Router Advertisements */
1405 if (r->family == AF_INET6)
1406 vrrp_zebra_radv_set(r, false);
1407 }
1408
1409 void (*vrrp_change_state_handlers[])(struct vrrp_router *vr) = {
1410 [VRRP_STATE_MASTER] = vrrp_change_state_master,
1411 [VRRP_STATE_BACKUP] = vrrp_change_state_backup,
1412 [VRRP_STATE_INITIALIZE] = vrrp_change_state_initialize,
1413 };
1414
1415 /*
1416 * Change Virtual Router FSM position. Handles transitional actions and calls
1417 * any subscribers to the state change hook.
1418 *
1419 * r
1420 * Virtual Router for which to change state
1421 *
1422 * to
1423 * State to change to
1424 */
1425 static void vrrp_change_state(struct vrrp_router *r, int to)
1426 {
1427 if (r->fsm.state == to)
1428 return;
1429
1430 /* Call our handlers, then any subscribers */
1431 vrrp_change_state_handlers[to](r);
1432 hook_call(vrrp_change_state_hook, r, to);
1433 zlog_info(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM "%s -> %s",
1434 r->vr->vrid, family2str(r->family),
1435 vrrp_state_names[r->fsm.state], vrrp_state_names[to]);
1436 r->fsm.state = to;
1437
1438 ++r->stats.trans_cnt;
1439 }
1440
1441 /*
1442 * Called when Adver_Timer expires.
1443 */
1444 static int vrrp_adver_timer_expire(struct thread *thread)
1445 {
1446 struct vrrp_router *r = thread->arg;
1447
1448 DEBUGD(&vrrp_dbg_proto,
1449 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1450 "Adver_Timer expired",
1451 r->vr->vrid, family2str(r->family));
1452
1453 if (r->fsm.state == VRRP_STATE_MASTER) {
1454 /* Send an ADVERTISEMENT */
1455 vrrp_send_advertisement(r);
1456
1457 /* Reset the Adver_Timer to Advertisement_Interval */
1458 thread_add_timer_msec(master, vrrp_adver_timer_expire, r,
1459 r->vr->advertisement_interval * 10,
1460 &r->t_adver_timer);
1461 } else {
1462 zlog_err(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1463 "Adver_Timer expired in state '%s'; this is a bug",
1464 r->vr->vrid, family2str(r->family),
1465 vrrp_state_names[r->fsm.state]);
1466 }
1467
1468 return 0;
1469 }
1470
1471 /*
1472 * Called when Master_Down_Timer expires.
1473 */
1474 static int vrrp_master_down_timer_expire(struct thread *thread)
1475 {
1476 struct vrrp_router *r = thread->arg;
1477
1478 zlog_info(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1479 "Master_Down_Timer expired",
1480 r->vr->vrid, family2str(r->family));
1481
1482 thread_add_timer_msec(master, vrrp_adver_timer_expire, r,
1483 r->vr->advertisement_interval * 10,
1484 &r->t_adver_timer);
1485 vrrp_change_state(r, VRRP_STATE_MASTER);
1486
1487 return 0;
1488 }
1489
1490 /*
1491 * Event handler for Startup event.
1492 *
1493 * Creates sockets, sends advertisements and ARP requests, starts timers,
1494 * and transitions the Virtual Router to either Master or Backup states.
1495 *
1496 * This function will also initialize the program's global ARP subsystem if it
1497 * has not yet been initialized.
1498 *
1499 * r
1500 * VRRP Router on which to apply Startup event
1501 *
1502 * Returns:
1503 * < 0 if the session socket could not be created, or the state is not
1504 * Initialize
1505 * 0 on success
1506 */
1507 static int vrrp_startup(struct vrrp_router *r)
1508 {
1509 /* May only be called when the state is Initialize */
1510 if (r->fsm.state != VRRP_STATE_INITIALIZE)
1511 return -1;
1512
1513 /* Must have a valid macvlan interface available */
1514 if (r->mvl_ifp == NULL && !vrrp_attach_interface(r)) {
1515 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1516 "No appropriate interface found",
1517 r->vr->vrid, family2str(r->family));
1518 return -1;
1519 }
1520
1521 /* Initialize global gratuitous ARP socket if necessary */
1522 if (r->family == AF_INET && !vrrp_garp_is_init())
1523 vrrp_garp_init();
1524 if (r->family == AF_INET6 && !vrrp_ndisc_is_init())
1525 vrrp_ndisc_init();
1526
1527 /* Create socket */
1528 if (r->sock_rx < 0 || r->sock_tx < 0) {
1529 int ret = vrrp_socket(r);
1530
1531 if (ret < 0 || r->sock_tx < 0 || r->sock_rx < 0)
1532 return ret;
1533 }
1534
1535 /* Schedule listener */
1536 thread_add_read(master, vrrp_read, r, r->sock_rx, &r->t_read);
1537
1538 /* Configure effective priority */
1539 assert(listhead(r->addrs));
1540 struct ipaddr *primary = (struct ipaddr *)listhead(r->addrs)->data;
1541 char ipbuf[INET6_ADDRSTRLEN];
1542
1543 inet_ntop(r->family, &primary->ip.addr, ipbuf, sizeof(ipbuf));
1544
1545 if (r->vr->priority == VRRP_PRIO_MASTER
1546 || vrrp_is_owner(r->vr->ifp, primary)) {
1547 r->priority = VRRP_PRIO_MASTER;
1548 vrrp_recalculate_timers(r);
1549
1550 zlog_info(
1551 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1552 "%s has priority set to 255 or owns primary Virtual Router IP %s; electing self as Master",
1553 r->vr->vrid, family2str(r->family), r->vr->ifp->name,
1554 ipbuf);
1555 }
1556
1557 if (r->priority == VRRP_PRIO_MASTER) {
1558 thread_add_timer_msec(master, vrrp_adver_timer_expire, r,
1559 r->vr->advertisement_interval * 10,
1560 &r->t_adver_timer);
1561 vrrp_change_state(r, VRRP_STATE_MASTER);
1562 } else {
1563 r->master_adver_interval = r->vr->advertisement_interval;
1564 vrrp_recalculate_timers(r);
1565 thread_add_timer_msec(master, vrrp_master_down_timer_expire, r,
1566 r->master_down_interval * 10,
1567 &r->t_master_down_timer);
1568 vrrp_change_state(r, VRRP_STATE_BACKUP);
1569 }
1570
1571 r->is_active = true;
1572
1573 return 0;
1574 }
1575
1576 /*
1577 * Shuts down a Virtual Router and transitions it to Initialize.
1578 *
1579 * This call must be idempotent; it is safe to call multiple times on the same
1580 * VRRP Router.
1581 */
1582 static int vrrp_shutdown(struct vrrp_router *r)
1583 {
1584 uint8_t saved_prio;
1585
1586 switch (r->fsm.state) {
1587 case VRRP_STATE_MASTER:
1588 /* Send an ADVERTISEMENT with Priority = 0 */
1589 saved_prio = r->priority;
1590 r->priority = 0;
1591 vrrp_send_advertisement(r);
1592 r->priority = saved_prio;
1593 break;
1594 case VRRP_STATE_BACKUP:
1595 break;
1596 case VRRP_STATE_INITIALIZE:
1597 DEBUGD(&vrrp_dbg_proto,
1598 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1599 "Received '%s' event in '%s' state; ignoring",
1600 r->vr->vrid, family2str(r->family),
1601 vrrp_event_names[VRRP_EVENT_SHUTDOWN],
1602 vrrp_state_names[VRRP_STATE_INITIALIZE]);
1603 break;
1604 }
1605
1606 /* Cancel all timers */
1607 THREAD_OFF(r->t_adver_timer);
1608 THREAD_OFF(r->t_master_down_timer);
1609 THREAD_OFF(r->t_read);
1610 THREAD_OFF(r->t_write);
1611
1612 /* Protodown macvlan */
1613 vrrp_zclient_send_interface_protodown(r->mvl_ifp, true);
1614
1615 /* Throw away our source address */
1616 memset(&r->src, 0x00, sizeof(r->src));
1617
1618 if (r->sock_rx > 0) {
1619 close(r->sock_rx);
1620 r->sock_rx = -1;
1621 }
1622 if (r->sock_tx > 0) {
1623 close(r->sock_tx);
1624 r->sock_tx = -1;
1625 }
1626
1627 vrrp_change_state(r, VRRP_STATE_INITIALIZE);
1628
1629 r->is_active = false;
1630
1631 return 0;
1632 }
1633
1634 static int (*vrrp_event_handlers[])(struct vrrp_router *r) = {
1635 [VRRP_EVENT_STARTUP] = vrrp_startup,
1636 [VRRP_EVENT_SHUTDOWN] = vrrp_shutdown,
1637 };
1638
1639 /*
1640 * Spawn a VRRP FSM event on a VRRP Router.
1641 *
1642 * vr
1643 * VRRP Router on which to spawn event
1644 *
1645 * event
1646 * The event to spawn
1647 *
1648 * Returns:
1649 * -1 on failure
1650 * 0 otherwise
1651 */
1652 int vrrp_event(struct vrrp_router *r, int event)
1653 {
1654 zlog_info(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM "'%s' event",
1655 r->vr->vrid, family2str(r->family), vrrp_event_names[event]);
1656 return vrrp_event_handlers[event](r);
1657 }
1658
1659
1660 /* Autoconfig -------------------------------------------------------------- */
1661
1662 /*
1663 * Set the configured addresses for this VRRP instance to exactly the addresses
1664 * present on its macvlan subinterface(s).
1665 *
1666 * vr
1667 * VRRP router to act on
1668 */
1669 static void vrrp_autoconfig_autoaddrupdate(struct vrrp_router *r)
1670 {
1671 struct listnode *ln;
1672 struct connected *c = NULL;
1673 bool is_v6_ll;
1674 char ipbuf[INET6_ADDRSTRLEN];
1675
1676 if (!r->mvl_ifp)
1677 return;
1678
1679 DEBUGD(&vrrp_dbg_auto,
1680 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1681 "Setting Virtual IP list to match IPv4 addresses on %s",
1682 r->vr->vrid, family2str(r->family), r->mvl_ifp->name);
1683 for (ALL_LIST_ELEMENTS_RO(r->mvl_ifp->connected, ln, c)) {
1684 is_v6_ll = (c->address->family == AF_INET6
1685 && IN6_IS_ADDR_LINKLOCAL(&c->address->u.prefix6));
1686 if (c->address->family == r->family && !is_v6_ll) {
1687 inet_ntop(r->family, &c->address->u.prefix, ipbuf,
1688 sizeof(ipbuf));
1689 DEBUGD(&vrrp_dbg_auto,
1690 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1691 "Adding %s",
1692 r->vr->vrid, family2str(r->family), ipbuf);
1693 if (r->family == AF_INET)
1694 vrrp_add_ipv4(r->vr, c->address->u.prefix4);
1695 else if (r->vr->version == 3)
1696 vrrp_add_ipv6(r->vr, c->address->u.prefix6);
1697 }
1698 }
1699
1700 vrrp_check_start(r->vr);
1701
1702 if (r->addrs->count == 0 && r->fsm.state != VRRP_STATE_INITIALIZE) {
1703 DEBUGD(&vrrp_dbg_auto,
1704 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1705 "Virtual IP list is empty; shutting down",
1706 r->vr->vrid, family2str(r->family));
1707 vrrp_event(r, VRRP_EVENT_SHUTDOWN);
1708 }
1709 }
1710
1711 static struct vrrp_vrouter *
1712 vrrp_autoconfig_autocreate(struct interface *mvl_ifp)
1713 {
1714 struct interface *p;
1715 struct vrrp_vrouter *vr;
1716
1717 p = if_lookup_by_index(mvl_ifp->link_ifindex, VRF_DEFAULT);
1718
1719 if (!p)
1720 return NULL;
1721
1722 uint8_t vrid = mvl_ifp->hw_addr[5];
1723 uint8_t fam = mvl_ifp->hw_addr[4];
1724
1725 DEBUGD(&vrrp_dbg_auto,
1726 VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1727 "Autoconfiguring VRRP on %s",
1728 vrid, family2str(fam), p->name);
1729
1730 vr = vrrp_vrouter_create(p, vrid, vrrp_autoconfig_version);
1731
1732 if (!vr) {
1733 zlog_warn(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
1734 "Failed to autoconfigure VRRP on %s",
1735 vrid, family2str(fam), p->name);
1736 return NULL;
1737 }
1738
1739 vr->autoconf = true;
1740
1741 /*
1742 * If these interfaces are protodown on, we need to un-protodown them
1743 * in order to get Zebra to send us their addresses so we can
1744 * autoconfigure them.
1745 */
1746 if (vr->v4->mvl_ifp)
1747 vrrp_zclient_send_interface_protodown(vr->v4->mvl_ifp, false);
1748 if (vr->v6->mvl_ifp)
1749 vrrp_zclient_send_interface_protodown(vr->v6->mvl_ifp, false);
1750
1751 /* If they're not, we can go ahead and add the addresses we have */
1752 vrrp_autoconfig_autoaddrupdate(vr->v4);
1753 vrrp_autoconfig_autoaddrupdate(vr->v6);
1754
1755 return vr;
1756 }
1757
1758 /*
1759 * Callback to notify autoconfig of interface add.
1760 *
1761 * If the interface is a VRRP-compatible device, and there is no existing VRRP
1762 * router running on it, one is created. All addresses on the interface are
1763 * added to the router.
1764 *
1765 * ifp
1766 * Interface to operate on
1767 *
1768 * Returns:
1769 * -1 on failure
1770 * 0 otherwise
1771 */
1772 static int vrrp_autoconfig_if_add(struct interface *ifp)
1773 {
1774 bool created = false;
1775 struct vrrp_vrouter *vr;
1776
1777 if (!vrrp_autoconfig_is_on)
1778 return 0;
1779
1780 if (!ifp || !ifp->link_ifindex || !vrrp_ifp_has_vrrp_mac(ifp))
1781 return -1;
1782
1783 vr = vrrp_lookup_by_if_mvl(ifp);
1784
1785 if (!vr) {
1786 vr = vrrp_autoconfig_autocreate(ifp);
1787 created = true;
1788 }
1789
1790 if (!vr || vr->autoconf == false)
1791 return 0;
1792
1793 if (!created) {
1794 /*
1795 * We didn't create it, but it has already been autoconfigured.
1796 * Try to attach this interface to the existing instance.
1797 */
1798 if (!vr->v4->mvl_ifp) {
1799 vrrp_attach_interface(vr->v4);
1800 /* If we just attached it, make sure it's turned on */
1801 if (vr->v4->mvl_ifp) {
1802 vrrp_zclient_send_interface_protodown(
1803 vr->v4->mvl_ifp, false);
1804 /*
1805 * If it's already up, we can go ahead and add
1806 * the addresses we have
1807 */
1808 vrrp_autoconfig_autoaddrupdate(vr->v4);
1809 }
1810 }
1811 if (!vr->v6->mvl_ifp) {
1812 vrrp_attach_interface(vr->v6);
1813 /* If we just attached it, make sure it's turned on */
1814 if (vr->v6->mvl_ifp) {
1815 vrrp_zclient_send_interface_protodown(
1816 vr->v6->mvl_ifp, false);
1817 /*
1818 * If it's already up, we can go ahead and add
1819 * the addresses we have
1820 */
1821 vrrp_autoconfig_autoaddrupdate(vr->v6);
1822 }
1823 }
1824 }
1825
1826 return 0;
1827 }
1828
1829 /*
1830 * Callback to notify autoconfig of interface delete.
1831 *
1832 * If the interface is a VRRP-compatible device, and a VRRP router is running
1833 * on it, and that VRRP router was automatically configured, it will be
1834 * deleted. If that was the last router for the corresponding VRID (i.e., if
1835 * this interface was a v4 VRRP interface and no v6 router is configured for
1836 * the same VRID) then the entire virtual router is deleted.
1837 *
1838 * ifp
1839 * Interface to operate on
1840 *
1841 * Returns:
1842 * -1 on failure
1843 * 0 otherwise
1844 */
1845 static int vrrp_autoconfig_if_del(struct interface *ifp)
1846 {
1847 if (!vrrp_autoconfig_is_on)
1848 return 0;
1849
1850 struct vrrp_vrouter *vr;
1851 struct listnode *ln;
1852 struct list *vrs;
1853
1854 vrs = vrrp_lookup_by_if_any(ifp);
1855
1856 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr))
1857 if (vr->autoconf
1858 && (!vr->ifp || (!vr->v4->mvl_ifp && !vr->v6->mvl_ifp))) {
1859 DEBUGD(&vrrp_dbg_auto,
1860 VRRP_LOGPFX VRRP_LOGPFX_VRID
1861 "All VRRP interfaces for instance deleted; destroying autoconfigured VRRP router",
1862 vr->vrid);
1863 vrrp_vrouter_destroy(vr);
1864 }
1865
1866 list_delete(&vrs);
1867
1868 return 0;
1869 }
1870
1871 /*
1872 * Callback to notify autoconfig of interface up.
1873 *
1874 * Creates VRRP instance on interface if it does not exist. Otherwise does
1875 * nothing.
1876 *
1877 * ifp
1878 * Interface to operate on
1879 *
1880 * Returns:
1881 * -1 on failure
1882 * 0 otherwise
1883 */
1884 static int vrrp_autoconfig_if_up(struct interface *ifp)
1885 {
1886 if (!vrrp_autoconfig_is_on)
1887 return 0;
1888
1889 struct vrrp_vrouter *vr = vrrp_lookup_by_if_mvl(ifp);
1890
1891 if (vr && !vr->autoconf)
1892 return 0;
1893
1894 if (!vr) {
1895 vrrp_autoconfig_if_add(ifp);
1896 return 0;
1897 }
1898
1899 return 0;
1900 }
1901
1902 /*
1903 * Callback to notify autoconfig of interface down.
1904 *
1905 * Does nothing. An interface down event is accompanied by address deletion
1906 * events for all the addresses on the interface; if an autoconfigured VRRP
1907 * router exists on this interface, then it will have all its addresses deleted
1908 * and end up in Initialize.
1909 *
1910 * ifp
1911 * Interface to operate on
1912 *
1913 * Returns:
1914 * -1 on failure
1915 * 0 otherwise
1916 */
1917 static int vrrp_autoconfig_if_down(struct interface *ifp)
1918 {
1919 if (!vrrp_autoconfig_is_on)
1920 return 0;
1921
1922 return 0;
1923 }
1924
1925 /*
1926 * Callback to notify autoconfig of a new interface address.
1927 *
1928 * If a VRRP router exists on this interface, its address list is updated to
1929 * match the new address list. If no addresses remain, a Shutdown event is
1930 * issued to the VRRP router.
1931 *
1932 * ifp
1933 * Interface to operate on
1934 *
1935 * Returns:
1936 * -1 on failure
1937 * 0 otherwise
1938 *
1939 */
1940 static int vrrp_autoconfig_if_address_add(struct interface *ifp)
1941 {
1942 if (!vrrp_autoconfig_is_on)
1943 return 0;
1944
1945 struct vrrp_vrouter *vr = vrrp_lookup_by_if_mvl(ifp);
1946
1947 if (vr && vr->autoconf) {
1948 if (vr->v4->mvl_ifp == ifp)
1949 vrrp_autoconfig_autoaddrupdate(vr->v4);
1950 else if (vr->v6->mvl_ifp == ifp)
1951 vrrp_autoconfig_autoaddrupdate(vr->v6);
1952 }
1953
1954 return 0;
1955 }
1956
1957 /*
1958 * Callback to notify autoconfig of a removed interface address.
1959 *
1960 * If a VRRP router exists on this interface, its address list is updated to
1961 * match the new address list. If no addresses remain, a Shutdown event is
1962 * issued to the VRRP router.
1963 *
1964 * ifp
1965 * Interface to operate on
1966 *
1967 * Returns:
1968 * -1 on failure
1969 * 0 otherwise
1970 *
1971 */
1972 static int vrrp_autoconfig_if_address_del(struct interface *ifp)
1973 {
1974 if (!vrrp_autoconfig_is_on)
1975 return 0;
1976
1977 struct vrrp_vrouter *vr = vrrp_lookup_by_if_mvl(ifp);
1978
1979 if (vr && vr->autoconf) {
1980 if (vr->v4->mvl_ifp == ifp)
1981 vrrp_autoconfig_autoaddrupdate(vr->v4);
1982 else if (vr->v6->mvl_ifp == ifp)
1983 vrrp_autoconfig_autoaddrupdate(vr->v6);
1984 }
1985
1986 return 0;
1987 }
1988
1989 int vrrp_autoconfig(void)
1990 {
1991 if (!vrrp_autoconfig_is_on)
1992 return 0;
1993
1994 struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
1995 struct interface *ifp;
1996
1997 FOR_ALL_INTERFACES (vrf, ifp)
1998 vrrp_autoconfig_if_add(ifp);
1999
2000 return 0;
2001 }
2002
2003 void vrrp_autoconfig_on(int version)
2004 {
2005 vrrp_autoconfig_is_on = true;
2006 vrrp_autoconfig_version = version;
2007
2008 vrrp_autoconfig();
2009 }
2010
2011 void vrrp_autoconfig_off(void)
2012 {
2013 vrrp_autoconfig_is_on = false;
2014
2015 struct list *ll = hash_to_list(vrrp_vrouters_hash);
2016
2017 struct listnode *ln;
2018 struct vrrp_vrouter *vr;
2019
2020 for (ALL_LIST_ELEMENTS_RO(ll, ln, vr))
2021 if (vr->autoconf)
2022 vrrp_vrouter_destroy(vr);
2023
2024 list_delete(&ll);
2025 }
2026
2027 /* Interface tracking ------------------------------------------------------ */
2028
2029 /*
2030 * Bind any pending interfaces.
2031 *
2032 * mvl_ifp
2033 * macvlan interface that some VRRP instances might want to bind to
2034 */
2035 static void vrrp_bind_pending(struct interface *mvl_ifp)
2036 {
2037 struct vrrp_vrouter *vr;
2038
2039 DEBUGD(&vrrp_dbg_zebra,
2040 VRRP_LOGPFX
2041 "Searching for instances that could use interface %s",
2042 mvl_ifp->name);
2043
2044 vr = vrrp_lookup_by_if_mvl(mvl_ifp);
2045
2046 if (vr) {
2047 DEBUGD(&vrrp_dbg_zebra,
2048 VRRP_LOGPFX VRRP_LOGPFX_VRID
2049 "<-- This instance can probably use interface %s",
2050 vr->vrid, mvl_ifp->name);
2051
2052 if (mvl_ifp->hw_addr[4] == 0x01 && !vr->v4->mvl_ifp)
2053 vrrp_attach_interface(vr->v4);
2054 else if (mvl_ifp->hw_addr[4] == 0x02 && !vr->v6->mvl_ifp)
2055 vrrp_attach_interface(vr->v6);
2056 }
2057 }
2058
2059 void vrrp_if_up(struct interface *ifp)
2060 {
2061 struct vrrp_vrouter *vr;
2062 struct listnode *ln;
2063 struct list *vrs;
2064
2065 vrrp_bind_pending(ifp);
2066
2067 vrs = vrrp_lookup_by_if_any(ifp);
2068
2069 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr)) {
2070 vrrp_check_start(vr);
2071
2072 if (!if_is_operative(ifp))
2073 continue;
2074
2075 /*
2076 * Handle the situation in which we performed a state
2077 * transition on this VRRP router but needed to wait for the
2078 * macvlan interface to come up to perform some actions
2079 */
2080 if (ifp == vr->v4->mvl_ifp) {
2081 if (vr->v4->advert_pending) {
2082 DEBUGD(&vrrp_dbg_proto,
2083 VRRP_LOGPFX VRRP_LOGPFX_VRID
2084 VRRP_LOGPFX_FAM
2085 "Interface up; sending pending advertisement",
2086 vr->vrid, family2str(vr->v4->family));
2087 vrrp_send_advertisement(vr->v4);
2088 vr->v4->advert_pending = false;
2089 }
2090 if (vr->v4->garp_pending) {
2091 DEBUGD(&vrrp_dbg_proto,
2092 VRRP_LOGPFX VRRP_LOGPFX_VRID
2093 VRRP_LOGPFX_FAM
2094 "Interface up; sending pending gratuitous ARP",
2095 vr->vrid, family2str(vr->v4->family));
2096 vrrp_garp_send_all(vr->v4);
2097 vr->v4->garp_pending = false;
2098 }
2099 }
2100 if (ifp == vr->v6->mvl_ifp) {
2101 if (vr->v6->advert_pending) {
2102 DEBUGD(&vrrp_dbg_proto,
2103 VRRP_LOGPFX VRRP_LOGPFX_VRID
2104 VRRP_LOGPFX_FAM
2105 "Interface up; sending pending advertisement",
2106 vr->vrid, family2str(vr->v6->family));
2107 vrrp_send_advertisement(vr->v6);
2108 vr->v6->advert_pending = false;
2109 }
2110 if (vr->v6->ndisc_pending) {
2111 DEBUGD(&vrrp_dbg_proto,
2112 VRRP_LOGPFX VRRP_LOGPFX_VRID
2113 VRRP_LOGPFX_FAM
2114 "Interface up; sending pending Unsolicited Neighbor Advertisement",
2115 vr->vrid, family2str(vr->v6->family));
2116 vrrp_ndisc_una_send_all(vr->v6);
2117 vr->v6->ndisc_pending = false;
2118 }
2119 }
2120 }
2121
2122 list_delete(&vrs);
2123
2124 vrrp_autoconfig_if_up(ifp);
2125 }
2126
2127 void vrrp_if_down(struct interface *ifp)
2128 {
2129 struct vrrp_vrouter *vr;
2130 struct listnode *ln;
2131 struct list *vrs;
2132
2133 vrrp_bind_pending(ifp);
2134
2135 vrs = vrrp_lookup_by_if_any(ifp);
2136
2137 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr)) {
2138 vrrp_check_start(vr);
2139
2140 if (vr->ifp == ifp || vr->v4->mvl_ifp == ifp
2141 || vr->v6->mvl_ifp == ifp) {
2142 DEBUGD(&vrrp_dbg_auto,
2143 VRRP_LOGPFX VRRP_LOGPFX_VRID "Interface %s down",
2144 vr->vrid, ifp->name);
2145 }
2146 }
2147
2148 list_delete(&vrs);
2149
2150 vrrp_autoconfig_if_down(ifp);
2151 }
2152
2153 void vrrp_if_add(struct interface *ifp)
2154 {
2155 vrrp_bind_pending(ifp);
2156
2157 /* thanks, zebra */
2158 if (CHECK_FLAG(ifp->flags, IFF_UP))
2159 vrrp_if_up(ifp);
2160
2161 vrrp_autoconfig_if_add(ifp);
2162 }
2163
2164 void vrrp_if_del(struct interface *ifp)
2165 {
2166 struct listnode *ln;
2167 struct vrrp_vrouter *vr;
2168 struct list *vrs = vrrp_lookup_by_if_any(ifp);
2169
2170 vrrp_if_down(ifp);
2171
2172 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr)) {
2173 if ((vr->v4->mvl_ifp == ifp || vr->ifp == ifp)
2174 && vr->v4->fsm.state != VRRP_STATE_INITIALIZE) {
2175 vrrp_event(vr->v4, VRRP_EVENT_SHUTDOWN);
2176 vr->v4->mvl_ifp = NULL;
2177 } else if ((vr->v6->mvl_ifp == ifp || vr->ifp == ifp)
2178 && vr->v6->fsm.state != VRRP_STATE_INITIALIZE) {
2179 vrrp_event(vr->v6, VRRP_EVENT_SHUTDOWN);
2180 vr->v6->mvl_ifp = NULL;
2181 }
2182 }
2183
2184 list_delete(&vrs);
2185
2186 vrrp_autoconfig_if_del(ifp);
2187 }
2188
2189 void vrrp_if_address_add(struct interface *ifp)
2190 {
2191 struct vrrp_vrouter *vr;
2192 struct listnode *ln;
2193 struct list *vrs;
2194
2195 /*
2196 * We have to do a wide search here, because we need to know when a v6
2197 * macvlan device gets a new address. This is because the macvlan link
2198 * local is used as the source address for v6 advertisements, and hence
2199 * "do I have a link local" constitutes an activation condition for v6
2200 * virtual routers.
2201 */
2202 vrs = vrrp_lookup_by_if_any(ifp);
2203
2204 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr))
2205 vrrp_check_start(vr);
2206
2207 list_delete(&vrs);
2208
2209 vrrp_autoconfig_if_address_add(ifp);
2210 }
2211
2212 void vrrp_if_address_del(struct interface *ifp)
2213 {
2214 /*
2215 * Zebra is stupid and sends us address deletion notifications
2216 * when any of the following condition sets are met:
2217 *
2218 * - if_is_operative && address deleted
2219 * - if_is_operative -> !if_is_operative
2220 *
2221 * Note that the second one is nonsense, because Zebra behaves as
2222 * though an interface going down means all the addresses on that
2223 * interface got deleted. Which is a problem for autoconfig because all
2224 * the addresses on an interface going away means the VRRP session goes
2225 * to Initialize. However interfaces go down whenever we transition to
2226 * Backup, so this effectively means that for autoconfigured instances
2227 * we actually end up in Initialize whenever we try to go into Backup.
2228 *
2229 * Also, Zebra does NOT send us notifications when:
2230 * - !if_is_operative && address deleted
2231 *
2232 * Which means if we're in backup and an address is deleted out from
2233 * under us, we won't even know.
2234 *
2235 * The only solution here is to only resynchronize our address list
2236 * when:
2237 *
2238 * - An interfaces comes up
2239 * - An interface address is added
2240 * - An interface address is deleted AND the interface is up
2241 *
2242 * Even though this is only a problem with autoconfig at the moment I'm
2243 * papering over Zebra's braindead semantics here. Every piece of code
2244 * in this function should be protected by a check that the interface
2245 * is up.
2246 */
2247 if (if_is_operative(ifp))
2248 vrrp_autoconfig_if_address_del(ifp);
2249 }
2250
2251 /* Other ------------------------------------------------------------------- */
2252
2253 int vrrp_config_write_interface(struct vty *vty)
2254 {
2255 struct list *vrs = hash_to_list(vrrp_vrouters_hash);
2256 struct listnode *ln, *ipln;
2257 struct vrrp_vrouter *vr;
2258 int writes = 0;
2259
2260 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr)) {
2261 vty_frame(vty, "interface %s\n", vr->ifp->name);
2262 ++writes;
2263
2264 vty_out(vty, " vrrp %" PRIu8 "%s\n", vr->vrid,
2265 vr->version == 2 ? " version 2" : "");
2266 ++writes;
2267
2268 if (vr->shutdown != vd.shutdown && ++writes)
2269 vty_out(vty, " %svrrp %" PRIu8 " shutdown\n",
2270 vr->shutdown ? "" : "no ", vr->vrid);
2271
2272 if (vr->preempt_mode != vd.preempt_mode && ++writes)
2273 vty_out(vty, " %svrrp %" PRIu8 " preempt\n",
2274 vr->preempt_mode ? "" : "no ", vr->vrid);
2275
2276 if (vr->accept_mode != vd.accept_mode && ++writes)
2277 vty_out(vty, " %svrrp %" PRIu8 " accept\n",
2278 vr->accept_mode ? "" : "no ", vr->vrid);
2279
2280 if (vr->advertisement_interval != vd.advertisement_interval
2281 && ++writes)
2282 vty_out(vty,
2283 " vrrp %" PRIu8
2284 " advertisement-interval %d\n",
2285 vr->vrid, vr->advertisement_interval * CS2MS);
2286
2287 if (vr->priority != vd.priority && ++writes)
2288 vty_out(vty, " vrrp %" PRIu8 " priority %" PRIu8 "\n",
2289 vr->vrid, vr->priority);
2290
2291 struct ipaddr *ip;
2292
2293 for (ALL_LIST_ELEMENTS_RO(vr->v4->addrs, ipln, ip)) {
2294 char ipbuf[INET6_ADDRSTRLEN];
2295
2296 ipaddr2str(ip, ipbuf, sizeof(ipbuf));
2297 vty_out(vty, " vrrp %" PRIu8 " ip %s\n", vr->vrid,
2298 ipbuf);
2299 ++writes;
2300 }
2301
2302 for (ALL_LIST_ELEMENTS_RO(vr->v6->addrs, ipln, ip)) {
2303 char ipbuf[INET6_ADDRSTRLEN];
2304
2305 ipaddr2str(ip, ipbuf, sizeof(ipbuf));
2306 vty_out(vty, " vrrp %" PRIu8 " ipv6 %s\n", vr->vrid,
2307 ipbuf);
2308 ++writes;
2309 }
2310 vty_endframe(vty, "!\n");
2311 }
2312
2313 list_delete(&vrs);
2314
2315 return writes;
2316 }
2317
2318 int vrrp_config_write_global(struct vty *vty)
2319 {
2320 unsigned int writes = 0;
2321
2322 if (vrrp_autoconfig_is_on && ++writes)
2323 vty_out(vty, "vrrp autoconfigure%s\n",
2324 vrrp_autoconfig_version == 2 ? " version 2" : "");
2325
2326 if (vd.priority != VRRP_DEFAULT_PRIORITY && ++writes)
2327 vty_out(vty, "vrrp default priority %" PRIu8 "\n", vd.priority);
2328
2329 if (vd.advertisement_interval != VRRP_DEFAULT_ADVINT && ++writes)
2330 vty_out(vty,
2331 "vrrp default advertisement-interval %" PRIu16 "\n",
2332 vd.advertisement_interval * CS2MS);
2333
2334 if (vd.preempt_mode != VRRP_DEFAULT_PREEMPT && ++writes)
2335 vty_out(vty, "%svrrp default preempt\n",
2336 !vd.preempt_mode ? "no " : "");
2337
2338 if (vd.accept_mode != VRRP_DEFAULT_ACCEPT && ++writes)
2339 vty_out(vty, "%svrrp default accept\n",
2340 !vd.accept_mode ? "no " : "");
2341
2342 if (vd.shutdown != VRRP_DEFAULT_SHUTDOWN && ++writes)
2343 vty_out(vty, "%svrrp default shutdown\n",
2344 !vd.shutdown ? "no " : "");
2345
2346 return writes;
2347 }
2348
2349 static unsigned int vrrp_hash_key(const void *arg)
2350 {
2351 const struct vrrp_vrouter *vr = arg;
2352 char key[IFNAMSIZ + 64];
2353
2354 snprintf(key, sizeof(key), "%s@%" PRIu8, vr->ifp->name, vr->vrid);
2355
2356 return string_hash_make(key);
2357 }
2358
2359 static bool vrrp_hash_cmp(const void *arg1, const void *arg2)
2360 {
2361 const struct vrrp_vrouter *vr1 = arg1;
2362 const struct vrrp_vrouter *vr2 = arg2;
2363
2364 if (vr1->ifp != vr2->ifp)
2365 return 0;
2366 if (vr1->vrid != vr2->vrid)
2367 return 0;
2368
2369 return 1;
2370 }
2371
2372 void vrrp_init(void)
2373 {
2374 /* Set default defaults */
2375 vd.priority = VRRP_DEFAULT_PRIORITY;
2376 vd.advertisement_interval = VRRP_DEFAULT_ADVINT;
2377 vd.preempt_mode = VRRP_DEFAULT_PREEMPT;
2378 vd.accept_mode = VRRP_DEFAULT_ACCEPT;
2379 vd.shutdown = VRRP_DEFAULT_SHUTDOWN;
2380
2381 vrrp_autoconfig_version = 3;
2382 vrrp_vrouters_hash = hash_create(&vrrp_hash_key, vrrp_hash_cmp,
2383 "VRRP virtual router hash");
2384 vrf_init(NULL, NULL, NULL, NULL, NULL);
2385 }
2386
2387 void vrrp_fini(void)
2388 {
2389 /* Destroy all instances */
2390 struct list *vrs = hash_to_list(vrrp_vrouters_hash);
2391
2392 struct listnode *ln;
2393 struct vrrp_vrouter *vr;
2394
2395 for (ALL_LIST_ELEMENTS_RO(vrs, ln, vr))
2396 vrrp_vrouter_destroy(vr);
2397
2398 list_delete(&vrs);
2399
2400 hash_clean(vrrp_vrouters_hash, NULL);
2401 hash_free(vrrp_vrouters_hash);
2402 }