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 #ifndef __VRRP_H__
21 #define __VRRP_H__
22
23 #include <zebra.h>
24 #include <netinet/ip.h>
25
26 #include "lib/memory.h"
27 #include "lib/hash.h"
28 #include "lib/hook.h"
29 #include "lib/if.h"
30 #include "lib/linklist.h"
31 #include "lib/northbound.h"
32 #include "lib/privs.h"
33 #include "lib/stream.h"
34 #include "lib/thread.h"
35 #include "lib/vty.h"
36
37 /* Global definitions */
38 #define VRRP_RADV_INT 16
39 #define VRRP_PRIO_MASTER 255
40 #define VRRP_MCASTV4_GROUP_STR "224.0.0.18"
41 #define VRRP_MCASTV6_GROUP_STR "ff02:0:0:0:0:0:0:12"
42 #define VRRP_MCASTV4_GROUP 0xe0000012
43 #define VRRP_MCASTV6_GROUP 0xff020000000000000000000000000012
44 #define IPPROTO_VRRP 112
45
46 #define VRRP_LOGPFX_VRID "[VRID %u] "
47 #define VRRP_LOGPFX_FAM "[%s] "
48
49 /* Default defaults */
50 #define VRRP_XPATH_FULL "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group"
51 #define VRRP_XPATH "./frr-vrrpd:vrrp/vrrp-group"
52 #define VRRP_DEFAULT_PRIORITY 100
53 #define VRRP_DEFAULT_ADVINT 100
54 #define VRRP_DEFAULT_PREEMPT true
55 #define VRRP_DEFAULT_ACCEPT true
56 #define VRRP_DEFAULT_SHUTDOWN false
57
58 /* User compatibility constant */
59 #define CS2MS 10
60
DECLARE_MGROUP(VRRPD)61 DECLARE_MGROUP(VRRPD)
62
63 /* Northbound */
64 extern const struct frr_yang_module_info frr_vrrpd_info;
65
66 /* Configured defaults */
67 struct vrrp_defaults {
68 uint8_t version;
69 uint8_t priority;
70 uint16_t advertisement_interval;
71 bool preempt_mode;
72 bool accept_mode;
73 bool shutdown;
74 };
75
76 extern struct vrrp_defaults vd;
77
78 /* threadmaster */
79 extern struct thread_master *master;
80
81 /* privileges */
82 extern struct zebra_privs_t vrrp_privs;
83
84 /* Global hash of all Virtual Routers */
85 extern struct hash *vrrp_vrouters_hash;
86
87 /*
88 * VRRP Router.
89 *
90 * This struct contains all state for a particular VRRP Router operating
91 * in a Virtual Router for either IPv4 or IPv6.
92 */
93 struct vrrp_router {
94 /*
95 * Whether this VRRP Router is active.
96 */
97 bool is_active;
98
99 /* Whether we are the address owner */
100 bool is_owner;
101
102 /* Rx socket: Rx from parent of mvl_ifp */
103 int sock_rx;
104 /* Tx socket; Tx from mvl_ifp */
105 int sock_tx;
106
107 /* macvlan interface */
108 struct interface *mvl_ifp;
109
110 /* Source address for advertisements */
111 struct ipaddr src;
112
113 /* Socket read buffer */
114 uint8_t ibuf[IP_MAXPACKET];
115
116 /*
117 * Address family of this Virtual Router.
118 * Either AF_INET or AF_INET6.
119 */
120 int family;
121
122 /*
123 * Virtual Router this VRRP Router is participating in.
124 */
125 struct vrrp_vrouter *vr;
126
127 /*
128 * One or more IPvX addresses associated with this Virtual
129 * Router. The first address must be the "primary" address this
130 * Virtual Router is backing up in the case of IPv4. In the case of
131 * IPv6 it must be the link-local address of vr->ifp.
132 *
133 * Type: struct ipaddr *
134 */
135 struct list *addrs;
136
137 /*
138 * This flag says whether we are waiting on an interface up
139 * notification from Zebra before we send an ADVERTISEMENT.
140 */
141 bool advert_pending;
142
143 /*
144 * If this is an IPv4 VRRP router, this flag says whether we are
145 * waiting on an interface up notification from Zebra before we send
146 * gratuitous ARP packets for all our addresses. Should never be true
147 * if family == AF_INET6.
148 */
149 bool garp_pending;
150 /*
151 * If this is an IPv6 VRRP router, this flag says whether we are
152 * waiting on an interface up notification from Zebra before we send
153 * Unsolicited Neighbor Advertisement packets for all our addresses.
154 * Should never be true if family == AF_INET.
155 */
156 bool ndisc_pending;
157
158 /*
159 * Effective priority
160 * => vr->priority if we are Backup
161 * => 255 if we are Master
162 */
163 uint8_t priority;
164
165 /*
166 * Advertisement interval contained in ADVERTISEMENTS received from the
167 * Master (centiseconds)
168 */
169 uint16_t master_adver_interval;
170
171 /*
172 * Time to skew Master_Down_Interval in centiseconds. Calculated as:
173 * (((256 - priority) * Master_Adver_Interval) / 256)
174 */
175 uint16_t skew_time;
176
177 /*
178 * Time interval for Backup to declare Master down (centiseconds).
179 * Calculated as:
180 * (3 * Master_Adver_Interval) + Skew_time
181 */
182 uint16_t master_down_interval;
183
184 /*
185 * The MAC address used for the source MAC address in VRRP
186 * advertisements, advertised in ARP requests/responses, and advertised
187 * in ND Neighbor Advertisements.
188 */
189 struct ethaddr vmac;
190
191 struct {
192 int state;
193 } fsm;
194
195 struct {
196 /* Total number of advertisements sent and received */
197 uint32_t adver_tx_cnt;
198 uint32_t adver_rx_cnt;
199 /* Total number of gratuitous ARPs sent */
200 uint32_t garp_tx_cnt;
201 /* Total number of unsolicited Neighbor Advertisements sent */
202 uint32_t una_tx_cnt;
203 /* Total number of state transitions */
204 uint32_t trans_cnt;
205 } stats;
206
207 struct thread *t_master_down_timer;
208 struct thread *t_adver_timer;
209 struct thread *t_read;
210 struct thread *t_write;
211 };
212
213 /*
214 * VRRP Virtual Router.
215 *
216 * This struct contains all state and configuration for a given Virtual Router
217 * Identifier on a given interface, both v4 and v6.
218 *
219 * RFC5798 s. 1 states:
220 * "Within a VRRP router, the virtual routers in each of the IPv4 and IPv6
221 * address families are a domain unto themselves and do not overlap."
222 *
223 * This implementation has chosen the tuple (interface, VRID) as the key for a
224 * particular VRRP Router, and the rest of the program is designed around this
225 * assumption. Additionally, base protocol configuration parameters such as the
226 * advertisement interval and (configured) priority are shared between v4 and
227 * v6 instances. This corresponds to the choice made by other industrial
228 * implementations.
229 */
230 struct vrrp_vrouter {
231 /* Whether this instance was automatically configured */
232 bool autoconf;
233
234 /* Whether this VRRP router is in administrative shutdown */
235 bool shutdown;
236
237 /* Interface */
238 struct interface *ifp;
239
240 /* Version */
241 uint8_t version;
242
243 /* Virtual Router Identifier */
244 uint32_t vrid;
245
246 /* Configured priority */
247 uint8_t priority;
248
249 /*
250 * Time interval between ADVERTISEMENTS (centiseconds). Default is 100
251 * centiseconds (1 second).
252 */
253 uint16_t advertisement_interval;
254
255 /*
256 * Controls whether a (starting or restarting) higher-priority Backup
257 * router preempts a lower-priority Master router. Values are True to
258 * allow preemption and False to prohibit preemption. Default is True.
259 */
260 bool preempt_mode;
261
262 /*
263 * Controls whether a virtual router in Master state will accept
264 * packets addressed to the address owner's IPvX address as its own if
265 * it is not the IPvX address owner. The default is False.
266 */
267 bool accept_mode;
268
269 struct vrrp_router *v4;
270 struct vrrp_router *v6;
271 };
272
273 /*
274 * Initialize VRRP global datastructures.
275 */
276 void vrrp_init(void);
277
278 /*
279 * Destroy all VRRP instances and gracefully shutdown.
280 *
281 * For instances in Master state, VRRP advertisements with 0 priority will be
282 * sent if possible to notify Backup routers that we are going away.
283 */
284 void vrrp_fini(void);
285
286
287 /* Creation and destruction ------------------------------------------------ */
288
289 /*
290 * Create and register a new VRRP Virtual Router.
291 *
292 * ifp
293 * Base interface to configure VRRP on
294 *
295 * vrid
296 * Virtual Router Identifier
297 */
298 struct vrrp_vrouter *vrrp_vrouter_create(struct interface *ifp, uint8_t vrid,
299 uint8_t version);
300
301 /*
302 * Destroy a VRRP Virtual Router, freeing all its resources.
303 *
304 * If there are any running VRRP instances, these are stopped and destroyed.
305 */
306 void vrrp_vrouter_destroy(struct vrrp_vrouter *vr);
307
308
309 /* Configuration controllers ----------------------------------------------- */
310
311 /*
312 * Check if a Virtual Router ought to be started, and if so, start it.
313 *
314 * vr
315 * Virtual Router to checkstart
316 */
317 void vrrp_check_start(struct vrrp_vrouter *vr);
318
319 /*
320 * Change the configured priority of a VRRP Virtual Router.
321 *
322 * Note that this only changes the configured priority of the Virtual Router.
323 * The currently effective priority will not be changed; to change the
324 * effective priority, the Virtual Router must be restarted by issuing a
325 * VRRP_EVENT_SHUTDOWN followed by a VRRP_EVENT_STARTUP.
326 *
327 * vr
328 * Virtual Router to change priority of
329 *
330 * priority
331 * New priority
332 */
333 void vrrp_set_priority(struct vrrp_vrouter *vr, uint8_t priority);
334
335 /*
336 * Set Advertisement Interval on this Virtual Router.
337 *
338 * vr
339 * Virtual Router to change priority of
340 *
341 * advertisement_interval
342 * New advertisement interval
343 */
344 void vrrp_set_advertisement_interval(struct vrrp_vrouter *vr,
345 uint16_t advertisement_interval);
346
347 /*
348 * Add an IPvX address to a VRRP Virtual Router.
349 *
350 * vr
351 * Virtual Router to add IPvx address to
352 *
353 * ip
354 * Address to add
355 *
356 * activate
357 * Whether to automatically start the VRRP router if this is the first IP
358 * address added.
359 *
360 * Returns:
361 * -1 on error
362 * 0 otherwise
363 */
364 int vrrp_add_ip(struct vrrp_vrouter *vr, struct ipaddr *ip);
365
366 /*
367 * Add an IPv4 address to a VRRP Virtual Router.
368 *
369 * vr
370 * Virtual Router to add IPv4 address to
371 *
372 * v4
373 * Address to add
374 *
375 * activate
376 * Whether to automatically start the VRRP router if this is the first IP
377 * address added.
378 *
379 * Returns:
380 * -1 on error
381 * 0 otherwise
382 */
383 int vrrp_add_ipv4(struct vrrp_vrouter *vr, struct in_addr v4);
384
385 /*
386 * Add an IPv6 address to a VRRP Virtual Router.
387 *
388 * vr
389 * Virtual Router to add IPv6 address to
390 *
391 * v6
392 * Address to add
393 *
394 * activate
395 * Whether to automatically start the VRRP router if this is the first IP
396 * address added.
397 *
398 * Returns:
399 * -1 on error
400 * 0 otherwise
401 */
402 int vrrp_add_ipv6(struct vrrp_vrouter *vr, struct in6_addr v6);
403
404 /*
405 * Remove an IP address from a VRRP Virtual Router.
406 *
407 * vr
408 * Virtual Router to remove IP address from
409 *
410 * ip
411 * Address to remove
412 *
413 * deactivate
414 * Whether to automatically stop the VRRP router if removing v4 would leave
415 * us with an empty address list. If this is not true and ip is the only IP
416 * address backed up by this virtual router, this function will not remove
417 * the address and return failure.
418 *
419 * Returns:
420 * -1 on error
421 * 0 otherwise
422 */
423 int vrrp_del_ip(struct vrrp_vrouter *vr, struct ipaddr *ip);
424
425 /*
426 * Remove an IPv4 address from a VRRP Virtual Router.
427 *
428 * vr
429 * Virtual Router to remove IPv4 address from
430 *
431 * v4
432 * Address to remove
433 *
434 * deactivate
435 * Whether to automatically stop the VRRP router if removing v4 would leave
436 * us with an empty address list. If this is not true and v4 is the only
437 * IPv4 address backed up by this virtual router, this function will not
438 * remove the address and return failure.
439 *
440 * Returns:
441 * -1 on error
442 * 0 otherwise
443 */
444 int vrrp_del_ipv4(struct vrrp_vrouter *vr, struct in_addr v4);
445
446 /*
447 * Remove an IPv6 address from a VRRP Virtual Router.
448 *
449 * vr
450 * Virtual Router to remove IPv6 address from
451 *
452 * v6
453 * Address to remove
454 *
455 * deactivate
456 * Whether to automatically stop the VRRP router if removing v5 would leave
457 * us with an empty address list. If this is not true and v4 is the only
458 * IPv6 address backed up by this virtual router, this function will not
459 * remove the address and return failure.
460 *
461 * Returns:
462 * -1 on error
463 * 0 otherwise
464 */
465 int vrrp_del_ipv6(struct vrrp_vrouter *vr, struct in6_addr v6);
466
467 /* State machine ----------------------------------------------------------- */
468
469 #define VRRP_STATE_INITIALIZE 0
470 #define VRRP_STATE_MASTER 1
471 #define VRRP_STATE_BACKUP 2
472 #define VRRP_EVENT_STARTUP 0
473 #define VRRP_EVENT_SHUTDOWN 1
474
475 extern const char *const vrrp_state_names[3];
476
477 /*
478 * This hook called whenever the state of a Virtual Router changes, after the
479 * specific internal state handlers have run.
480 *
481 * Use this if you need to react to state changes to perform non-critical
482 * tasks. Critical tasks should go in the internal state change handlers.
483 */
484 DECLARE_HOOK(vrrp_change_state_hook, (struct vrrp_router *r, int to), (r, to));
485
486 /*
487 * Trigger a VRRP event on a given Virtual Router..
488 *
489 * vr
490 * Virtual Router to operate on
491 *
492 * event
493 * Event to kick off. All event related processing will have completed upon
494 * return of this function.
495 *
496 * Returns:
497 * < 0 if the event created an error
498 * 0 otherwise
499 */
500 int vrrp_event(struct vrrp_router *r, int event);
501
502 /* Autoconfig -------------------------------------------------------------- */
503
504 /*
505 * Search for and automatically configure VRRP instances on interfaces.
506 *
507 * ifp
508 * Interface to autoconfig. If it is a macvlan interface and has a VRRP MAC,
509 * a VRRP instance corresponding to VMAC assigned to macvlan will be created
510 * on the parent interface and all addresses on the macvlan interface except
511 * the v6 link local will be configured as VRRP addresses. If NULL, this
512 * treatment will be applied to all existing interfaces matching the above
513 * criterion.
514 *
515 * Returns:
516 * -1 on failure
517 * 0 otherwise
518 */
519 int vrrp_autoconfig(void);
520
521 /*
522 * Enable autoconfiguration.
523 *
524 * Calling this function will cause vrrpd to automatically configure VRRP
525 * instances on existing compatible macvlan interfaces. These instances will
526 * react to interface up/down and address add/delete events to keep themselves
527 * in sync with the available interfaces.
528 *
529 * version
530 * VRRP version to use for autoconfigured instances. Must be 2 or 3.
531 */
532 void vrrp_autoconfig_on(int version);
533
534 /*
535 * Disable autoconfiguration.
536 *
537 * Calling this function will delete all existing autoconfigured VRRP instances.
538 */
539 void vrrp_autoconfig_off(void);
540
541 /* Interface Tracking ------------------------------------------------------ */
542
543 void vrrp_if_add(struct interface *ifp);
544 void vrrp_if_del(struct interface *ifp);
545 void vrrp_if_up(struct interface *ifp);
546 void vrrp_if_down(struct interface *ifp);
547 void vrrp_if_address_add(struct interface *ifp);
548 void vrrp_if_address_del(struct interface *ifp);
549
550 /* Other ------------------------------------------------------------------- */
551
552 /*
553 * Write global level configuration to vty.
554 *
555 * vty
556 * vty to write config to
557 *
558 * Returns:
559 * # of lines written
560 */
561 int vrrp_config_write_global(struct vty *vty);
562
563 /*
564 * Find VRRP Virtual Router by Virtual Router ID
565 */
566 struct vrrp_vrouter *vrrp_lookup(const struct interface *ifp, uint8_t vrid);
567
568 #endif /* __VRRP_H__ */
569