]> git.proxmox.com Git - mirror_frr.git/blob - pimd/pim_ifchannel.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
pimd: Handle rpf_addr in pim_ifchannel code
[mirror_frr.git] / pimd / pim_ifchannel.c
1 /*
2 * PIM for Quagga
3 * Copyright (C) 2008 Everton da Silva Marques
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include <zebra.h>
21
22 #include "linklist.h"
23 #include "thread.h"
24 #include "memory.h"
25 #include "if.h"
26 #include "vrf.h"
27 #include "hash.h"
28 #include "jhash.h"
29 #include "prefix.h"
30
31 #include "pimd.h"
32 #include "pim_instance.h"
33 #include "pim_str.h"
34 #include "pim_iface.h"
35 #include "pim_ifchannel.h"
36 #include "pim_zebra.h"
37 #include "pim_time.h"
38 #include "pim_msg.h"
39 #include "pim_pim.h"
40 #include "pim_join.h"
41 #include "pim_rpf.h"
42 #include "pim_macro.h"
43 #include "pim_oil.h"
44 #include "pim_upstream.h"
45 #include "pim_ssm.h"
46 #include "pim_rp.h"
47 #include "pim_mlag.h"
48
49 RB_GENERATE(pim_ifchannel_rb, pim_ifchannel, pim_ifp_rb, pim_ifchannel_compare);
50
51 int pim_ifchannel_compare(const struct pim_ifchannel *ch1,
52 const struct pim_ifchannel *ch2)
53 {
54 struct pim_interface *pim_ifp1;
55 struct pim_interface *pim_ifp2;
56
57 pim_ifp1 = ch1->interface->info;
58 pim_ifp2 = ch2->interface->info;
59
60 if (pim_ifp1->mroute_vif_index < pim_ifp2->mroute_vif_index)
61 return -1;
62
63 if (pim_ifp1->mroute_vif_index > pim_ifp2->mroute_vif_index)
64 return 1;
65
66 return pim_sgaddr_cmp(ch1->sg, ch2->sg);
67 }
68
69 /*
70 * A (*,G) or a (*,*) is going away
71 * remove the parent pointer from
72 * those pointing at us
73 */
74 static void pim_ifchannel_remove_children(struct pim_ifchannel *ch)
75 {
76 struct pim_ifchannel *child;
77
78 if (!ch->sources)
79 return;
80
81 while (!list_isempty(ch->sources)) {
82 child = listnode_head(ch->sources);
83 child->parent = NULL;
84 listnode_delete(ch->sources, child);
85 }
86 }
87
88 /*
89 * A (*,G) or a (*,*) is being created
90 * find all the children that would point
91 * at us.
92 */
93 static void pim_ifchannel_find_new_children(struct pim_ifchannel *ch)
94 {
95 struct pim_interface *pim_ifp = ch->interface->info;
96 struct pim_ifchannel *child;
97
98 // Basic Sanity that we are not being silly
99 if (!pim_addr_is_any(ch->sg.src) && !pim_addr_is_any(ch->sg.grp))
100 return;
101
102 if (pim_addr_is_any(ch->sg.src) && pim_addr_is_any(ch->sg.grp))
103 return;
104
105 RB_FOREACH (child, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
106 if (!pim_addr_is_any(ch->sg.grp) &&
107 !pim_addr_cmp(child->sg.grp, ch->sg.grp) && (child != ch)) {
108 child->parent = ch;
109 listnode_add_sort(ch->sources, child);
110 }
111 }
112 }
113
114 void pim_ifchannel_delete(struct pim_ifchannel *ch)
115 {
116 struct pim_interface *pim_ifp;
117 struct pim_upstream *up;
118
119 pim_ifp = ch->interface->info;
120
121 if (PIM_DEBUG_PIM_TRACE)
122 zlog_debug("%s: ifchannel entry %s(%s) del start", __func__,
123 ch->sg_str, ch->interface->name);
124
125 if (PIM_I_am_DualActive(pim_ifp)) {
126 if (PIM_DEBUG_MLAG)
127 zlog_debug(
128 "%s: if-chnanel-%s is deleted from a Dual active Interface",
129 __func__, ch->sg_str);
130 /* Post Delete only if it is the last Dual-active Interface */
131 if (ch->upstream->dualactive_ifchannel_count == 1) {
132 pim_mlag_up_local_del(pim_ifp->pim, ch->upstream);
133 PIM_UPSTREAM_FLAG_UNSET_MLAG_INTERFACE(
134 ch->upstream->flags);
135 }
136 ch->upstream->dualactive_ifchannel_count--;
137 }
138
139 if (ch->upstream->channel_oil) {
140 uint32_t mask = PIM_OIF_FLAG_PROTO_PIM;
141 if (ch->upstream->flags & PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
142 mask |= PIM_OIF_FLAG_PROTO_GM;
143
144 /*
145 * A S,G RPT channel can have an empty oil, we also
146 * need to take into account the fact that a ifchannel
147 * might have been suppressing a *,G ifchannel from
148 * being inherited. So let's figure out what
149 * needs to be done here
150 */
151 if (!pim_addr_is_any(ch->sg.src) &&
152 pim_upstream_evaluate_join_desired_interface(
153 ch->upstream, ch, ch->parent))
154 pim_channel_add_oif(ch->upstream->channel_oil,
155 ch->interface,
156 PIM_OIF_FLAG_PROTO_STAR,
157 __func__);
158
159 pim_channel_del_oif(ch->upstream->channel_oil,
160 ch->interface, mask, __func__);
161 /*
162 * Do we have any S,G's that are inheriting?
163 * Nuke from on high too.
164 */
165 if (ch->upstream->sources) {
166 struct pim_upstream *child;
167 struct listnode *up_node;
168
169 for (ALL_LIST_ELEMENTS_RO(ch->upstream->sources,
170 up_node, child))
171 pim_channel_del_inherited_oif(
172 child->channel_oil,
173 ch->interface,
174 __func__);
175 }
176 }
177
178 /*
179 * When this channel is removed
180 * we need to find all our children
181 * and make sure our pointers are fixed
182 */
183 pim_ifchannel_remove_children(ch);
184
185 if (ch->sources)
186 list_delete(&ch->sources);
187
188 listnode_delete(ch->upstream->ifchannels, ch);
189
190 up = ch->upstream;
191
192 /* upstream is common across ifchannels, check if upstream's
193 ifchannel list is empty before deleting upstream_del
194 ref count will take care of it.
195 */
196 if (ch->upstream->ref_count > 0)
197 up = pim_upstream_del(pim_ifp->pim, ch->upstream, __func__);
198
199 else {
200 if (PIM_DEBUG_PIM_TRACE)
201 zlog_debug(
202 "%s: Avoiding deletion of upstream with ref_count %d from ifchannel(%s): %s",
203 __func__, ch->upstream->ref_count,
204 ch->interface->name, ch->sg_str);
205 }
206
207 ch->upstream = NULL;
208
209 THREAD_OFF(ch->t_ifjoin_expiry_timer);
210 THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
211 THREAD_OFF(ch->t_ifassert_timer);
212
213 if (ch->parent) {
214 listnode_delete(ch->parent->sources, ch);
215 ch->parent = NULL;
216 }
217
218 RB_REMOVE(pim_ifchannel_rb, &pim_ifp->ifchannel_rb, ch);
219
220 if (PIM_DEBUG_PIM_TRACE)
221 zlog_debug("%s: ifchannel entry %s(%s) is deleted ", __func__,
222 ch->sg_str, ch->interface->name);
223
224 XFREE(MTYPE_PIM_IFCHANNEL, ch);
225
226 if (up)
227 pim_upstream_update_join_desired(pim_ifp->pim, up);
228 }
229
230 void pim_ifchannel_delete_all(struct interface *ifp)
231 {
232 struct pim_interface *pim_ifp;
233 struct pim_ifchannel *ch;
234
235 pim_ifp = ifp->info;
236 if (!pim_ifp)
237 return;
238
239 while (!RB_EMPTY(pim_ifchannel_rb, &pim_ifp->ifchannel_rb)) {
240 ch = RB_ROOT(pim_ifchannel_rb, &pim_ifp->ifchannel_rb);
241
242 pim_ifchannel_ifjoin_switch(__func__, ch, PIM_IFJOIN_NOINFO);
243 pim_ifchannel_delete(ch);
244 }
245 }
246
247 void delete_on_noinfo(struct pim_ifchannel *ch)
248 {
249 if (ch->local_ifmembership == PIM_IFMEMBERSHIP_NOINFO
250 && ch->ifjoin_state == PIM_IFJOIN_NOINFO
251 && ch->t_ifjoin_expiry_timer == NULL)
252 pim_ifchannel_delete(ch);
253 }
254
255 void pim_ifchannel_ifjoin_switch(const char *caller, struct pim_ifchannel *ch,
256 enum pim_ifjoin_state new_state)
257 {
258 enum pim_ifjoin_state old_state = ch->ifjoin_state;
259 struct pim_interface *pim_ifp = ch->interface->info;
260 struct pim_ifchannel *child_ch;
261
262 if (PIM_DEBUG_PIM_EVENTS)
263 zlog_debug(
264 "PIM_IFCHANNEL(%s): %s is switching from %s to %s",
265 ch->interface->name, ch->sg_str,
266 pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags),
267 pim_ifchannel_ifjoin_name(new_state, 0));
268
269
270 if (old_state == new_state) {
271 if (PIM_DEBUG_PIM_EVENTS) {
272 zlog_debug(
273 "%s called by %s: non-transition on state %d (%s)",
274 __func__, caller, new_state,
275 pim_ifchannel_ifjoin_name(new_state, 0));
276 }
277 return;
278 }
279
280 ch->ifjoin_state = new_state;
281
282 if (pim_addr_is_any(ch->sg.src)) {
283 struct pim_upstream *up = ch->upstream;
284 struct pim_upstream *child;
285 struct listnode *up_node;
286
287 if (up) {
288 if (ch->ifjoin_state == PIM_IFJOIN_NOINFO) {
289 for (ALL_LIST_ELEMENTS_RO(up->sources, up_node,
290 child)) {
291 struct channel_oil *c_oil =
292 child->channel_oil;
293
294 if (PIM_DEBUG_PIM_TRACE)
295 zlog_debug(
296 "%s %s: Prune(S,G)=%s from %s",
297 __FILE__, __func__,
298 child->sg_str,
299 up->sg_str);
300 if (!c_oil)
301 continue;
302
303 /*
304 * If the S,G has no if channel and the
305 * c_oil still
306 * has output here then the *,G was
307 * supplying the implied
308 * if channel. So remove it.
309 */
310 if (oil_if_has(c_oil,
311 pim_ifp->mroute_vif_index))
312 pim_channel_del_inherited_oif(
313 c_oil, ch->interface,
314 __func__);
315 }
316 }
317 if (ch->ifjoin_state == PIM_IFJOIN_JOIN) {
318 for (ALL_LIST_ELEMENTS_RO(up->sources, up_node,
319 child)) {
320 if (PIM_DEBUG_PIM_TRACE)
321 zlog_debug(
322 "%s %s: Join(S,G)=%s from %s",
323 __FILE__, __func__,
324 child->sg_str,
325 up->sg_str);
326
327 /* check if the channel can be
328 * inherited into the SG's OIL
329 */
330 child_ch = pim_ifchannel_find(
331 ch->interface,
332 &child->sg);
333 if (pim_upstream_eval_inherit_if(
334 child, child_ch, ch)) {
335 pim_channel_add_oif(
336 child->channel_oil,
337 ch->interface,
338 PIM_OIF_FLAG_PROTO_STAR,
339 __func__);
340 pim_upstream_update_join_desired(
341 pim_ifp->pim, child);
342 }
343 }
344 }
345 }
346 }
347 /* Transition to/from NOINFO ? */
348 if ((old_state == PIM_IFJOIN_NOINFO)
349 || (new_state == PIM_IFJOIN_NOINFO)) {
350
351 if (PIM_DEBUG_PIM_EVENTS) {
352 zlog_debug("PIM_IFCHANNEL_%s: (S,G)=%s on interface %s",
353 ((new_state == PIM_IFJOIN_NOINFO) ? "DOWN"
354 : "UP"),
355 ch->sg_str, ch->interface->name);
356 }
357
358 /*
359 Record uptime of state transition to/from NOINFO
360 */
361 ch->ifjoin_creation = pim_time_monotonic_sec();
362
363 pim_upstream_update_join_desired(pim_ifp->pim, ch->upstream);
364 pim_ifchannel_update_could_assert(ch);
365 pim_ifchannel_update_assert_tracking_desired(ch);
366 }
367 }
368
369 const char *pim_ifchannel_ifjoin_name(enum pim_ifjoin_state ifjoin_state,
370 int flags)
371 {
372 switch (ifjoin_state) {
373 case PIM_IFJOIN_NOINFO:
374 if (PIM_IF_FLAG_TEST_S_G_RPT(flags))
375 return "SGRpt(NI)";
376 else
377 return "NOINFO";
378 case PIM_IFJOIN_JOIN:
379 return "JOIN";
380 case PIM_IFJOIN_PRUNE:
381 if (PIM_IF_FLAG_TEST_S_G_RPT(flags))
382 return "SGRpt(P)";
383 else
384 return "PRUNE";
385 case PIM_IFJOIN_PRUNE_PENDING:
386 if (PIM_IF_FLAG_TEST_S_G_RPT(flags))
387 return "SGRpt(PP)";
388 else
389 return "PRUNEP";
390 case PIM_IFJOIN_PRUNE_TMP:
391 if (PIM_IF_FLAG_TEST_S_G_RPT(flags))
392 return "SGRpt(P')";
393 else
394 return "PRUNET";
395 case PIM_IFJOIN_PRUNE_PENDING_TMP:
396 if (PIM_IF_FLAG_TEST_S_G_RPT(flags))
397 return "SGRpt(PP')";
398 else
399 return "PRUNEPT";
400 }
401
402 return "ifjoin_bad_state";
403 }
404
405 const char *pim_ifchannel_ifassert_name(enum pim_ifassert_state ifassert_state)
406 {
407 switch (ifassert_state) {
408 case PIM_IFASSERT_NOINFO:
409 return "NOINFO";
410 case PIM_IFASSERT_I_AM_WINNER:
411 return "WINNER";
412 case PIM_IFASSERT_I_AM_LOSER:
413 return "LOSER";
414 }
415
416 return "ifassert_bad_state";
417 }
418
419 /*
420 RFC 4601: 4.6.5. Assert State Macros
421
422 AssertWinner(S,G,I) defaults to NULL and AssertWinnerMetric(S,G,I)
423 defaults to Infinity when in the NoInfo state.
424 */
425 void reset_ifassert_state(struct pim_ifchannel *ch)
426 {
427 THREAD_OFF(ch->t_ifassert_timer);
428
429 pim_ifassert_winner_set(ch, PIM_IFASSERT_NOINFO, PIMADDR_ANY,
430 router->infinite_assert_metric);
431 }
432
433 struct pim_ifchannel *pim_ifchannel_find(struct interface *ifp, pim_sgaddr *sg)
434 {
435 struct pim_interface *pim_ifp;
436 struct pim_ifchannel *ch;
437 struct pim_ifchannel lookup;
438
439 pim_ifp = ifp->info;
440
441 if (!pim_ifp) {
442 zlog_warn("%s: (S,G)=%pSG: multicast not enabled on interface %s",
443 __func__, sg, ifp->name);
444 return NULL;
445 }
446
447 lookup.sg = *sg;
448 lookup.interface = ifp;
449 ch = RB_FIND(pim_ifchannel_rb, &pim_ifp->ifchannel_rb, &lookup);
450
451 return ch;
452 }
453
454 static void ifmembership_set(struct pim_ifchannel *ch,
455 enum pim_ifmembership membership)
456 {
457 struct pim_interface *pim_ifp = ch->interface->info;
458
459 if (ch->local_ifmembership == membership)
460 return;
461
462 if (PIM_DEBUG_PIM_EVENTS) {
463 zlog_debug("%s: (S,G)=%s membership now is %s on interface %s",
464 __func__, ch->sg_str,
465 membership == PIM_IFMEMBERSHIP_INCLUDE ? "INCLUDE"
466 : "NOINFO",
467 ch->interface->name);
468 }
469
470 ch->local_ifmembership = membership;
471
472 pim_upstream_update_join_desired(pim_ifp->pim, ch->upstream);
473 pim_ifchannel_update_could_assert(ch);
474 pim_ifchannel_update_assert_tracking_desired(ch);
475 }
476
477
478 void pim_ifchannel_membership_clear(struct interface *ifp)
479 {
480 struct pim_interface *pim_ifp;
481 struct pim_ifchannel *ch;
482
483 pim_ifp = ifp->info;
484 assert(pim_ifp);
485
486 RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb)
487 ifmembership_set(ch, PIM_IFMEMBERSHIP_NOINFO);
488 }
489
490 void pim_ifchannel_delete_on_noinfo(struct interface *ifp)
491 {
492 struct pim_interface *pim_ifp;
493 struct pim_ifchannel *ch, *ch_tmp;
494
495 pim_ifp = ifp->info;
496 assert(pim_ifp);
497
498 RB_FOREACH_SAFE (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb, ch_tmp)
499 delete_on_noinfo(ch);
500 }
501
502 /*
503 * For a given Interface, if we are given a S,G
504 * Find the *,G (If we have it).
505 * If we are passed a *,G, find the *,* ifchannel
506 * if we have it.
507 */
508 static struct pim_ifchannel *pim_ifchannel_find_parent(struct pim_ifchannel *ch)
509 {
510 pim_sgaddr parent_sg = ch->sg;
511 struct pim_ifchannel *parent = NULL;
512
513 // (S,G)
514 if (!pim_addr_is_any(parent_sg.src) &&
515 !pim_addr_is_any(parent_sg.grp)) {
516 parent_sg.src = PIMADDR_ANY;
517 parent = pim_ifchannel_find(ch->interface, &parent_sg);
518
519 if (parent)
520 listnode_add(parent->sources, ch);
521 return parent;
522 }
523
524 return NULL;
525 }
526
527 struct pim_ifchannel *pim_ifchannel_add(struct interface *ifp, pim_sgaddr *sg,
528 uint8_t source_flags, int up_flags)
529 {
530 struct pim_interface *pim_ifp;
531 struct pim_ifchannel *ch;
532 struct pim_upstream *up;
533
534 ch = pim_ifchannel_find(ifp, sg);
535 if (ch) {
536 if (up_flags == PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
537 PIM_IF_FLAG_SET_PROTO_PIM(ch->flags);
538
539 if (up_flags == PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
540 PIM_IF_FLAG_SET_PROTO_IGMP(ch->flags);
541
542 if (ch->upstream)
543 ch->upstream->flags |= up_flags;
544 else if (PIM_DEBUG_EVENTS)
545 zlog_debug("%s:%pSG No Upstream found", __func__, sg);
546
547 return ch;
548 }
549
550 pim_ifp = ifp->info;
551
552 ch = XCALLOC(MTYPE_PIM_IFCHANNEL, sizeof(*ch));
553
554 ch->flags = 0;
555 if ((source_flags & PIM_ENCODE_RPT_BIT)
556 && !(source_flags & PIM_ENCODE_WC_BIT))
557 PIM_IF_FLAG_SET_S_G_RPT(ch->flags);
558
559 ch->interface = ifp;
560 ch->sg = *sg;
561 snprintfrr(ch->sg_str, sizeof(ch->sg_str), "%pSG", sg);
562 ch->parent = pim_ifchannel_find_parent(ch);
563 if (pim_addr_is_any(ch->sg.src)) {
564 ch->sources = list_new();
565 ch->sources->cmp =
566 (int (*)(void *, void *))pim_ifchannel_compare;
567 } else
568 ch->sources = NULL;
569
570 pim_ifchannel_find_new_children(ch);
571 ch->local_ifmembership = PIM_IFMEMBERSHIP_NOINFO;
572
573 ch->ifjoin_state = PIM_IFJOIN_NOINFO;
574 ch->t_ifjoin_expiry_timer = NULL;
575 ch->t_ifjoin_prune_pending_timer = NULL;
576 ch->ifjoin_creation = 0;
577
578 RB_INSERT(pim_ifchannel_rb, &pim_ifp->ifchannel_rb, ch);
579
580 up = pim_upstream_add(pim_ifp->pim, sg, NULL, up_flags, __func__, ch);
581
582 ch->upstream = up;
583
584 listnode_add_sort(up->ifchannels, ch);
585
586 ch->ifassert_my_metric = pim_macro_ch_my_assert_metric_eval(ch);
587 ch->ifassert_winner_metric = pim_macro_ch_my_assert_metric_eval(ch);
588
589 ch->ifassert_winner = PIMADDR_ANY;
590
591 /* Assert state */
592 ch->t_ifassert_timer = NULL;
593 ch->ifassert_state = PIM_IFASSERT_NOINFO;
594 reset_ifassert_state(ch);
595 if (pim_macro_ch_could_assert_eval(ch))
596 PIM_IF_FLAG_SET_COULD_ASSERT(ch->flags);
597 else
598 PIM_IF_FLAG_UNSET_COULD_ASSERT(ch->flags);
599
600 if (pim_macro_assert_tracking_desired_eval(ch))
601 PIM_IF_FLAG_SET_ASSERT_TRACKING_DESIRED(ch->flags);
602 else
603 PIM_IF_FLAG_UNSET_ASSERT_TRACKING_DESIRED(ch->flags);
604
605 /*
606 * advertise MLAG Data to MLAG peer
607 */
608 if (PIM_I_am_DualActive(pim_ifp)) {
609 up->dualactive_ifchannel_count++;
610 /* Sync once for upstream */
611 if (up->dualactive_ifchannel_count == 1) {
612 PIM_UPSTREAM_FLAG_SET_MLAG_INTERFACE(up->flags);
613 pim_mlag_up_local_add(pim_ifp->pim, up);
614 }
615 if (PIM_DEBUG_MLAG)
616 zlog_debug(
617 "%s: New Dual active if-chnanel is added to upstream:%s count:%d, flags:0x%x",
618 __func__, up->sg_str,
619 up->dualactive_ifchannel_count, up->flags);
620 }
621
622 if (up_flags == PIM_UPSTREAM_FLAG_MASK_SRC_PIM)
623 PIM_IF_FLAG_SET_PROTO_PIM(ch->flags);
624
625 if (up_flags == PIM_UPSTREAM_FLAG_MASK_SRC_IGMP)
626 PIM_IF_FLAG_SET_PROTO_IGMP(ch->flags);
627
628 if (PIM_DEBUG_PIM_TRACE)
629 zlog_debug("%s: ifchannel %s(%s) is created ", __func__,
630 ch->sg_str, ch->interface->name);
631
632 return ch;
633 }
634
635 static void ifjoin_to_noinfo(struct pim_ifchannel *ch)
636 {
637 pim_ifchannel_ifjoin_switch(__func__, ch, PIM_IFJOIN_NOINFO);
638 pim_forward_stop(ch);
639
640 if (ch->upstream)
641 PIM_UPSTREAM_FLAG_UNSET_SRC_PIM(ch->upstream->flags);
642
643 PIM_IF_FLAG_UNSET_PROTO_PIM(ch->flags);
644
645 delete_on_noinfo(ch);
646 }
647
648 static void on_ifjoin_expiry_timer(struct thread *t)
649 {
650 struct pim_ifchannel *ch;
651
652 ch = THREAD_ARG(t);
653
654 if (PIM_DEBUG_PIM_TRACE)
655 zlog_debug("%s: ifchannel %s expiry timer", __func__,
656 ch->sg_str);
657
658 ifjoin_to_noinfo(ch);
659 /* ch may have been deleted */
660 }
661
662 static void on_ifjoin_prune_pending_timer(struct thread *t)
663 {
664 struct pim_ifchannel *ch;
665 int send_prune_echo; /* boolean */
666 struct interface *ifp;
667 struct pim_interface *pim_ifp;
668
669 ch = THREAD_ARG(t);
670
671 if (PIM_DEBUG_PIM_TRACE)
672 zlog_debug("%s: IFCHANNEL%pSG %s Prune Pending Timer Popped",
673 __func__, &ch->sg,
674 pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags));
675
676 if (ch->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING) {
677 ifp = ch->interface;
678 pim_ifp = ifp->info;
679 if (!PIM_IF_FLAG_TEST_S_G_RPT(ch->flags)) {
680 /* Send PruneEcho(S,G) ? */
681 send_prune_echo =
682 (listcount(pim_ifp->pim_neighbor_list) > 1);
683
684 if (send_prune_echo) {
685 struct pim_rpf rpf;
686
687 rpf.source_nexthop.interface = ifp;
688 rpf.rpf_addr = pim_ifp->primary_address;
689 pim_jp_agg_single_upstream_send(
690 &rpf, ch->upstream, 0);
691 }
692
693 ifjoin_to_noinfo(ch);
694 } else {
695 /* If SGRpt flag is set on ifchannel, Trigger SGRpt
696 * message on RP path upon prune timer expiry.
697 */
698 ch->ifjoin_state = PIM_IFJOIN_PRUNE;
699 if (ch->upstream) {
700 struct pim_upstream *parent =
701 ch->upstream->parent;
702
703 pim_upstream_update_join_desired(pim_ifp->pim,
704 ch->upstream);
705
706 pim_jp_agg_single_upstream_send(&parent->rpf,
707 parent, true);
708 /*
709 * SGRpt prune pending expiry has to install
710 * SG entry with empty olist to drop the SG
711 * traffic incase no other intf exists.
712 * On that scenario, SG entry wouldn't have
713 * got installed until Prune pending timer
714 * expired. So install now.
715 */
716 pim_channel_del_oif(
717 ch->upstream->channel_oil, ifp,
718 PIM_OIF_FLAG_PROTO_STAR, __func__);
719 if (!ch->upstream->channel_oil->installed)
720 pim_upstream_mroute_add(
721 ch->upstream->channel_oil,
722 __func__);
723 }
724 }
725 /* from here ch may have been deleted */
726 }
727 }
728
729 static void check_recv_upstream(int is_join, struct interface *recv_ifp,
730 pim_addr upstream, pim_sgaddr *sg,
731 uint8_t source_flags, int holdtime)
732 {
733 struct pim_upstream *up;
734 struct pim_interface *pim_ifp = recv_ifp->info;
735 pim_addr rpf_addr;
736
737 /* Upstream (S,G) in Joined state ? */
738 up = pim_upstream_find(pim_ifp->pim, sg);
739 if (!up)
740 return;
741 if (up->join_state != PIM_UPSTREAM_JOINED)
742 return;
743
744 /* Upstream (S,G) in Joined state */
745
746 if (pim_rpf_addr_is_inaddr_any(&up->rpf)) {
747 /* RPF'(S,G) not found */
748 zlog_warn("%s %s: RPF'%s not found", __FILE__, __func__,
749 up->sg_str);
750 return;
751 }
752
753 rpf_addr = up->rpf.rpf_addr;
754
755 /* upstream directed to RPF'(S,G) ? */
756 if (pim_addr_cmp(upstream, rpf_addr)) {
757 zlog_warn(
758 "%s %s: (S,G)=%s upstream=%pPAs not directed to RPF'(S,G)=%pPAs on interface %s",
759 __FILE__, __func__, up->sg_str, &upstream, &rpf_addr,
760 recv_ifp->name);
761 return;
762 }
763 /* upstream directed to RPF'(S,G) */
764
765 if (is_join) {
766 /* Join(S,G) to RPF'(S,G) */
767 pim_upstream_join_suppress(up, up->rpf.rpf_addr, holdtime);
768 return;
769 }
770
771 /* Prune to RPF'(S,G) */
772
773 if (source_flags & PIM_RPT_BIT_MASK) {
774 if (source_flags & PIM_WILDCARD_BIT_MASK) {
775 /* Prune(*,G) to RPF'(S,G) */
776 pim_upstream_join_timer_decrease_to_t_override(
777 "Prune(*,G)", up);
778 return;
779 }
780
781 /* Prune(S,G,rpt) to RPF'(S,G) */
782 pim_upstream_join_timer_decrease_to_t_override("Prune(S,G,rpt)",
783 up);
784 return;
785 }
786
787 /* Prune(S,G) to RPF'(S,G) */
788 pim_upstream_join_timer_decrease_to_t_override("Prune(S,G)", up);
789 }
790
791 static int nonlocal_upstream(int is_join, struct interface *recv_ifp,
792 pim_addr upstream, pim_sgaddr *sg,
793 uint8_t source_flags, uint16_t holdtime)
794 {
795 struct pim_interface *recv_pim_ifp;
796 int is_local; /* boolean */
797
798 recv_pim_ifp = recv_ifp->info;
799 assert(recv_pim_ifp);
800
801 is_local = !pim_addr_cmp(upstream, recv_pim_ifp->primary_address);
802
803 if (is_local)
804 return 0;
805
806 if (PIM_DEBUG_PIM_TRACE_DETAIL)
807 zlog_warn(
808 "%s: recv %s (S,G)=%pSG to non-local upstream=%pPAs on %s",
809 __func__, is_join ? "join" : "prune", sg, &upstream,
810 recv_ifp->name);
811
812 /*
813 * Since recv upstream addr was not directed to our primary
814 * address, check if we should react to it in any way.
815 */
816 check_recv_upstream(is_join, recv_ifp, upstream, sg, source_flags,
817 holdtime);
818
819 return 1; /* non-local */
820 }
821
822 static void pim_ifchannel_ifjoin_handler(struct pim_ifchannel *ch,
823 struct pim_interface *pim_ifp)
824 {
825 pim_ifchannel_ifjoin_switch(__func__, ch, PIM_IFJOIN_JOIN);
826 PIM_IF_FLAG_UNSET_S_G_RPT(ch->flags);
827 /* check if the interface qualifies as an immediate
828 * OIF
829 */
830 if (pim_upstream_evaluate_join_desired_interface(
831 ch->upstream, ch,
832 NULL /*starch*/)) {
833 pim_channel_add_oif(ch->upstream->channel_oil,
834 ch->interface,
835 PIM_OIF_FLAG_PROTO_PIM,
836 __func__);
837 pim_upstream_update_join_desired(pim_ifp->pim,
838 ch->upstream);
839 }
840 }
841
842
843 void pim_ifchannel_join_add(struct interface *ifp, pim_addr neigh_addr,
844 pim_addr upstream, pim_sgaddr *sg,
845 uint8_t source_flags, uint16_t holdtime)
846 {
847 struct pim_interface *pim_ifp;
848 struct pim_ifchannel *ch;
849
850 if (nonlocal_upstream(1 /* join */, ifp, upstream, sg, source_flags,
851 holdtime)) {
852 return;
853 }
854
855 ch = pim_ifchannel_add(ifp, sg, source_flags,
856 PIM_UPSTREAM_FLAG_MASK_SRC_PIM);
857
858 /*
859 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
860
861 Transitions from "I am Assert Loser" State
862
863 Receive Join(S,G) on Interface I
864
865 We receive a Join(S,G) that has the Upstream Neighbor Address
866 field set to my primary IP address on interface I. The action is
867 to transition to NoInfo state, delete this (S,G) assert state
868 (Actions A5 below), and allow the normal PIM Join/Prune mechanisms
869 to operate.
870
871 Notice: The nonlocal_upstream() test above ensures the upstream
872 address of the join message is our primary address.
873 */
874 if (ch->ifassert_state == PIM_IFASSERT_I_AM_LOSER) {
875 zlog_warn("%s: Assert Loser recv Join%s from %pPA on %s",
876 __func__, ch->sg_str, &neigh_addr, ifp->name);
877
878 assert_action_a5(ch);
879 }
880
881 pim_ifp = ifp->info;
882 assert(pim_ifp);
883
884 switch (ch->ifjoin_state) {
885 case PIM_IFJOIN_NOINFO:
886 pim_ifchannel_ifjoin_switch(__func__, ch, PIM_IFJOIN_JOIN);
887 if (pim_macro_chisin_oiflist(ch)) {
888 pim_upstream_inherited_olist(pim_ifp->pim,
889 ch->upstream);
890 pim_forward_start(ch);
891 }
892 /*
893 * If we are going to be a LHR, we need to note it
894 */
895 if (ch->upstream->parent &&
896 (PIM_UPSTREAM_FLAG_TEST_CAN_BE_LHR(
897 ch->upstream->parent->flags))
898 && !(ch->upstream->flags
899 & PIM_UPSTREAM_FLAG_MASK_SRC_LHR)) {
900 pim_upstream_ref(ch->upstream,
901 PIM_UPSTREAM_FLAG_MASK_SRC_LHR,
902 __func__);
903 pim_upstream_keep_alive_timer_start(
904 ch->upstream, pim_ifp->pim->keep_alive_time);
905 }
906 break;
907 case PIM_IFJOIN_JOIN:
908 assert(!ch->t_ifjoin_prune_pending_timer);
909
910 /*
911 In the JOIN state ch->t_ifjoin_expiry_timer may be NULL due to
912 a
913 previously received join message with holdtime=0xFFFF.
914 */
915 if (ch->t_ifjoin_expiry_timer) {
916 unsigned long remain = thread_timer_remain_second(
917 ch->t_ifjoin_expiry_timer);
918 if (remain > holdtime) {
919 /*
920 RFC 4601: 4.5.3. Receiving (S,G) Join/Prune
921 Messages
922
923 Transitions from Join State
924
925 The (S,G) downstream state machine on
926 interface I remains in
927 Join state, and the Expiry Timer (ET) is
928 restarted, set to
929 maximum of its current value and the HoldTime
930 from the
931 triggering Join/Prune message.
932
933 Conclusion: Do not change the ET if the
934 current value is
935 higher than the received join holdtime.
936 */
937 return;
938 }
939 }
940 THREAD_OFF(ch->t_ifjoin_expiry_timer);
941 break;
942 case PIM_IFJOIN_PRUNE:
943 if (source_flags & PIM_ENCODE_RPT_BIT) {
944 pim_ifchannel_ifjoin_switch(__func__, ch,
945 PIM_IFJOIN_NOINFO);
946 THREAD_OFF(ch->t_ifjoin_expiry_timer);
947 delete_on_noinfo(ch);
948 return;
949 } else
950 pim_ifchannel_ifjoin_handler(ch, pim_ifp);
951 break;
952 case PIM_IFJOIN_PRUNE_PENDING:
953 /*
954 * Transitions from Prune-Pending State (Receive Join)
955 * RFC 7761 Sec 4.5.2:
956 * The (S,G) downstream state machine on interface I
957 * transitions to the Join state. The Prune-Pending Timer is
958 * canceled (without triggering an expiry event). The
959 * Expiry Timer (ET) is restarted and is then set to the
960 * maximum of its current value and the HoldTime from the
961 * triggering Join/Prune message.
962 */
963 THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
964
965 /* Check if SGRpt join Received */
966 if ((source_flags & PIM_ENCODE_RPT_BIT) &&
967 !pim_addr_is_any(sg->src)) {
968 /*
969 * Transitions from Prune-Pending State (Rcv SGRpt Join)
970 * RFC 7761 Sec 4.5.3:
971 * The (S,G,rpt) downstream state machine on interface
972 * I transitions to the NoInfo state.The ET and PPT are
973 * cancelled.
974 */
975 THREAD_OFF(ch->t_ifjoin_expiry_timer);
976 pim_ifchannel_ifjoin_switch(__func__, ch,
977 PIM_IFJOIN_NOINFO);
978 return;
979 }
980
981 pim_ifchannel_ifjoin_handler(ch, pim_ifp);
982
983 if (ch->t_ifjoin_expiry_timer) {
984 unsigned long remain = thread_timer_remain_second(
985 ch->t_ifjoin_expiry_timer);
986
987 if (remain > holdtime)
988 return;
989 }
990 THREAD_OFF(ch->t_ifjoin_expiry_timer);
991
992 break;
993 case PIM_IFJOIN_PRUNE_TMP:
994 break;
995 case PIM_IFJOIN_PRUNE_PENDING_TMP:
996 break;
997 }
998
999 if (holdtime != 0xFFFF) {
1000 thread_add_timer(router->master, on_ifjoin_expiry_timer, ch,
1001 holdtime, &ch->t_ifjoin_expiry_timer);
1002 }
1003 }
1004
1005 void pim_ifchannel_prune(struct interface *ifp, pim_addr upstream,
1006 pim_sgaddr *sg, uint8_t source_flags,
1007 uint16_t holdtime)
1008 {
1009 struct pim_ifchannel *ch;
1010 struct pim_interface *pim_ifp;
1011 int jp_override_interval_msec;
1012
1013 if (nonlocal_upstream(0 /* prune */, ifp, upstream, sg, source_flags,
1014 holdtime)) {
1015 return;
1016 }
1017
1018 ch = pim_ifchannel_find(ifp, sg);
1019 if (!ch && !(source_flags & PIM_ENCODE_RPT_BIT)) {
1020 if (PIM_DEBUG_PIM_TRACE)
1021 zlog_debug("%s: Received prune with no relevant ifchannel %s%pSG state: %d",
1022 __func__, ifp->name, sg,
1023 source_flags);
1024 return;
1025 }
1026
1027 ch = pim_ifchannel_add(ifp, sg, source_flags,
1028 PIM_UPSTREAM_FLAG_MASK_SRC_PIM);
1029
1030 pim_ifp = ifp->info;
1031
1032 switch (ch->ifjoin_state) {
1033 case PIM_IFJOIN_NOINFO:
1034 if (source_flags & PIM_ENCODE_RPT_BIT) {
1035 if (!(source_flags & PIM_ENCODE_WC_BIT))
1036 PIM_IF_FLAG_SET_S_G_RPT(ch->flags);
1037
1038 ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
1039 if (listcount(pim_ifp->pim_neighbor_list) > 1)
1040 jp_override_interval_msec =
1041 pim_if_jp_override_interval_msec(ifp);
1042 else
1043 jp_override_interval_msec =
1044 0; /* schedule to expire immediately */
1045 /* If we called ifjoin_prune() directly instead, care
1046 should
1047 be taken not to use "ch" afterwards since it would be
1048 deleted. */
1049
1050 THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
1051 THREAD_OFF(ch->t_ifjoin_expiry_timer);
1052 thread_add_timer_msec(
1053 router->master, on_ifjoin_prune_pending_timer,
1054 ch, jp_override_interval_msec,
1055 &ch->t_ifjoin_prune_pending_timer);
1056 thread_add_timer(router->master, on_ifjoin_expiry_timer,
1057 ch, holdtime,
1058 &ch->t_ifjoin_expiry_timer);
1059 pim_upstream_update_join_desired(pim_ifp->pim,
1060 ch->upstream);
1061 }
1062 break;
1063 case PIM_IFJOIN_PRUNE_PENDING:
1064 /* nothing to do */
1065 break;
1066 case PIM_IFJOIN_JOIN:
1067 /*
1068 * The (S,G) downstream state machine on interface I
1069 * transitions to the Prune-Pending state. The
1070 * Prune-Pending Timer is started. It is set to the
1071 * J/P_Override_Interval(I) if the router has more than one
1072 * neighbor on that interface; otherwise, it is set to zero,
1073 * causing it to expire immediately.
1074 */
1075
1076 pim_ifchannel_ifjoin_switch(__func__, ch,
1077 PIM_IFJOIN_PRUNE_PENDING);
1078
1079 if (listcount(pim_ifp->pim_neighbor_list) > 1)
1080 jp_override_interval_msec =
1081 pim_if_jp_override_interval_msec(ifp);
1082 else
1083 jp_override_interval_msec =
1084 0; /* schedule to expire immediately */
1085 /* If we called ifjoin_prune() directly instead, care should
1086 be taken not to use "ch" afterwards since it would be
1087 deleted. */
1088 THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
1089 thread_add_timer_msec(router->master,
1090 on_ifjoin_prune_pending_timer, ch,
1091 jp_override_interval_msec,
1092 &ch->t_ifjoin_prune_pending_timer);
1093 break;
1094 case PIM_IFJOIN_PRUNE:
1095 if (source_flags & PIM_ENCODE_RPT_BIT) {
1096 THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
1097 /*
1098 * While in Prune State, Receive SGRpt Prune.
1099 * RFC 7761 Sec 4.5.3:
1100 * The (S,G,rpt) downstream state machine on interface I
1101 * remains in Prune state. The Expiry Timer (ET) is
1102 * restarted and is then set to the maximum of its
1103 * current value and the HoldTime from the triggering
1104 * Join/Prune message.
1105 */
1106 if (ch->t_ifjoin_expiry_timer) {
1107 unsigned long rem = thread_timer_remain_second(
1108 ch->t_ifjoin_expiry_timer);
1109
1110 if (rem > holdtime)
1111 return;
1112 THREAD_OFF(ch->t_ifjoin_expiry_timer);
1113 }
1114
1115 thread_add_timer(router->master, on_ifjoin_expiry_timer,
1116 ch, holdtime,
1117 &ch->t_ifjoin_expiry_timer);
1118 }
1119 break;
1120 case PIM_IFJOIN_PRUNE_TMP:
1121 if (source_flags & PIM_ENCODE_RPT_BIT) {
1122 ch->ifjoin_state = PIM_IFJOIN_PRUNE;
1123 THREAD_OFF(ch->t_ifjoin_expiry_timer);
1124 thread_add_timer(router->master, on_ifjoin_expiry_timer,
1125 ch, holdtime,
1126 &ch->t_ifjoin_expiry_timer);
1127 }
1128 break;
1129 case PIM_IFJOIN_PRUNE_PENDING_TMP:
1130 if (source_flags & PIM_ENCODE_RPT_BIT) {
1131 ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
1132 THREAD_OFF(ch->t_ifjoin_expiry_timer);
1133 thread_add_timer(router->master, on_ifjoin_expiry_timer,
1134 ch, holdtime,
1135 &ch->t_ifjoin_expiry_timer);
1136 }
1137 break;
1138 }
1139 }
1140
1141 int pim_ifchannel_local_membership_add(struct interface *ifp, pim_sgaddr *sg,
1142 bool is_vxlan)
1143 {
1144 struct pim_ifchannel *ch, *starch;
1145 struct pim_interface *pim_ifp;
1146 struct pim_instance *pim;
1147 int up_flags;
1148
1149 /* PIM enabled on interface? */
1150 pim_ifp = ifp->info;
1151 if (!pim_ifp) {
1152 if (PIM_DEBUG_EVENTS)
1153 zlog_debug("%s:%pSG Expected pim interface setup for %s",
1154 __func__, sg, ifp->name);
1155 return 0;
1156 }
1157
1158 if (!pim_ifp->pim_enable) {
1159 if (PIM_DEBUG_EVENTS)
1160 zlog_debug("%s:%pSG PIM is not configured on this interface %s",
1161 __func__, sg, ifp->name);
1162 return 0;
1163 }
1164
1165 pim = pim_ifp->pim;
1166
1167 /* skip (*,G) ch creation if G is of type SSM */
1168 if (pim_addr_is_any(sg->src)) {
1169 if (pim_is_grp_ssm(pim, sg->grp)) {
1170 if (PIM_DEBUG_PIM_EVENTS)
1171 zlog_debug("%s: local membership (S,G)=%pSG ignored as group is SSM",
1172 __func__, sg);
1173 return 1;
1174 }
1175 }
1176
1177 /* vxlan term mroutes use ipmr-lo as local member to
1178 * pull down multicast vxlan tunnel traffic
1179 */
1180 up_flags = is_vxlan ? PIM_UPSTREAM_FLAG_MASK_SRC_VXLAN_TERM :
1181 PIM_UPSTREAM_FLAG_MASK_SRC_IGMP;
1182 ch = pim_ifchannel_add(ifp, sg, 0, up_flags);
1183
1184 ifmembership_set(ch, PIM_IFMEMBERSHIP_INCLUDE);
1185
1186 if (pim_addr_is_any(sg->src)) {
1187 struct pim_upstream *up = pim_upstream_find(pim, sg);
1188 struct pim_upstream *child;
1189 struct listnode *up_node;
1190
1191 starch = ch;
1192
1193 for (ALL_LIST_ELEMENTS_RO(up->sources, up_node, child)) {
1194 if (PIM_DEBUG_EVENTS)
1195 zlog_debug("%s %s: IGMP (S,G)=%s(%s) from %s",
1196 __FILE__, __func__, child->sg_str,
1197 ifp->name, up->sg_str);
1198
1199 if (!child->rpf.source_nexthop.interface) {
1200 /* when iif unknown, do not inherit */
1201 if (PIM_DEBUG_EVENTS)
1202 zlog_debug(
1203 "Skipped (S,G)=%s(%s) from %s: no iif",
1204 child->sg_str, ifp->name,
1205 up->sg_str);
1206 continue;
1207 }
1208
1209 ch = pim_ifchannel_find(ifp, &child->sg);
1210 if (pim_upstream_evaluate_join_desired_interface(
1211 child, ch, starch)) {
1212 pim_channel_add_oif(child->channel_oil, ifp,
1213 PIM_OIF_FLAG_PROTO_STAR,
1214 __func__);
1215 pim_upstream_update_join_desired(pim, child);
1216 }
1217 }
1218
1219 if (pim->spt.switchover == PIM_SPT_INFINITY) {
1220 if (pim->spt.plist) {
1221 struct prefix_list *plist = prefix_list_lookup(
1222 AFI_IP, pim->spt.plist);
1223 struct prefix g;
1224
1225 pim_addr_to_prefix(&g, up->sg.grp);
1226 if (prefix_list_apply(plist, &g)
1227 == PREFIX_DENY) {
1228 pim_channel_add_oif(
1229 up->channel_oil, pim->regiface,
1230 PIM_OIF_FLAG_PROTO_GM,
1231 __func__);
1232 }
1233 }
1234 } else
1235 pim_channel_add_oif(up->channel_oil, pim->regiface,
1236 PIM_OIF_FLAG_PROTO_GM, __func__);
1237 }
1238
1239 return 1;
1240 }
1241
1242 void pim_ifchannel_local_membership_del(struct interface *ifp, pim_sgaddr *sg)
1243 {
1244 struct pim_ifchannel *starch, *ch, *orig;
1245 struct pim_interface *pim_ifp;
1246
1247 /* PIM enabled on interface? */
1248 pim_ifp = ifp->info;
1249 if (!pim_ifp)
1250 return;
1251 if (!pim_ifp->pim_enable)
1252 return;
1253
1254 orig = ch = pim_ifchannel_find(ifp, sg);
1255 if (!ch)
1256 return;
1257 ifmembership_set(ch, PIM_IFMEMBERSHIP_NOINFO);
1258
1259 if (pim_addr_is_any(sg->src)) {
1260 struct pim_upstream *up = pim_upstream_find(pim_ifp->pim, sg);
1261 struct pim_upstream *child;
1262 struct listnode *up_node, *up_nnode;
1263
1264 starch = ch;
1265
1266 for (ALL_LIST_ELEMENTS(up->sources, up_node, up_nnode, child)) {
1267 struct channel_oil *c_oil = child->channel_oil;
1268 struct pim_ifchannel *chchannel =
1269 pim_ifchannel_find(ifp, &child->sg);
1270
1271 pim_ifp = ifp->info;
1272
1273 if (PIM_DEBUG_EVENTS)
1274 zlog_debug("%s %s: Prune(S,G)=%s(%s) from %s",
1275 __FILE__, __func__, up->sg_str,
1276 ifp->name, child->sg_str);
1277
1278 ch = pim_ifchannel_find(ifp, &child->sg);
1279 /*
1280 * If the S,G has no if channel and the c_oil still
1281 * has output here then the *,G was supplying the
1282 * implied
1283 * if channel. So remove it.
1284 */
1285 if (!pim_upstream_evaluate_join_desired_interface(
1286 child, ch, starch) ||
1287 (!chchannel &&
1288 oil_if_has(c_oil, pim_ifp->mroute_vif_index))) {
1289 pim_channel_del_inherited_oif(c_oil, ifp,
1290 __func__);
1291 }
1292
1293 /* Child node removal/ref count-- will happen as part of
1294 * parent' delete_no_info */
1295 }
1296 }
1297
1298 /* Resettng the IGMP flags here */
1299 if (orig->upstream)
1300 PIM_UPSTREAM_FLAG_UNSET_SRC_IGMP(orig->upstream->flags);
1301
1302 PIM_IF_FLAG_UNSET_PROTO_IGMP(orig->flags);
1303
1304 delete_on_noinfo(orig);
1305 }
1306
1307 void pim_ifchannel_update_could_assert(struct pim_ifchannel *ch)
1308 {
1309 int old_couldassert =
1310 PIM_FORCE_BOOLEAN(PIM_IF_FLAG_TEST_COULD_ASSERT(ch->flags));
1311 int new_couldassert =
1312 PIM_FORCE_BOOLEAN(pim_macro_ch_could_assert_eval(ch));
1313
1314 if (new_couldassert == old_couldassert)
1315 return;
1316
1317 if (PIM_DEBUG_PIM_EVENTS)
1318 zlog_debug("%s: CouldAssert(%pPAs,%pPAs,%s) changed from %d to %d",
1319 __func__, &ch->sg.src, &ch->sg.grp,
1320 ch->interface->name, old_couldassert,
1321 new_couldassert);
1322
1323 if (new_couldassert) {
1324 /* CouldAssert(S,G,I) switched from false to true */
1325 PIM_IF_FLAG_SET_COULD_ASSERT(ch->flags);
1326 } else {
1327 /* CouldAssert(S,G,I) switched from true to false */
1328 PIM_IF_FLAG_UNSET_COULD_ASSERT(ch->flags);
1329
1330 if (ch->ifassert_state == PIM_IFASSERT_I_AM_WINNER) {
1331 assert_action_a4(ch);
1332 }
1333 }
1334
1335 pim_ifchannel_update_my_assert_metric(ch);
1336 }
1337
1338 /*
1339 my_assert_metric may be affected by:
1340
1341 CouldAssert(S,G)
1342 pim_ifp->primary_address
1343 rpf->source_nexthop.mrib_metric_preference;
1344 rpf->source_nexthop.mrib_route_metric;
1345 */
1346 void pim_ifchannel_update_my_assert_metric(struct pim_ifchannel *ch)
1347 {
1348 struct pim_assert_metric my_metric_new =
1349 pim_macro_ch_my_assert_metric_eval(ch);
1350
1351 if (pim_assert_metric_match(&my_metric_new, &ch->ifassert_my_metric))
1352 return;
1353
1354 if (PIM_DEBUG_PIM_EVENTS)
1355 zlog_debug(
1356 "%s: my_assert_metric(%pPAs,%pPAs,%s) changed from %u,%u,%u,%pPAs to %u,%u,%u,%pPAs",
1357 __func__, &ch->sg.src, &ch->sg.grp, ch->interface->name,
1358 ch->ifassert_my_metric.rpt_bit_flag,
1359 ch->ifassert_my_metric.metric_preference,
1360 ch->ifassert_my_metric.route_metric,
1361 &ch->ifassert_my_metric.ip_address,
1362 my_metric_new.rpt_bit_flag,
1363 my_metric_new.metric_preference,
1364 my_metric_new.route_metric, &my_metric_new.ip_address);
1365
1366 ch->ifassert_my_metric = my_metric_new;
1367
1368 if (pim_assert_metric_better(&ch->ifassert_my_metric,
1369 &ch->ifassert_winner_metric)) {
1370 assert_action_a5(ch);
1371 }
1372 }
1373
1374 void pim_ifchannel_update_assert_tracking_desired(struct pim_ifchannel *ch)
1375 {
1376 int old_atd = PIM_FORCE_BOOLEAN(
1377 PIM_IF_FLAG_TEST_ASSERT_TRACKING_DESIRED(ch->flags));
1378 int new_atd =
1379 PIM_FORCE_BOOLEAN(pim_macro_assert_tracking_desired_eval(ch));
1380
1381 if (new_atd == old_atd)
1382 return;
1383
1384 if (PIM_DEBUG_PIM_EVENTS)
1385 zlog_debug(
1386 "%s: AssertTrackingDesired(%pPAs,%pPAs,%s) changed from %d to %d",
1387 __func__, &ch->sg.src, &ch->sg.grp, ch->interface->name,
1388 old_atd, new_atd);
1389
1390 if (new_atd) {
1391 /* AssertTrackingDesired(S,G,I) switched from false to true */
1392 PIM_IF_FLAG_SET_ASSERT_TRACKING_DESIRED(ch->flags);
1393 } else {
1394 /* AssertTrackingDesired(S,G,I) switched from true to false */
1395 PIM_IF_FLAG_UNSET_ASSERT_TRACKING_DESIRED(ch->flags);
1396
1397 if (ch->ifassert_state == PIM_IFASSERT_I_AM_LOSER) {
1398 assert_action_a5(ch);
1399 }
1400 }
1401 }
1402
1403 /*
1404 * If we have a new pim interface, check to
1405 * see if any of the pre-existing channels have
1406 * their upstream out that way and turn on forwarding
1407 * for that ifchannel then.
1408 */
1409 void pim_ifchannel_scan_forward_start(struct interface *new_ifp)
1410 {
1411 struct pim_interface *new_pim_ifp = new_ifp->info;
1412 struct pim_instance *pim = new_pim_ifp->pim;
1413 struct interface *ifp;
1414
1415 FOR_ALL_INTERFACES (pim->vrf, ifp) {
1416 struct pim_interface *loop_pim_ifp = ifp->info;
1417 struct pim_ifchannel *ch;
1418
1419 if (!loop_pim_ifp)
1420 continue;
1421
1422 if (new_pim_ifp == loop_pim_ifp)
1423 continue;
1424
1425 RB_FOREACH (ch, pim_ifchannel_rb, &loop_pim_ifp->ifchannel_rb) {
1426 if (ch->ifjoin_state == PIM_IFJOIN_JOIN) {
1427 struct pim_upstream *up = ch->upstream;
1428 if ((!up->channel_oil)
1429 && (up->rpf.source_nexthop
1430 .interface == new_ifp))
1431 pim_forward_start(ch);
1432 }
1433 }
1434 }
1435 }
1436
1437 /*
1438 * Downstream per-interface (S,G,rpt) state machine
1439 * states that we need to move (S,G,rpt) items
1440 * into different states at the start of the
1441 * reception of a *,G join as well, when
1442 * we get End of Message
1443 */
1444 void pim_ifchannel_set_star_g_join_state(struct pim_ifchannel *ch, int eom,
1445 uint8_t join)
1446 {
1447 bool send_upstream_starg = false;
1448 struct pim_ifchannel *child;
1449 struct listnode *ch_node, *nch_node;
1450 struct pim_instance *pim =
1451 ((struct pim_interface *)ch->interface->info)->pim;
1452 struct pim_upstream *starup = ch->upstream;
1453
1454 if (PIM_DEBUG_PIM_TRACE)
1455 zlog_debug(
1456 "%s: %s %s eom: %d join %u", __func__,
1457 pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags),
1458 ch->sg_str, eom, join);
1459 if (!ch->sources)
1460 return;
1461
1462 for (ALL_LIST_ELEMENTS(ch->sources, ch_node, nch_node, child)) {
1463 if (!PIM_IF_FLAG_TEST_S_G_RPT(child->flags))
1464 continue;
1465
1466 switch (child->ifjoin_state) {
1467 case PIM_IFJOIN_NOINFO:
1468 case PIM_IFJOIN_JOIN:
1469 break;
1470 case PIM_IFJOIN_PRUNE:
1471 if (!eom)
1472 child->ifjoin_state = PIM_IFJOIN_PRUNE_TMP;
1473 break;
1474 case PIM_IFJOIN_PRUNE_PENDING:
1475 if (!eom)
1476 child->ifjoin_state =
1477 PIM_IFJOIN_PRUNE_PENDING_TMP;
1478 break;
1479 case PIM_IFJOIN_PRUNE_TMP:
1480 case PIM_IFJOIN_PRUNE_PENDING_TMP:
1481 if (!eom)
1482 break;
1483
1484 if (child->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING_TMP)
1485 THREAD_OFF(child->t_ifjoin_prune_pending_timer);
1486 THREAD_OFF(child->t_ifjoin_expiry_timer);
1487
1488 PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
1489 child->ifjoin_state = PIM_IFJOIN_NOINFO;
1490
1491 if ((I_am_RP(pim, child->sg.grp)) &&
1492 (!pim_upstream_empty_inherited_olist(
1493 child->upstream))) {
1494 pim_channel_add_oif(
1495 child->upstream->channel_oil,
1496 ch->interface, PIM_OIF_FLAG_PROTO_STAR,
1497 __func__);
1498 pim_upstream_update_join_desired(pim,
1499 child->upstream);
1500 }
1501 send_upstream_starg = true;
1502
1503 delete_on_noinfo(child);
1504 break;
1505 }
1506 }
1507
1508 if (send_upstream_starg)
1509 pim_jp_agg_single_upstream_send(&starup->rpf, starup, true);
1510 }
FRRouting mirror