1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * pim_bsm.c: PIM BSM handling routines
5 * Copyright (C) 2018-19 Vmware, Inc.
15 #include "pim_iface.h"
16 #include "pim_instance.h"
17 #include "pim_neighbor.h"
19 #include "pim_hello.h"
24 #include "pim_zebra.h"
27 /* Functions forward declaration */
28 static void pim_bs_timer_start(struct bsm_scope
*scope
, int bs_timeout
);
29 static void pim_g2rp_timer_start(struct bsm_rpinfo
*bsrp
, int hold_time
);
30 static inline void pim_g2rp_timer_restart(struct bsm_rpinfo
*bsrp
,
34 DEFINE_MTYPE_STATIC(PIMD
, PIM_BSGRP_NODE
, "PIM BSR advertised grp info");
35 DEFINE_MTYPE_STATIC(PIMD
, PIM_BSRP_INFO
, "PIM BSR advertised RP info");
36 DEFINE_MTYPE_STATIC(PIMD
, PIM_BSM_FRAG
, "PIM BSM fragment");
37 DEFINE_MTYPE_STATIC(PIMD
, PIM_BSM_PKT_VAR_MEM
, "PIM BSM Packet");
39 /* All bsm packets forwarded shall be fit within ip mtu less iphdr(max) */
40 #define MAX_IP_HDR_LEN 24
42 /* pim_bsm_write_config - Write the interface pim bsm configuration.*/
43 void pim_bsm_write_config(struct vty
*vty
, struct interface
*ifp
)
45 struct pim_interface
*pim_ifp
= ifp
->info
;
48 if (!pim_ifp
->bsm_enable
)
49 vty_out(vty
, " no " PIM_AF_NAME
" pim bsm\n");
50 if (!pim_ifp
->ucast_bsm_accept
)
51 vty_out(vty
, " no " PIM_AF_NAME
" pim unicast-bsm\n");
55 static void pim_bsm_rpinfo_free(struct bsm_rpinfo
*bsrp_info
)
57 EVENT_OFF(bsrp_info
->g2rp_timer
);
58 XFREE(MTYPE_PIM_BSRP_INFO
, bsrp_info
);
61 static void pim_bsm_rpinfos_free(struct bsm_rpinfos_head
*head
)
63 struct bsm_rpinfo
*bsrp_info
;
65 while ((bsrp_info
= bsm_rpinfos_pop(head
)))
66 pim_bsm_rpinfo_free(bsrp_info
);
69 static void pim_free_bsgrp_data(struct bsgrp_node
*bsgrp_node
)
71 pim_bsm_rpinfos_free(bsgrp_node
->bsrp_list
);
72 pim_bsm_rpinfos_free(bsgrp_node
->partial_bsrp_list
);
73 XFREE(MTYPE_PIM_BSGRP_NODE
, bsgrp_node
);
76 static void pim_free_bsgrp_node(struct route_table
*rt
, struct prefix
*grp
)
78 struct route_node
*rn
;
80 rn
= route_node_lookup(rt
, grp
);
83 route_unlock_node(rn
);
84 route_unlock_node(rn
);
88 static void pim_bsm_frag_free(struct bsm_frag
*bsfrag
)
90 XFREE(MTYPE_PIM_BSM_FRAG
, bsfrag
);
93 static void pim_bsm_frags_free(struct bsm_scope
*scope
)
95 struct bsm_frag
*bsfrag
;
97 while ((bsfrag
= bsm_frags_pop(scope
->bsm_frags
)))
98 pim_bsm_frag_free(bsfrag
);
101 int pim_bsm_rpinfo_cmp(const struct bsm_rpinfo
*node1
,
102 const struct bsm_rpinfo
*node2
)
104 /* RP election Algo :
105 * Step-1 : Loweset Rp priority will have higher precedance.
106 * Step-2 : If priority same then higher hash val will have
108 * Step-3 : If Hash val is same then highest rp address will
111 if (node1
->rp_prio
< node2
->rp_prio
)
113 if (node1
->rp_prio
> node2
->rp_prio
)
115 if (node1
->hash
< node2
->hash
)
117 if (node1
->hash
> node2
->hash
)
119 return pim_addr_cmp(node2
->rp_address
, node1
->rp_address
);
122 static struct bsgrp_node
*pim_bsm_new_bsgrp_node(struct route_table
*rt
,
125 struct route_node
*rn
;
126 struct bsgrp_node
*bsgrp
;
128 rn
= route_node_get(rt
, grp
);
130 zlog_warn("%s: route node creation failed", __func__
);
133 bsgrp
= XCALLOC(MTYPE_PIM_BSGRP_NODE
, sizeof(struct bsgrp_node
));
136 bsm_rpinfos_init(bsgrp
->bsrp_list
);
137 bsm_rpinfos_init(bsgrp
->partial_bsrp_list
);
139 prefix_copy(&bsgrp
->group
, grp
);
143 static void pim_on_bs_timer(struct event
*t
)
145 struct route_node
*rn
;
146 struct bsm_scope
*scope
;
147 struct bsgrp_node
*bsgrp_node
;
148 struct bsm_rpinfo
*bsrp
;
150 scope
= EVENT_ARG(t
);
151 EVENT_OFF(scope
->bs_timer
);
154 zlog_debug("%s: Bootstrap Timer expired for scope: %d",
155 __func__
, scope
->sz_id
);
157 pim_nht_bsr_del(scope
->pim
, scope
->current_bsr
);
158 /* Reset scope zone data */
159 scope
->accept_nofwd_bsm
= false;
160 scope
->state
= ACCEPT_ANY
;
161 scope
->current_bsr
= PIMADDR_ANY
;
162 scope
->current_bsr_prio
= 0;
163 scope
->current_bsr_first_ts
= 0;
164 scope
->current_bsr_last_ts
= 0;
165 scope
->bsm_frag_tag
= 0;
166 pim_bsm_frags_free(scope
);
168 for (rn
= route_top(scope
->bsrp_table
); rn
; rn
= route_next(rn
)) {
170 bsgrp_node
= (struct bsgrp_node
*)rn
->info
;
173 zlog_debug("%s: bsgrp_node is null", __func__
);
176 /* Give grace time for rp to continue for another hold time */
177 bsrp
= bsm_rpinfos_first(bsgrp_node
->bsrp_list
);
179 pim_g2rp_timer_restart(bsrp
, bsrp
->rp_holdtime
);
181 /* clear pending list */
182 pim_bsm_rpinfos_free(bsgrp_node
->partial_bsrp_list
);
183 bsgrp_node
->pend_rp_cnt
= 0;
187 static void pim_bs_timer_stop(struct bsm_scope
*scope
)
190 zlog_debug("%s : BS timer being stopped of sz: %d", __func__
,
192 EVENT_OFF(scope
->bs_timer
);
195 static void pim_bs_timer_start(struct bsm_scope
*scope
, int bs_timeout
)
199 zlog_debug("%s : Invalid scope(NULL).", __func__
);
202 EVENT_OFF(scope
->bs_timer
);
205 "%s : starting bs timer for scope %d with timeout %d secs",
206 __func__
, scope
->sz_id
, bs_timeout
);
207 event_add_timer(router
->master
, pim_on_bs_timer
, scope
, bs_timeout
,
211 static inline void pim_bs_timer_restart(struct bsm_scope
*scope
, int bs_timeout
)
213 pim_bs_timer_start(scope
, bs_timeout
);
216 void pim_bsm_proc_init(struct pim_instance
*pim
)
218 memset(&pim
->global_scope
, 0, sizeof(struct bsm_scope
));
220 pim
->global_scope
.sz_id
= PIM_GBL_SZ_ID
;
221 pim
->global_scope
.bsrp_table
= route_table_init();
222 pim
->global_scope
.accept_nofwd_bsm
= true;
223 pim
->global_scope
.state
= NO_INFO
;
224 pim
->global_scope
.pim
= pim
;
225 bsm_frags_init(pim
->global_scope
.bsm_frags
);
226 pim_bs_timer_start(&pim
->global_scope
, PIM_BS_TIME
);
229 void pim_bsm_proc_free(struct pim_instance
*pim
)
231 struct route_node
*rn
;
232 struct bsgrp_node
*bsgrp
;
234 pim_bs_timer_stop(&pim
->global_scope
);
235 pim_bsm_frags_free(&pim
->global_scope
);
237 for (rn
= route_top(pim
->global_scope
.bsrp_table
); rn
;
238 rn
= route_next(rn
)) {
242 pim_free_bsgrp_data(bsgrp
);
245 route_table_finish(pim
->global_scope
.bsrp_table
);
248 static bool is_hold_time_elapsed(void *data
)
250 struct bsm_rpinfo
*bsrp
;
254 if (bsrp
->elapse_time
< bsrp
->rp_holdtime
)
260 static void pim_on_g2rp_timer(struct event
*t
)
262 struct bsm_rpinfo
*bsrp
;
263 struct bsm_rpinfo
*bsrp_node
;
264 struct bsgrp_node
*bsgrp_node
;
265 struct pim_instance
*pim
;
266 struct rp_info
*rp_info
;
267 struct route_node
*rn
;
272 EVENT_OFF(bsrp
->g2rp_timer
);
273 bsgrp_node
= bsrp
->bsgrp_node
;
275 /* elapse time is the hold time of expired node */
276 elapse
= bsrp
->rp_holdtime
;
277 bsrp_addr
= bsrp
->rp_address
;
279 /* update elapse for all bsrp nodes */
280 frr_each_safe (bsm_rpinfos
, bsgrp_node
->bsrp_list
, bsrp_node
) {
281 bsrp_node
->elapse_time
+= elapse
;
283 if (is_hold_time_elapsed(bsrp_node
)) {
284 bsm_rpinfos_del(bsgrp_node
->bsrp_list
, bsrp_node
);
285 pim_bsm_rpinfo_free(bsrp_node
);
289 /* Get the next elected rp node */
290 bsrp
= bsm_rpinfos_first(bsgrp_node
->bsrp_list
);
291 pim
= bsgrp_node
->scope
->pim
;
292 rn
= route_node_lookup(pim
->rp_table
, &bsgrp_node
->group
);
295 zlog_warn("%s: Route node doesn't exist", __func__
);
299 rp_info
= (struct rp_info
*)rn
->info
;
302 route_unlock_node(rn
);
306 if (rp_info
->rp_src
!= RP_SRC_STATIC
) {
307 /* If new rp available, change it else delete the existing */
309 pim_g2rp_timer_start(
310 bsrp
, (bsrp
->rp_holdtime
- bsrp
->elapse_time
));
311 pim_rp_change(pim
, bsrp
->rp_address
, bsgrp_node
->group
,
314 pim_rp_del(pim
, bsrp_addr
, bsgrp_node
->group
, NULL
,
319 if (!bsm_rpinfos_count(bsgrp_node
->bsrp_list
)
320 && !bsm_rpinfos_count(bsgrp_node
->partial_bsrp_list
)) {
321 pim_free_bsgrp_node(pim
->global_scope
.bsrp_table
,
323 pim_free_bsgrp_data(bsgrp_node
);
327 static void pim_g2rp_timer_start(struct bsm_rpinfo
*bsrp
, int hold_time
)
331 zlog_debug("%s : Invalid brsp(NULL).", __func__
);
334 EVENT_OFF(bsrp
->g2rp_timer
);
337 "%s : starting g2rp timer for grp: %pFX - rp: %pPAs with timeout %d secs(Actual Hold time : %d secs)",
338 __func__
, &bsrp
->bsgrp_node
->group
, &bsrp
->rp_address
,
339 hold_time
, bsrp
->rp_holdtime
);
341 event_add_timer(router
->master
, pim_on_g2rp_timer
, bsrp
, hold_time
,
345 static inline void pim_g2rp_timer_restart(struct bsm_rpinfo
*bsrp
,
348 pim_g2rp_timer_start(bsrp
, hold_time
);
351 static void pim_g2rp_timer_stop(struct bsm_rpinfo
*bsrp
)
357 zlog_debug("%s : stopping g2rp timer for grp: %pFX - rp: %pPAs",
358 __func__
, &bsrp
->bsgrp_node
->group
,
361 EVENT_OFF(bsrp
->g2rp_timer
);
364 static bool is_hold_time_zero(void *data
)
366 struct bsm_rpinfo
*bsrp
;
370 if (bsrp
->rp_holdtime
)
376 static void pim_instate_pend_list(struct bsgrp_node
*bsgrp_node
)
378 struct bsm_rpinfo
*active
;
379 struct bsm_rpinfo
*pend
;
380 struct rp_info
*rp_info
;
381 struct route_node
*rn
;
382 struct pim_instance
*pim
;
383 struct rp_info
*rp_all
;
384 struct prefix group_all
;
385 bool had_rp_node
= true;
387 pim
= bsgrp_node
->scope
->pim
;
388 active
= bsm_rpinfos_first(bsgrp_node
->bsrp_list
);
390 /* Remove nodes with hold time 0 & check if list still has a head */
391 frr_each_safe (bsm_rpinfos
, bsgrp_node
->partial_bsrp_list
, pend
) {
392 if (is_hold_time_zero(pend
)) {
393 bsm_rpinfos_del(bsgrp_node
->partial_bsrp_list
, pend
);
394 pim_bsm_rpinfo_free(pend
);
398 pend
= bsm_rpinfos_first(bsgrp_node
->partial_bsrp_list
);
400 if (!pim_get_all_mcast_group(&group_all
))
403 rp_all
= pim_rp_find_match_group(pim
, &group_all
);
404 rn
= route_node_lookup(pim
->rp_table
, &bsgrp_node
->group
);
407 pim_g2rp_timer_start(pend
, pend
->rp_holdtime
);
409 /* if rp node doesn't exist or exist but not configured(rp_all),
410 * install the rp from head(if exists) of partial list. List is
411 * is sorted such that head is the elected RP for the group.
413 if (!rn
|| (prefix_same(&rp_all
->group
, &bsgrp_node
->group
) &&
414 pim_rpf_addr_is_inaddr_any(&rp_all
->rp
))) {
416 zlog_debug("%s: Route node doesn't exist", __func__
);
418 pim_rp_new(pim
, pend
->rp_address
, bsgrp_node
->group
,
422 rp_info
= (struct rp_info
*)rn
->info
;
424 route_unlock_node(rn
);
426 pim_rp_new(pim
, pend
->rp_address
,
427 bsgrp_node
->group
, NULL
, RP_SRC_BSR
);
432 /* We didn't have rp node and pending list is empty(unlikely), cleanup*/
433 if ((!had_rp_node
) && (!pend
)) {
434 pim_free_bsgrp_node(bsgrp_node
->scope
->bsrp_table
,
436 pim_free_bsgrp_data(bsgrp_node
);
440 if ((had_rp_node
) && (rp_info
->rp_src
!= RP_SRC_STATIC
)) {
441 /* This means we searched and got rp node, needs unlock */
442 route_unlock_node(rn
);
444 if (active
&& pend
) {
445 if (pim_addr_cmp(active
->rp_address
, pend
->rp_address
))
446 pim_rp_change(pim
, pend
->rp_address
,
447 bsgrp_node
->group
, RP_SRC_BSR
);
450 /* Possible when the first BSM has group with 0 rp count */
451 if ((!active
) && (!pend
)) {
454 "%s: Both bsrp and partial list are empty",
457 pim_free_bsgrp_node(bsgrp_node
->scope
->bsrp_table
,
459 pim_free_bsgrp_data(bsgrp_node
);
463 /* Possible when a group with 0 rp count received in BSM */
464 if ((active
) && (!pend
)) {
465 pim_rp_del(pim
, active
->rp_address
, bsgrp_node
->group
,
467 pim_free_bsgrp_node(bsgrp_node
->scope
->bsrp_table
,
470 zlog_debug("%s:Pend List is null,del grp node",
473 pim_free_bsgrp_data(bsgrp_node
);
478 if ((had_rp_node
) && (rp_info
->rp_src
== RP_SRC_STATIC
)) {
479 /* We need to unlock rn this case */
480 route_unlock_node(rn
);
481 /* there is a chance that static rp exist and bsrp cleaned
482 * so clean bsgrp node if pending list empty
487 "%s: Partial list is empty, static rp exists",
489 pim_free_bsgrp_node(bsgrp_node
->scope
->bsrp_table
,
491 pim_free_bsgrp_data(bsgrp_node
);
496 /* swap the list & delete all nodes in partial list (old bsrp_list)
498 * active is head of bsrp list
499 * pend is head of partial list
501 * active is head of partial list
502 * pend is head of bsrp list
503 * So check appriate head after swap and clean the new partial list
505 bsm_rpinfos_swap_all(bsgrp_node
->bsrp_list
,
506 bsgrp_node
->partial_bsrp_list
);
509 pim_g2rp_timer_stop(active
);
510 pim_bsm_rpinfos_free(bsgrp_node
->partial_bsrp_list
);
513 static bool is_preferred_bsr(struct pim_instance
*pim
, pim_addr bsr
,
516 if (!pim_addr_cmp(bsr
, pim
->global_scope
.current_bsr
))
519 if (bsr_prio
> pim
->global_scope
.current_bsr_prio
)
522 else if (bsr_prio
== pim
->global_scope
.current_bsr_prio
) {
523 if (pim_addr_cmp(bsr
, pim
->global_scope
.current_bsr
) >= 0)
531 static void pim_bsm_update(struct pim_instance
*pim
, pim_addr bsr
,
534 if (pim_addr_cmp(bsr
, pim
->global_scope
.current_bsr
)) {
535 pim_nht_bsr_del(pim
, pim
->global_scope
.current_bsr
);
536 pim_nht_bsr_add(pim
, bsr
);
538 pim
->global_scope
.current_bsr
= bsr
;
539 pim
->global_scope
.current_bsr_first_ts
=
540 pim_time_monotonic_sec();
541 pim
->global_scope
.state
= ACCEPT_PREFERRED
;
543 pim
->global_scope
.current_bsr_prio
= bsr_prio
;
544 pim
->global_scope
.current_bsr_last_ts
= pim_time_monotonic_sec();
547 void pim_bsm_clear(struct pim_instance
*pim
)
549 struct route_node
*rn
;
550 struct route_node
*rpnode
;
551 struct bsgrp_node
*bsgrp
;
554 struct rp_info
*rp_all
;
555 struct pim_upstream
*up
;
556 struct rp_info
*rp_info
;
557 bool upstream_updated
= false;
559 pim_nht_bsr_del(pim
, pim
->global_scope
.current_bsr
);
561 /* Reset scope zone data */
562 pim
->global_scope
.accept_nofwd_bsm
= false;
563 pim
->global_scope
.state
= ACCEPT_ANY
;
564 pim
->global_scope
.current_bsr
= PIMADDR_ANY
;
565 pim
->global_scope
.current_bsr_prio
= 0;
566 pim
->global_scope
.current_bsr_first_ts
= 0;
567 pim
->global_scope
.current_bsr_last_ts
= 0;
568 pim
->global_scope
.bsm_frag_tag
= 0;
569 pim_bsm_frags_free(&pim
->global_scope
);
571 pim_bs_timer_stop(&pim
->global_scope
);
573 for (rn
= route_top(pim
->global_scope
.bsrp_table
); rn
;
574 rn
= route_next(rn
)) {
579 rpnode
= route_node_lookup(pim
->rp_table
, &bsgrp
->group
);
582 pim_free_bsgrp_node(bsgrp
->scope
->bsrp_table
,
584 pim_free_bsgrp_data(bsgrp
);
588 rp_info
= (struct rp_info
*)rpnode
->info
;
590 if ((!rp_info
) || (rp_info
->rp_src
!= RP_SRC_BSR
)) {
591 pim_free_bsgrp_node(bsgrp
->scope
->bsrp_table
,
593 pim_free_bsgrp_data(bsgrp
);
597 /* Deregister addr with Zebra NHT */
598 nht_p
= rp_info
->rp
.rpf_addr
;
600 if (PIM_DEBUG_PIM_NHT_RP
) {
601 zlog_debug("%s: Deregister RP addr %pPA with Zebra ",
605 pim_delete_tracked_nexthop(pim
, nht_p
, NULL
, rp_info
);
607 if (!pim_get_all_mcast_group(&g_all
))
610 rp_all
= pim_rp_find_match_group(pim
, &g_all
);
612 if (rp_all
== rp_info
) {
613 rp_all
->rp
.rpf_addr
= PIMADDR_ANY
;
616 /* Delete the rp_info from rp-list */
617 listnode_delete(pim
->rp_list
, rp_info
);
619 /* Delete the rp node from rp_table */
621 route_unlock_node(rpnode
);
622 route_unlock_node(rpnode
);
623 XFREE(MTYPE_PIM_RP
, rp_info
);
626 pim_free_bsgrp_node(bsgrp
->scope
->bsrp_table
, &bsgrp
->group
);
627 pim_free_bsgrp_data(bsgrp
);
629 pim_rp_refresh_group_to_rp_mapping(pim
);
632 frr_each (rb_pim_upstream
, &pim
->upstream_head
, up
) {
633 /* Find the upstream (*, G) whose upstream address is same as
636 if (!pim_addr_is_any(up
->sg
.src
))
640 struct rp_info
*trp_info
;
642 pim_addr_to_prefix(&grp
, up
->sg
.grp
);
643 trp_info
= pim_rp_find_match_group(pim
, &grp
);
645 /* RP not found for the group grp */
646 if (pim_rpf_addr_is_inaddr_any(&trp_info
->rp
)) {
647 pim_upstream_rpf_clear(pim
, up
);
648 pim_rp_set_upstream_addr(pim
, &up
->upstream_addr
,
649 up
->sg
.src
, up
->sg
.grp
);
651 /* RP found for the group grp */
652 pim_upstream_update(pim
, up
);
653 upstream_updated
= true;
657 if (upstream_updated
)
658 pim_zebra_update_all_interfaces(pim
);
661 static bool pim_bsm_send_intf(uint8_t *buf
, int len
, struct interface
*ifp
,
664 struct pim_interface
*pim_ifp
;
670 zlog_debug("%s: Pim interface not available for %s",
671 __func__
, ifp
->name
);
675 if (pim_ifp
->pim_sock_fd
== -1) {
677 zlog_debug("%s: Pim sock not available for %s",
678 __func__
, ifp
->name
);
682 if (pim_msg_send(pim_ifp
->pim_sock_fd
, pim_ifp
->primary_address
,
683 dst_addr
, buf
, len
, ifp
)) {
684 zlog_warn("%s: Could not send BSM message on interface: %s",
685 __func__
, ifp
->name
);
689 if (!pim_ifp
->pim_passive_enable
)
690 pim_ifp
->pim_ifstat_bsm_tx
++;
692 pim_ifp
->pim
->bsm_sent
++;
696 static bool pim_bsm_frag_send(uint8_t *buf
, uint32_t len
, struct interface
*ifp
,
697 uint32_t pim_mtu
, pim_addr dst_addr
, bool no_fwd
)
699 struct pim_interface
*pim_ifp
= ifp
->info
;
700 struct bsmmsg_grpinfo
*grpinfo
, *curgrp
;
701 uint8_t *firstgrp_ptr
;
704 uint32_t parsed_len
= 0;
705 uint32_t this_pkt_rem
;
706 uint32_t copy_byte_count
;
707 uint32_t this_pkt_len
;
708 uint8_t total_rp_cnt
;
712 bool pak_pending
= false;
714 /* MTU passed here is PIM MTU (IP MTU less IP Hdr) */
715 if (pim_mtu
< (PIM_MIN_BSM_LEN
)) {
717 "%s: mtu(pim mtu: %d) size less than minimum bootstrap len",
721 "%s: mtu (pim mtu:%d) less than minimum bootstrap len",
726 pak_start
= XCALLOC(MTYPE_PIM_BSM_PKT_VAR_MEM
, pim_mtu
);
730 /* Fill PIM header later before sending packet to calc checksum */
731 pkt
+= PIM_MSG_HEADER_LEN
;
732 buf
+= PIM_MSG_HEADER_LEN
;
734 /* copy bsm header to new packet at offset of pim hdr */
735 memcpy(pkt
, buf
, PIM_BSM_HDR_LEN
);
736 pkt
+= PIM_BSM_HDR_LEN
;
737 buf
+= PIM_BSM_HDR_LEN
;
738 parsed_len
+= (PIM_MSG_HEADER_LEN
+ PIM_BSM_HDR_LEN
);
740 /* Store the position of first grp ptr, which can be reused for
741 * next packet to start filling group. old bsm header and pim hdr
742 * remains. So need not be filled again for next packet onwards.
746 /* we received mtu excluding IP hdr len as param
747 * now this_pkt_rem is mtu excluding
748 * PIM_BSM_HDR_LEN + PIM_MSG_HEADER_LEN
750 this_pkt_rem
= pim_mtu
- (PIM_BSM_HDR_LEN
+ PIM_MSG_HEADER_LEN
);
752 /* For each group till the packet length parsed */
753 while (parsed_len
< len
) {
754 /* pkt ---> fragment's current pointer
755 * buf ---> input buffer's current pointer
756 * mtu ---> size of the pim packet - PIM header
757 * curgrp ---> current group on the fragment
758 * grpinfo ---> current group on the input buffer
759 * this_pkt_rem ---> bytes remaing on the current fragment
760 * rp_fit_cnt ---> num of rp for current grp that
762 * total_rp_cnt ---> total rp present for the group in the buf
763 * frag_rp_cnt ---> no of rp for the group to be fit in
765 * this_rp_cnt ---> how many rp have we parsed
767 grpinfo
= (struct bsmmsg_grpinfo
*)buf
;
768 memcpy(pkt
, buf
, PIM_BSM_GRP_LEN
);
769 curgrp
= (struct bsmmsg_grpinfo
*)pkt
;
770 parsed_len
+= PIM_BSM_GRP_LEN
;
771 pkt
+= PIM_BSM_GRP_LEN
;
772 buf
+= PIM_BSM_GRP_LEN
;
773 this_pkt_rem
-= PIM_BSM_GRP_LEN
;
775 /* initialize rp count and total_rp_cnt before the rp loop */
777 total_rp_cnt
= grpinfo
->frag_rp_count
;
779 /* Loop till all RPs for the group parsed */
780 while (this_rp_cnt
< total_rp_cnt
) {
781 /* All RP from a group processed here.
782 * group is pointed by grpinfo.
783 * At this point make sure buf pointing to a RP
786 rp_fit_cnt
= this_pkt_rem
/ PIM_BSM_RP_LEN
;
788 /* calculate how many rp am i going to copy in
791 if (rp_fit_cnt
> (total_rp_cnt
- this_rp_cnt
))
792 frag_rp_cnt
= total_rp_cnt
- this_rp_cnt
;
794 frag_rp_cnt
= rp_fit_cnt
;
796 /* populate the frag rp count for the current grp */
797 curgrp
->frag_rp_count
= frag_rp_cnt
;
798 copy_byte_count
= frag_rp_cnt
* PIM_BSM_RP_LEN
;
800 /* copy all the rp that we are fitting in this
803 memcpy(pkt
, buf
, copy_byte_count
);
804 this_rp_cnt
+= frag_rp_cnt
;
805 buf
+= copy_byte_count
;
806 pkt
+= copy_byte_count
;
807 parsed_len
+= copy_byte_count
;
808 this_pkt_rem
-= copy_byte_count
;
810 /* Either we couldn't fit all rp for the group or the
813 if ((this_rp_cnt
< total_rp_cnt
)
815 < (PIM_BSM_GRP_LEN
+ PIM_BSM_RP_LEN
))) {
816 /* No space to fit in more rp, send this pkt */
817 this_pkt_len
= pim_mtu
- this_pkt_rem
;
818 pim_msg_build_header(
819 pim_ifp
->primary_address
, dst_addr
,
820 pak_start
, this_pkt_len
,
821 PIM_MSG_TYPE_BOOTSTRAP
, no_fwd
);
822 pim_bsm_send_intf(pak_start
, this_pkt_len
, ifp
,
825 /* Construct next fragment. Reuse old packet */
827 this_pkt_rem
= pim_mtu
- (PIM_BSM_HDR_LEN
828 + PIM_MSG_HEADER_LEN
);
830 /* If pkt can't accommodate next group + at
831 * least one rp, we must break out of this inner
832 * loop and process next RP
834 if (total_rp_cnt
== this_rp_cnt
)
837 /* If some more RPs for the same group pending,
840 memcpy(pkt
, (uint8_t *)grpinfo
,
842 curgrp
= (struct bsmmsg_grpinfo
*)pkt
;
843 pkt
+= PIM_BSM_GRP_LEN
;
844 this_pkt_rem
-= PIM_BSM_GRP_LEN
;
847 /* We filled something but not yet sent out */
850 } /* while RP count */
851 } /*while parsed len */
853 /* Send if we have any unsent packet */
855 this_pkt_len
= pim_mtu
- this_pkt_rem
;
856 pim_msg_build_header(pim_ifp
->primary_address
, dst_addr
,
857 pak_start
, this_pkt_len
,
858 PIM_MSG_TYPE_BOOTSTRAP
, no_fwd
);
859 pim_bsm_send_intf(pak_start
, (pim_mtu
- this_pkt_rem
), ifp
,
862 XFREE(MTYPE_PIM_BSM_PKT_VAR_MEM
, pak_start
);
866 static void pim_bsm_fwd_whole_sz(struct pim_instance
*pim
, uint8_t *buf
,
867 uint32_t len
, int sz
)
869 struct interface
*ifp
;
870 struct pim_interface
*pim_ifp
;
876 /* For now only global scope zone is supported, so send on all
877 * pim interfaces in the vrf
879 dst_addr
= qpim_all_pim_routers_addr
;
880 FOR_ALL_INTERFACES (pim
->vrf
, ifp
) {
882 if ((!pim_ifp
) || (!pim_ifp
->bsm_enable
))
887 * When a Bootstrap message is forwarded, it is forwarded out
888 * of every multicast-capable interface that has PIM neighbors.
890 * So skipping pim interfaces with no neighbors.
892 if (listcount(pim_ifp
->pim_neighbor_list
) == 0)
895 pim_hello_require(ifp
);
896 pim_mtu
= ifp
->mtu
- MAX_IP_HDR_LEN
;
898 ret
= pim_bsm_frag_send(buf
, len
, ifp
, pim_mtu
,
901 zlog_debug("%s: pim_bsm_frag_send returned %s",
902 __func__
, ret
? "TRUE" : "FALSE");
904 pim_msg_build_header(pim_ifp
->primary_address
, dst_addr
,
905 buf
, len
, PIM_MSG_TYPE_BOOTSTRAP
,
907 if (!pim_bsm_send_intf(buf
, len
, ifp
, dst_addr
)) {
910 "%s: pim_bsm_send_intf returned false",
917 bool pim_bsm_new_nbr_fwd(struct pim_neighbor
*neigh
, struct interface
*ifp
)
920 struct pim_interface
*pim_ifp
;
921 struct bsm_scope
*scope
;
922 struct bsm_frag
*bsfrag
;
928 zlog_debug("%s: New neighbor %pPA seen on %s", __func__
,
929 &neigh
->source_addr
, ifp
->name
);
933 /* DR only forwards BSM packet */
934 if (!pim_addr_cmp(pim_ifp
->pim_dr_addr
, pim_ifp
->primary_address
)) {
937 "%s: It is not DR, so don't forward BSM packet",
941 if (!pim_ifp
->bsm_enable
) {
943 zlog_debug("%s: BSM proc not enabled on %s", __func__
,
948 scope
= &pim_ifp
->pim
->global_scope
;
950 if (!bsm_frags_count(scope
->bsm_frags
)) {
952 zlog_debug("%s: BSM list for the scope is empty",
957 if (!pim_ifp
->ucast_bsm_accept
) {
958 dst_addr
= qpim_all_pim_routers_addr
;
960 zlog_debug("%s: Sending BSM mcast to %pPA", __func__
,
961 &neigh
->source_addr
);
963 dst_addr
= neigh
->source_addr
;
965 zlog_debug("%s: Sending BSM ucast to %pPA", __func__
,
966 &neigh
->source_addr
);
968 pim_mtu
= ifp
->mtu
- MAX_IP_HDR_LEN
;
969 pim_hello_require(ifp
);
971 frr_each (bsm_frags
, scope
->bsm_frags
, bsfrag
) {
972 if (pim_mtu
< bsfrag
->size
) {
973 ret
= pim_bsm_frag_send(bsfrag
->data
, bsfrag
->size
, ifp
,
974 pim_mtu
, dst_addr
, no_fwd
);
978 "%s: pim_bsm_frag_send failed",
982 /* Pim header needs to be constructed */
983 pim_msg_build_header(pim_ifp
->primary_address
, dst_addr
,
984 bsfrag
->data
, bsfrag
->size
,
985 PIM_MSG_TYPE_BOOTSTRAP
, no_fwd
);
986 ret
= pim_bsm_send_intf(bsfrag
->data
, bsfrag
->size
, ifp
,
991 "%s: pim_bsm_frag_send failed",
999 struct bsgrp_node
*pim_bsm_get_bsgrp_node(struct bsm_scope
*scope
,
1002 struct route_node
*rn
;
1003 struct bsgrp_node
*bsgrp
;
1005 rn
= route_node_lookup(scope
->bsrp_table
, grp
);
1008 zlog_debug("%s: Route node doesn't exist for the group",
1013 route_unlock_node(rn
);
1018 static uint32_t hash_calc_on_grp_rp(struct prefix group
, pim_addr rp
,
1019 uint8_t hashmasklen
)
1025 uint32_t mask
= 0xffffffff;
1027 /* mask to be made zero if hashmasklen is 0 because mask << 32
1028 * may not give 0. hashmasklen can be 0 to 32.
1030 if (hashmasklen
== 0)
1033 /* in_addr stores ip in big endian, hence network byte order
1034 * convert to uint32 before processing hash
1037 grpaddr
= ntohl(group
.u
.prefix4
.s_addr
);
1039 grpaddr
= group
.u
.prefix6
.s6_addr32
[0] ^ group
.u
.prefix6
.s6_addr32
[1] ^
1040 group
.u
.prefix6
.s6_addr32
[2] ^ group
.u
.prefix6
.s6_addr32
[3];
1042 /* Avoid shifting by 32 bit on a 32 bit register */
1044 grpaddr
= grpaddr
& ((mask
<< (32 - hashmasklen
)));
1046 grpaddr
= grpaddr
& mask
;
1049 rp_add
= ntohl(rp
.s_addr
);
1051 rp_add
= rp
.s6_addr32
[0] ^ rp
.s6_addr32
[1] ^ rp
.s6_addr32
[2] ^
1054 temp
= 1103515245 * ((1103515245 * (uint64_t)grpaddr
+ 12345) ^ rp_add
)
1056 hash
= temp
& (0x7fffffff);
1060 static bool pim_install_bsm_grp_rp(struct pim_instance
*pim
,
1061 struct bsgrp_node
*grpnode
,
1062 struct bsmmsg_rpinfo
*rp
)
1064 struct bsm_rpinfo
*bsm_rpinfo
;
1065 uint8_t hashMask_len
= pim
->global_scope
.hashMasklen
;
1067 /*memory allocation for bsm_rpinfo */
1068 bsm_rpinfo
= XCALLOC(MTYPE_PIM_BSRP_INFO
, sizeof(*bsm_rpinfo
));
1070 bsm_rpinfo
->rp_prio
= rp
->rp_pri
;
1071 bsm_rpinfo
->rp_holdtime
= rp
->rp_holdtime
;
1072 bsm_rpinfo
->rp_address
= rp
->rpaddr
.addr
;
1073 bsm_rpinfo
->elapse_time
= 0;
1075 /* Back pointer to the group node. */
1076 bsm_rpinfo
->bsgrp_node
= grpnode
;
1078 /* update hash for this rp node */
1079 bsm_rpinfo
->hash
= hash_calc_on_grp_rp(grpnode
->group
, rp
->rpaddr
.addr
,
1081 if (bsm_rpinfos_add(grpnode
->partial_bsrp_list
, bsm_rpinfo
) == NULL
) {
1084 "%s, bs_rpinfo node added to the partial bs_rplist.",
1090 zlog_debug("%s: list node not added", __func__
);
1092 XFREE(MTYPE_PIM_BSRP_INFO
, bsm_rpinfo
);
1096 static void pim_update_pending_rp_cnt(struct bsm_scope
*sz
,
1097 struct bsgrp_node
*bsgrp
,
1098 uint16_t bsm_frag_tag
,
1099 uint32_t total_rp_count
)
1101 if (bsgrp
->pend_rp_cnt
) {
1102 /* received bsm is different packet ,
1103 * it is not same fragment.
1105 if (bsm_frag_tag
!= bsgrp
->frag_tag
) {
1108 "%s,Received a new BSM ,so clear the pending bs_rpinfo list.",
1110 pim_bsm_rpinfos_free(bsgrp
->partial_bsrp_list
);
1111 bsgrp
->pend_rp_cnt
= total_rp_count
;
1114 bsgrp
->pend_rp_cnt
= total_rp_count
;
1116 bsgrp
->frag_tag
= bsm_frag_tag
;
1119 /* Parsing BSR packet and adding to partial list of corresponding bsgrp node */
1120 static bool pim_bsm_parse_install_g2rp(struct bsm_scope
*scope
, uint8_t *buf
,
1121 int buflen
, uint16_t bsm_frag_tag
)
1123 struct bsmmsg_grpinfo grpinfo
;
1124 struct bsmmsg_rpinfo rpinfo
;
1125 struct prefix group
;
1126 struct bsgrp_node
*bsgrp
= NULL
;
1127 int frag_rp_cnt
= 0;
1132 while (buflen
> offset
) {
1133 if (offset
+ (int)sizeof(struct bsmmsg_grpinfo
) > buflen
) {
1136 "%s: buflen received %d is less than the internal data structure of the packet would suggest",
1140 /* Extract Group tlv from BSM */
1141 memcpy(&grpinfo
, buf
, sizeof(struct bsmmsg_grpinfo
));
1142 grp_addr
= grpinfo
.group
.addr
;
1146 "%s, Group %pPAs Rpcount:%d Fragment-Rp-count:%d",
1147 __func__
, &grp_addr
, grpinfo
.rp_count
,
1148 grpinfo
.frag_rp_count
);
1150 buf
+= sizeof(struct bsmmsg_grpinfo
);
1151 offset
+= sizeof(struct bsmmsg_grpinfo
);
1153 group
.family
= PIM_AF
;
1154 if (grpinfo
.group
.mask
> PIM_MAX_BITLEN
) {
1157 "%s, prefix length specified: %d is too long",
1158 __func__
, grpinfo
.group
.mask
);
1162 pim_addr_to_prefix(&group
, grp_addr
);
1163 group
.prefixlen
= grpinfo
.group
.mask
;
1165 /* Get the Group node for the BSM rp table */
1166 bsgrp
= pim_bsm_get_bsgrp_node(scope
, &group
);
1168 if (grpinfo
.rp_count
== 0) {
1169 struct bsm_rpinfo
*old_rpinfo
;
1171 /* BSR explicitly no longer has RPs for this group */
1177 "%s, Rp count is zero for group: %pPAs",
1178 __func__
, &grp_addr
);
1180 old_rpinfo
= bsm_rpinfos_first(bsgrp
->bsrp_list
);
1182 pim_rp_del(scope
->pim
, old_rpinfo
->rp_address
,
1183 group
, NULL
, RP_SRC_BSR
);
1185 pim_free_bsgrp_node(scope
->bsrp_table
, &bsgrp
->group
);
1186 pim_free_bsgrp_data(bsgrp
);
1192 zlog_debug("%s, Create new BSM Group node.",
1195 /* create a new node to be added to the tree. */
1196 bsgrp
= pim_bsm_new_bsgrp_node(scope
->bsrp_table
,
1201 "%s, Failed to get the BSM group node.",
1206 bsgrp
->scope
= scope
;
1209 pim_update_pending_rp_cnt(scope
, bsgrp
, bsm_frag_tag
,
1211 frag_rp_cnt
= grpinfo
.frag_rp_count
;
1214 while (frag_rp_cnt
--) {
1215 if (offset
+ (int)sizeof(struct bsmmsg_rpinfo
)
1219 "%s, buflen received: %u is less than the internal data structure of the packet would suggest",
1224 /* Extract RP address tlv from BSM */
1225 memcpy(&rpinfo
, buf
, sizeof(struct bsmmsg_rpinfo
));
1226 rpinfo
.rp_holdtime
= ntohs(rpinfo
.rp_holdtime
);
1227 buf
+= sizeof(struct bsmmsg_rpinfo
);
1228 offset
+= sizeof(struct bsmmsg_rpinfo
);
1230 if (PIM_DEBUG_BSM
) {
1233 rp_addr
= rpinfo
.rpaddr
.addr
;
1235 "%s, Rp address - %pPAs; pri:%d hold:%d",
1236 __func__
, &rp_addr
, rpinfo
.rp_pri
,
1237 rpinfo
.rp_holdtime
);
1240 /* Call Install api to update grp-rp mappings */
1241 if (pim_install_bsm_grp_rp(scope
->pim
, bsgrp
, &rpinfo
))
1245 bsgrp
->pend_rp_cnt
-= ins_count
;
1247 if (!bsgrp
->pend_rp_cnt
) {
1250 "%s, Recvd all the rps for this group, so bsrp list with penidng rp list.",
1252 /* replace the bsrp_list with pending list */
1253 pim_instate_pend_list(bsgrp
);
1259 int pim_bsm_process(struct interface
*ifp
, pim_sgaddr
*sg
, uint8_t *buf
,
1260 uint32_t buf_size
, bool no_fwd
)
1262 struct bsm_hdr
*bshdr
;
1263 int sz
= PIM_GBL_SZ_ID
;
1264 struct bsmmsg_grpinfo
*msg_grp
;
1265 struct pim_interface
*pim_ifp
= NULL
;
1266 struct bsm_frag
*bsfrag
;
1267 struct pim_instance
*pim
;
1270 bool empty_bsm
= false;
1272 /* BSM Packet acceptance validation */
1273 pim_ifp
= ifp
->info
;
1276 zlog_debug("%s: multicast not enabled on interface %s",
1277 __func__
, ifp
->name
);
1281 if (pim_ifp
->pim_passive_enable
) {
1282 if (PIM_DEBUG_PIM_PACKETS
)
1284 "skip receiving PIM message on passive interface %s",
1289 pim_ifp
->pim_ifstat_bsm_rx
++;
1293 /* Drop if bsm processing is disabled on interface */
1294 if (!pim_ifp
->bsm_enable
) {
1295 zlog_warn("%s: BSM not enabled on interface %s", __func__
,
1297 pim_ifp
->pim_ifstat_bsm_cfg_miss
++;
1302 if (buf_size
< (PIM_MSG_HEADER_LEN
+ sizeof(struct bsm_hdr
))) {
1305 "%s: received buffer length of %d which is too small to properly decode",
1306 __func__
, buf_size
);
1310 bshdr
= (struct bsm_hdr
*)(buf
+ PIM_MSG_HEADER_LEN
);
1311 if (bshdr
->hm_len
> PIM_MAX_BITLEN
) {
1313 "Bad hashmask length for %s; got %hhu, expected value in range 0-32",
1314 PIM_AF_NAME
, bshdr
->hm_len
);
1318 pim
->global_scope
.hashMasklen
= bshdr
->hm_len
;
1319 frag_tag
= ntohs(bshdr
->frag_tag
);
1320 /* NB: bshdr->bsr_addr.addr is packed/unaligned => memcpy */
1321 memcpy(&bsr_addr
, &bshdr
->bsr_addr
.addr
, sizeof(bsr_addr
));
1323 /* Identify empty BSM */
1324 if ((buf_size
- PIM_BSM_HDR_LEN
- PIM_MSG_HEADER_LEN
) < PIM_BSM_GRP_LEN
)
1328 msg_grp
= (struct bsmmsg_grpinfo
*)(buf
+ PIM_MSG_HEADER_LEN
1330 /* Currently we don't support scope zoned BSM */
1331 if (msg_grp
->group
.sz
) {
1334 "%s : Administratively scoped range BSM received",
1336 pim_ifp
->pim_ifstat_bsm_invalid_sz
++;
1342 /* Drop if bsr is not preferred bsr */
1343 if (!is_preferred_bsr(pim
, bsr_addr
, bshdr
->bsr_prio
)) {
1345 zlog_debug("%s : Received a non-preferred BSM",
1352 /* only accept no-forward BSM if quick refresh on startup */
1353 if ((pim
->global_scope
.accept_nofwd_bsm
)
1354 || (frag_tag
== pim
->global_scope
.bsm_frag_tag
)) {
1355 pim
->global_scope
.accept_nofwd_bsm
= false;
1359 "%s : nofwd_bsm received on %pPAs when accpt_nofwd_bsm false",
1360 __func__
, &bsr_addr
);
1362 pim_ifp
->pim_ifstat_ucast_bsm_cfg_miss
++;
1367 if (!pim_addr_cmp(sg
->grp
, qpim_all_pim_routers_addr
)) {
1368 /* Multicast BSMs are only accepted if source interface & IP
1369 * match RPF towards the BSR's IP address, or they have
1373 !pim_nht_bsr_rpf_check(pim
, bsr_addr
, ifp
, sg
->src
)) {
1376 "BSM check: RPF to BSR %pPAs is not %pPA%%%s",
1377 &bsr_addr
, &sg
->src
, ifp
->name
);
1381 } else if (if_address_is_local(&sg
->grp
, PIM_AF
, pim
->vrf
->vrf_id
)) {
1382 /* Unicast BSM received - if ucast bsm not enabled on
1383 * the interface, drop it
1385 if (!pim_ifp
->ucast_bsm_accept
) {
1388 "%s : Unicast BSM not enabled on interface %s",
1389 __func__
, ifp
->name
);
1390 pim_ifp
->pim_ifstat_ucast_bsm_cfg_miss
++;
1397 zlog_debug("%s : Invalid destination address",
1405 zlog_debug("%s : Empty Pref BSM received", __func__
);
1407 /* Parse Update bsm rp table and install/uninstall rp if required */
1408 if (!pim_bsm_parse_install_g2rp(
1409 &pim_ifp
->pim
->global_scope
,
1410 (buf
+ PIM_BSM_HDR_LEN
+ PIM_MSG_HEADER_LEN
),
1411 (buf_size
- PIM_BSM_HDR_LEN
- PIM_MSG_HEADER_LEN
),
1413 if (PIM_DEBUG_BSM
) {
1414 zlog_debug("%s, Parsing BSM failed.", __func__
);
1419 /* Restart the bootstrap timer */
1420 pim_bs_timer_restart(&pim_ifp
->pim
->global_scope
,
1421 PIM_BSR_DEFAULT_TIMEOUT
);
1423 /* If new BSM received, clear the old bsm database */
1424 if (pim_ifp
->pim
->global_scope
.bsm_frag_tag
!= frag_tag
) {
1425 if (PIM_DEBUG_BSM
) {
1426 zlog_debug("%s: Current frag tag: %d Frag teg rcvd: %d",
1428 pim_ifp
->pim
->global_scope
.bsm_frag_tag
,
1431 pim_bsm_frags_free(&pim_ifp
->pim
->global_scope
);
1432 pim_ifp
->pim
->global_scope
.bsm_frag_tag
= frag_tag
;
1435 /* update the scope information from bsm */
1436 pim_bsm_update(pim
, bsr_addr
, bshdr
->bsr_prio
);
1439 pim_bsm_fwd_whole_sz(pim_ifp
->pim
, buf
, buf_size
, sz
);
1440 bsfrag
= XCALLOC(MTYPE_PIM_BSM_FRAG
,
1441 sizeof(struct bsm_frag
) + buf_size
);
1443 bsfrag
->size
= buf_size
;
1444 memcpy(bsfrag
->data
, buf
, buf_size
);
1445 bsm_frags_add_tail(pim_ifp
->pim
->global_scope
.bsm_frags
,