]> git.proxmox.com Git - mirror_frr.git/blob - pimd/pim_assert.c
zebra: move rtadv service from zrouter to zvrf
[mirror_frr.git] / pimd / pim_assert.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 "log.h"
23 #include "prefix.h"
24 #include "if.h"
25
26 #include "pimd.h"
27 #include "pim_str.h"
28 #include "pim_tlv.h"
29 #include "pim_msg.h"
30 #include "pim_pim.h"
31 #include "pim_int.h"
32 #include "pim_time.h"
33 #include "pim_iface.h"
34 #include "pim_hello.h"
35 #include "pim_macro.h"
36 #include "pim_assert.h"
37 #include "pim_ifchannel.h"
38
39 static int assert_action_a3(struct pim_ifchannel *ch);
40 static void assert_action_a2(struct pim_ifchannel *ch,
41 struct pim_assert_metric winner_metric);
42 static void assert_action_a6(struct pim_ifchannel *ch,
43 struct pim_assert_metric winner_metric);
44
45 void pim_ifassert_winner_set(struct pim_ifchannel *ch,
46 enum pim_ifassert_state new_state,
47 struct in_addr winner,
48 struct pim_assert_metric winner_metric)
49 {
50 struct pim_interface *pim_ifp = ch->interface->info;
51 int winner_changed = (ch->ifassert_winner.s_addr != winner.s_addr);
52 int metric_changed = !pim_assert_metric_match(
53 &ch->ifassert_winner_metric, &winner_metric);
54
55 if (PIM_DEBUG_PIM_EVENTS) {
56 if (ch->ifassert_state != new_state) {
57 zlog_debug(
58 "%s: (S,G)=%s assert state changed from %s to %s on interface %s",
59 __PRETTY_FUNCTION__, ch->sg_str,
60 pim_ifchannel_ifassert_name(ch->ifassert_state),
61 pim_ifchannel_ifassert_name(new_state),
62 ch->interface->name);
63 }
64
65 if (winner_changed) {
66 char was_str[INET_ADDRSTRLEN];
67 char winner_str[INET_ADDRSTRLEN];
68 pim_inet4_dump("<was?>", ch->ifassert_winner, was_str,
69 sizeof(was_str));
70 pim_inet4_dump("<winner?>", winner, winner_str,
71 sizeof(winner_str));
72 zlog_debug(
73 "%s: (S,G)=%s assert winner changed from %s to %s on interface %s",
74 __PRETTY_FUNCTION__, ch->sg_str, was_str,
75 winner_str, ch->interface->name);
76 }
77 } /* PIM_DEBUG_PIM_EVENTS */
78
79 ch->ifassert_state = new_state;
80 ch->ifassert_winner = winner;
81 ch->ifassert_winner_metric = winner_metric;
82 ch->ifassert_creation = pim_time_monotonic_sec();
83
84 if (winner_changed || metric_changed) {
85 pim_upstream_update_join_desired(pim_ifp->pim, ch->upstream);
86 pim_ifchannel_update_could_assert(ch);
87 pim_ifchannel_update_assert_tracking_desired(ch);
88 }
89 }
90
91 static void on_trace(const char *label, struct interface *ifp,
92 struct in_addr src)
93 {
94 if (PIM_DEBUG_PIM_TRACE) {
95 char src_str[INET_ADDRSTRLEN];
96 pim_inet4_dump("<src?>", src, src_str, sizeof(src_str));
97 zlog_debug("%s: from %s on %s", label, src_str, ifp->name);
98 }
99 }
100
101 static int preferred_assert(const struct pim_ifchannel *ch,
102 const struct pim_assert_metric *recv_metric)
103 {
104 return pim_assert_metric_better(recv_metric,
105 &ch->ifassert_winner_metric);
106 }
107
108 static int acceptable_assert(const struct pim_assert_metric *my_metric,
109 const struct pim_assert_metric *recv_metric)
110 {
111 return pim_assert_metric_better(recv_metric, my_metric);
112 }
113
114 static int inferior_assert(const struct pim_assert_metric *my_metric,
115 const struct pim_assert_metric *recv_metric)
116 {
117 return pim_assert_metric_better(my_metric, recv_metric);
118 }
119
120 static int cancel_assert(const struct pim_assert_metric *recv_metric)
121 {
122 return (recv_metric->metric_preference
123 == PIM_ASSERT_METRIC_PREFERENCE_MAX)
124 && (recv_metric->route_metric == PIM_ASSERT_ROUTE_METRIC_MAX);
125 }
126
127 static void if_could_assert_do_a1(const char *caller, struct pim_ifchannel *ch)
128 {
129 if (PIM_IF_FLAG_TEST_COULD_ASSERT(ch->flags)) {
130 if (assert_action_a1(ch)) {
131 zlog_warn(
132 "%s: %s: (S,G)=%s assert_action_a1 failure on interface %s",
133 __PRETTY_FUNCTION__, caller, ch->sg_str,
134 ch->interface->name);
135 /* log warning only */
136 }
137 }
138 }
139
140 static int dispatch_assert(struct interface *ifp, struct in_addr source_addr,
141 struct in_addr group_addr,
142 struct pim_assert_metric recv_metric)
143 {
144 struct pim_ifchannel *ch;
145 struct prefix_sg sg;
146
147 memset(&sg, 0, sizeof(struct prefix_sg));
148 sg.src = source_addr;
149 sg.grp = group_addr;
150 ch = pim_ifchannel_add(ifp, &sg, 0, 0);
151 if (!ch) {
152 zlog_warn(
153 "%s: (S,G)=%s failure creating channel on interface %s",
154 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg), ifp->name);
155 return -1;
156 }
157
158 switch (ch->ifassert_state) {
159 case PIM_IFASSERT_NOINFO:
160 if (recv_metric.rpt_bit_flag) {
161 /* RPT bit set */
162 if_could_assert_do_a1(__PRETTY_FUNCTION__, ch);
163 } else {
164 /* RPT bit clear */
165 if (inferior_assert(&ch->ifassert_my_metric,
166 &recv_metric)) {
167 if_could_assert_do_a1(__PRETTY_FUNCTION__, ch);
168 } else if (acceptable_assert(&ch->ifassert_my_metric,
169 &recv_metric)) {
170 if (PIM_IF_FLAG_TEST_ASSERT_TRACKING_DESIRED(
171 ch->flags)) {
172 assert_action_a6(ch, recv_metric);
173 }
174 }
175 }
176 break;
177 case PIM_IFASSERT_I_AM_WINNER:
178 if (preferred_assert(ch, &recv_metric)) {
179 assert_action_a2(ch, recv_metric);
180 } else {
181 if (inferior_assert(&ch->ifassert_my_metric,
182 &recv_metric)) {
183 assert_action_a3(ch);
184 }
185 }
186 break;
187 case PIM_IFASSERT_I_AM_LOSER:
188 if (recv_metric.ip_address.s_addr
189 == ch->ifassert_winner.s_addr) {
190 /* Assert from current winner */
191
192 if (cancel_assert(&recv_metric)) {
193 assert_action_a5(ch);
194 } else {
195 if (inferior_assert(&ch->ifassert_my_metric,
196 &recv_metric)) {
197 assert_action_a5(ch);
198 } else if (acceptable_assert(
199 &ch->ifassert_my_metric,
200 &recv_metric)) {
201 if (!recv_metric.rpt_bit_flag) {
202 assert_action_a2(ch,
203 recv_metric);
204 }
205 }
206 }
207 } else if (preferred_assert(ch, &recv_metric)) {
208 assert_action_a2(ch, recv_metric);
209 }
210 break;
211 default: {
212 zlog_warn(
213 "%s: (S,G)=%s invalid assert state %d on interface %s",
214 __PRETTY_FUNCTION__, ch->sg_str, ch->ifassert_state,
215 ifp->name);
216 }
217 return -2;
218 }
219
220 return 0;
221 }
222
223 int pim_assert_recv(struct interface *ifp, struct pim_neighbor *neigh,
224 struct in_addr src_addr, uint8_t *buf, int buf_size)
225 {
226 struct prefix_sg sg;
227 struct prefix msg_source_addr;
228 struct pim_assert_metric msg_metric;
229 int offset;
230 uint8_t *curr;
231 int curr_size;
232 struct pim_interface *pim_ifp = NULL;
233
234 on_trace(__PRETTY_FUNCTION__, ifp, src_addr);
235
236 curr = buf;
237 curr_size = buf_size;
238
239 /*
240 Parse assert group addr
241 */
242 memset(&sg, 0, sizeof(struct prefix_sg));
243 offset = pim_parse_addr_group(&sg, curr, curr_size);
244 if (offset < 1) {
245 char src_str[INET_ADDRSTRLEN];
246 pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
247 zlog_warn("%s: pim_parse_addr_group() failure: from %s on %s",
248 __PRETTY_FUNCTION__, src_str, ifp->name);
249 return -1;
250 }
251 curr += offset;
252 curr_size -= offset;
253
254 /*
255 Parse assert source addr
256 */
257 offset = pim_parse_addr_ucast(&msg_source_addr, curr, curr_size);
258 if (offset < 1) {
259 char src_str[INET_ADDRSTRLEN];
260 pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
261 zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
262 __PRETTY_FUNCTION__, src_str, ifp->name);
263 return -2;
264 }
265 curr += offset;
266 curr_size -= offset;
267
268 if (curr_size != 8) {
269 char src_str[INET_ADDRSTRLEN];
270 pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
271 zlog_warn(
272 "%s: preference/metric size is not 8: size=%d from %s on interface %s",
273 __PRETTY_FUNCTION__, curr_size, src_str, ifp->name);
274 return -3;
275 }
276
277 /*
278 Parse assert metric preference
279 */
280
281 msg_metric.metric_preference = pim_read_uint32_host(curr);
282
283 msg_metric.rpt_bit_flag = msg_metric.metric_preference
284 & 0x80000000; /* save highest bit */
285 msg_metric.metric_preference &= ~0x80000000; /* clear highest bit */
286
287 curr += 4;
288
289 /*
290 Parse assert route metric
291 */
292
293 msg_metric.route_metric = pim_read_uint32_host(curr);
294
295 if (PIM_DEBUG_PIM_TRACE) {
296 char neigh_str[INET_ADDRSTRLEN];
297 char source_str[INET_ADDRSTRLEN];
298 char group_str[INET_ADDRSTRLEN];
299 pim_inet4_dump("<neigh?>", src_addr, neigh_str,
300 sizeof(neigh_str));
301 pim_inet4_dump("<src?>", msg_source_addr.u.prefix4, source_str,
302 sizeof(source_str));
303 pim_inet4_dump("<grp?>", sg.grp, group_str, sizeof(group_str));
304 zlog_debug(
305 "%s: from %s on %s: (S,G)=(%s,%s) pref=%u metric=%u rpt_bit=%u",
306 __PRETTY_FUNCTION__, neigh_str, ifp->name, source_str,
307 group_str, msg_metric.metric_preference,
308 msg_metric.route_metric,
309 PIM_FORCE_BOOLEAN(msg_metric.rpt_bit_flag));
310 }
311
312 msg_metric.ip_address = src_addr;
313
314 pim_ifp = ifp->info;
315 zassert(pim_ifp);
316 ++pim_ifp->pim_ifstat_assert_recv;
317
318 return dispatch_assert(ifp, msg_source_addr.u.prefix4, sg.grp,
319 msg_metric);
320 }
321
322 /*
323 RFC 4601: 4.6.3. Assert Metrics
324
325 Assert metrics are defined as:
326
327 When comparing assert_metrics, the rpt_bit_flag, metric_preference,
328 and route_metric field are compared in order, where the first lower
329 value wins. If all fields are equal, the primary IP address of the
330 router that sourced the Assert message is used as a tie-breaker,
331 with the highest IP address winning.
332 */
333 int pim_assert_metric_better(const struct pim_assert_metric *m1,
334 const struct pim_assert_metric *m2)
335 {
336 if (m1->rpt_bit_flag < m2->rpt_bit_flag)
337 return 1;
338 if (m1->rpt_bit_flag > m2->rpt_bit_flag)
339 return 0;
340
341 if (m1->metric_preference < m2->metric_preference)
342 return 1;
343 if (m1->metric_preference > m2->metric_preference)
344 return 0;
345
346 if (m1->route_metric < m2->route_metric)
347 return 1;
348 if (m1->route_metric > m2->route_metric)
349 return 0;
350
351 return ntohl(m1->ip_address.s_addr) > ntohl(m2->ip_address.s_addr);
352 }
353
354 int pim_assert_metric_match(const struct pim_assert_metric *m1,
355 const struct pim_assert_metric *m2)
356 {
357 if (m1->rpt_bit_flag != m2->rpt_bit_flag)
358 return 0;
359 if (m1->metric_preference != m2->metric_preference)
360 return 0;
361 if (m1->route_metric != m2->route_metric)
362 return 0;
363
364 return m1->ip_address.s_addr == m2->ip_address.s_addr;
365 }
366
367 int pim_assert_build_msg(uint8_t *pim_msg, int buf_size, struct interface *ifp,
368 struct in_addr group_addr, struct in_addr source_addr,
369 uint32_t metric_preference, uint32_t route_metric,
370 uint32_t rpt_bit_flag)
371 {
372 uint8_t *buf_pastend = pim_msg + buf_size;
373 uint8_t *pim_msg_curr;
374 int pim_msg_size;
375 int remain;
376
377 pim_msg_curr =
378 pim_msg + PIM_MSG_HEADER_LEN; /* skip room for pim header */
379
380 /* Encode group */
381 remain = buf_pastend - pim_msg_curr;
382 pim_msg_curr = pim_msg_addr_encode_ipv4_group(pim_msg_curr, group_addr);
383 if (!pim_msg_curr) {
384 char group_str[INET_ADDRSTRLEN];
385 pim_inet4_dump("<grp?>", group_addr, group_str,
386 sizeof(group_str));
387 zlog_warn(
388 "%s: failure encoding group address %s: space left=%d",
389 __PRETTY_FUNCTION__, group_str, remain);
390 return -1;
391 }
392
393 /* Encode source */
394 remain = buf_pastend - pim_msg_curr;
395 pim_msg_curr =
396 pim_msg_addr_encode_ipv4_ucast(pim_msg_curr, source_addr);
397 if (!pim_msg_curr) {
398 char source_str[INET_ADDRSTRLEN];
399 pim_inet4_dump("<src?>", source_addr, source_str,
400 sizeof(source_str));
401 zlog_warn(
402 "%s: failure encoding source address %s: space left=%d",
403 __PRETTY_FUNCTION__, source_str, remain);
404 return -2;
405 }
406
407 /* Metric preference */
408 pim_write_uint32(pim_msg_curr,
409 rpt_bit_flag ? metric_preference | 0x80000000
410 : metric_preference);
411 pim_msg_curr += 4;
412
413 /* Route metric */
414 pim_write_uint32(pim_msg_curr, route_metric);
415 pim_msg_curr += 4;
416
417 /*
418 Add PIM header
419 */
420 pim_msg_size = pim_msg_curr - pim_msg;
421 pim_msg_build_header(pim_msg, pim_msg_size, PIM_MSG_TYPE_ASSERT);
422
423 return pim_msg_size;
424 }
425
426 static int pim_assert_do(struct pim_ifchannel *ch,
427 struct pim_assert_metric metric)
428 {
429 struct interface *ifp;
430 struct pim_interface *pim_ifp;
431 uint8_t pim_msg[1000];
432 int pim_msg_size;
433
434 ifp = ch->interface;
435 if (!ifp) {
436 if (PIM_DEBUG_PIM_TRACE)
437 zlog_debug("%s: channel%s has no associated interface!",
438 __PRETTY_FUNCTION__, ch->sg_str);
439 return -1;
440 }
441 pim_ifp = ifp->info;
442 if (!pim_ifp) {
443 if (PIM_DEBUG_PIM_TRACE)
444 zlog_debug(
445 "%s: channel %s pim not enabled on interface: %s",
446 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
447 return -1;
448 }
449
450 pim_msg_size =
451 pim_assert_build_msg(pim_msg, sizeof(pim_msg), ifp, ch->sg.grp,
452 ch->sg.src, metric.metric_preference,
453 metric.route_metric, metric.rpt_bit_flag);
454 if (pim_msg_size < 1) {
455 zlog_warn(
456 "%s: failure building PIM assert message: msg_size=%d",
457 __PRETTY_FUNCTION__, pim_msg_size);
458 return -2;
459 }
460
461 /*
462 RFC 4601: 4.3.1. Sending Hello Messages
463
464 Thus, if a router needs to send a Join/Prune or Assert message on
465 an interface on which it has not yet sent a Hello message with the
466 currently configured IP address, then it MUST immediately send the
467 relevant Hello message without waiting for the Hello Timer to
468 expire, followed by the Join/Prune or Assert message.
469 */
470 pim_hello_require(ifp);
471
472 if (PIM_DEBUG_PIM_TRACE) {
473 zlog_debug("%s: to %s: (S,G)=%s pref=%u metric=%u rpt_bit=%u",
474 __PRETTY_FUNCTION__, ifp->name, ch->sg_str,
475 metric.metric_preference, metric.route_metric,
476 PIM_FORCE_BOOLEAN(metric.rpt_bit_flag));
477 }
478 ++pim_ifp->pim_ifstat_assert_send;
479
480 if (pim_msg_send(pim_ifp->pim_sock_fd, pim_ifp->primary_address,
481 qpim_all_pim_routers_addr, pim_msg, pim_msg_size,
482 ifp->name)) {
483 zlog_warn("%s: could not send PIM message on interface %s",
484 __PRETTY_FUNCTION__, ifp->name);
485 return -3;
486 }
487
488 return 0;
489 }
490
491 int pim_assert_send(struct pim_ifchannel *ch)
492 {
493 return pim_assert_do(ch, ch->ifassert_my_metric);
494 }
495
496 /*
497 RFC 4601: 4.6.4. AssertCancel Messages
498
499 An AssertCancel(S,G) is an infinite metric assert with the RPT bit
500 set that names S as the source.
501 */
502 static int pim_assert_cancel(struct pim_ifchannel *ch)
503 {
504 struct pim_assert_metric metric;
505
506 metric.rpt_bit_flag = 0;
507 metric.metric_preference = PIM_ASSERT_METRIC_PREFERENCE_MAX;
508 metric.route_metric = PIM_ASSERT_ROUTE_METRIC_MAX;
509 metric.ip_address = ch->sg.src;
510
511 return pim_assert_do(ch, metric);
512 }
513
514 static int on_assert_timer(struct thread *t)
515 {
516 struct pim_ifchannel *ch;
517 struct interface *ifp;
518
519 ch = THREAD_ARG(t);
520
521 ifp = ch->interface;
522
523 if (PIM_DEBUG_PIM_TRACE) {
524 zlog_debug("%s: (S,G)=%s timer expired on interface %s",
525 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
526 }
527
528 ch->t_ifassert_timer = NULL;
529
530 switch (ch->ifassert_state) {
531 case PIM_IFASSERT_I_AM_WINNER:
532 assert_action_a3(ch);
533 break;
534 case PIM_IFASSERT_I_AM_LOSER:
535 assert_action_a5(ch);
536 break;
537 default: {
538 if (PIM_DEBUG_PIM_EVENTS)
539 zlog_warn(
540 "%s: (S,G)=%s invalid assert state %d on interface %s",
541 __PRETTY_FUNCTION__, ch->sg_str,
542 ch->ifassert_state, ifp->name);
543 }
544 }
545
546 return 0;
547 }
548
549 static void assert_timer_off(struct pim_ifchannel *ch)
550 {
551 if (PIM_DEBUG_PIM_TRACE) {
552 if (ch->t_ifassert_timer) {
553 zlog_debug(
554 "%s: (S,G)=%s cancelling timer on interface %s",
555 __PRETTY_FUNCTION__, ch->sg_str,
556 ch->interface->name);
557 }
558 }
559 THREAD_OFF(ch->t_ifassert_timer);
560 }
561
562 static void pim_assert_timer_set(struct pim_ifchannel *ch, int interval)
563 {
564 assert_timer_off(ch);
565
566 if (PIM_DEBUG_PIM_TRACE) {
567 zlog_debug("%s: (S,G)=%s starting %u sec timer on interface %s",
568 __PRETTY_FUNCTION__, ch->sg_str, interval,
569 ch->interface->name);
570 }
571
572 thread_add_timer(router->master, on_assert_timer, ch, interval,
573 &ch->t_ifassert_timer);
574 }
575
576 static void pim_assert_timer_reset(struct pim_ifchannel *ch)
577 {
578 pim_assert_timer_set(ch,
579 PIM_ASSERT_TIME - PIM_ASSERT_OVERRIDE_INTERVAL);
580 }
581
582 /*
583 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
584
585 (S,G) Assert State machine Actions
586
587 A1: Send Assert(S,G).
588 Set Assert Timer to (Assert_Time - Assert_Override_Interval).
589 Store self as AssertWinner(S,G,I).
590 Store spt_assert_metric(S,I) as AssertWinnerMetric(S,G,I).
591 */
592 int assert_action_a1(struct pim_ifchannel *ch)
593 {
594 struct interface *ifp = ch->interface;
595 struct pim_interface *pim_ifp;
596
597 pim_ifp = ifp->info;
598 if (!pim_ifp) {
599 zlog_warn("%s: (S,G)=%s multicast not enabled on interface %s",
600 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
601 return -1; /* must return since pim_ifp is used below */
602 }
603
604 /* Switch to I_AM_WINNER before performing action_a3 below */
605 pim_ifassert_winner_set(
606 ch, PIM_IFASSERT_I_AM_WINNER, pim_ifp->primary_address,
607 pim_macro_spt_assert_metric(&ch->upstream->rpf,
608 pim_ifp->primary_address));
609
610 if (assert_action_a3(ch)) {
611 zlog_warn(
612 "%s: (S,G)=%s assert_action_a3 failure on interface %s",
613 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
614 /* warning only */
615 }
616
617 if (ch->ifassert_state != PIM_IFASSERT_I_AM_WINNER) {
618 if (PIM_DEBUG_PIM_EVENTS)
619 zlog_warn(
620 "%s: channel%s not in expected PIM_IFASSERT_I_AM_WINNER state",
621 __PRETTY_FUNCTION__, ch->sg_str);
622 }
623
624 return 0;
625 }
626
627 /*
628 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
629
630 (S,G) Assert State machine Actions
631
632 A2: Store new assert winner as AssertWinner(S,G,I) and assert
633 winner metric as AssertWinnerMetric(S,G,I).
634 Set Assert Timer to Assert_Time.
635 */
636 static void assert_action_a2(struct pim_ifchannel *ch,
637 struct pim_assert_metric winner_metric)
638 {
639 pim_ifassert_winner_set(ch, PIM_IFASSERT_I_AM_LOSER,
640 winner_metric.ip_address, winner_metric);
641
642 pim_assert_timer_set(ch, PIM_ASSERT_TIME);
643
644 if (ch->ifassert_state != PIM_IFASSERT_I_AM_LOSER) {
645 if (PIM_DEBUG_PIM_EVENTS)
646 zlog_warn(
647 "%s: channel%s not in expected PIM_IFASSERT_I_AM_LOSER state",
648 __PRETTY_FUNCTION__, ch->sg_str);
649 }
650 }
651
652 /*
653 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
654
655 (S,G) Assert State machine Actions
656
657 A3: Send Assert(S,G).
658 Set Assert Timer to (Assert_Time - Assert_Override_Interval).
659 */
660 static int assert_action_a3(struct pim_ifchannel *ch)
661 {
662 if (ch->ifassert_state != PIM_IFASSERT_I_AM_WINNER) {
663 if (PIM_DEBUG_PIM_EVENTS)
664 zlog_warn(
665 "%s: channel%s expected to be in PIM_IFASSERT_I_AM_WINNER state",
666 __PRETTY_FUNCTION__, ch->sg_str);
667 return -1;
668 }
669
670 pim_assert_timer_reset(ch);
671
672 if (pim_assert_send(ch)) {
673 zlog_warn("%s: (S,G)=%s failure sending assert on interface %s",
674 __PRETTY_FUNCTION__, ch->sg_str, ch->interface->name);
675 return -1;
676 }
677
678 return 0;
679 }
680
681 /*
682 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
683
684 (S,G) Assert State machine Actions
685
686 A4: Send AssertCancel(S,G).
687 Delete assert info (AssertWinner(S,G,I) and
688 AssertWinnerMetric(S,G,I) will then return their default
689 values).
690 */
691 void assert_action_a4(struct pim_ifchannel *ch)
692 {
693 if (pim_assert_cancel(ch)) {
694 zlog_warn("%s: failure sending AssertCancel%s on interface %s",
695 __PRETTY_FUNCTION__, ch->sg_str, ch->interface->name);
696 /* log warning only */
697 }
698
699 assert_action_a5(ch);
700
701 if (ch->ifassert_state != PIM_IFASSERT_NOINFO) {
702 if (PIM_DEBUG_PIM_EVENTS)
703 zlog_warn(
704 "%s: channel%s not in PIM_IFASSERT_NOINFO state as expected",
705 __PRETTY_FUNCTION__, ch->sg_str);
706 }
707 }
708
709 /*
710 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
711
712 (S,G) Assert State machine Actions
713
714 A5: Delete assert info (AssertWinner(S,G,I) and
715 AssertWinnerMetric(S,G,I) will then return their default values).
716 */
717 void assert_action_a5(struct pim_ifchannel *ch)
718 {
719 reset_ifassert_state(ch);
720 if (ch->ifassert_state != PIM_IFASSERT_NOINFO) {
721 if (PIM_DEBUG_PIM_EVENTS)
722 zlog_warn(
723 "%s: channel%s not in PIM_IFSSERT_NOINFO state as expected",
724 __PRETTY_FUNCTION__, ch->sg_str);
725 }
726 }
727
728 /*
729 RFC 4601: 4.6.1. (S,G) Assert Message State Machine
730
731 (S,G) Assert State machine Actions
732
733 A6: Store new assert winner as AssertWinner(S,G,I) and assert
734 winner metric as AssertWinnerMetric(S,G,I).
735 Set Assert Timer to Assert_Time.
736 If (I is RPF_interface(S)) AND (UpstreamJPState(S,G) == true)
737 set SPTbit(S,G) to TRUE.
738 */
739 static void assert_action_a6(struct pim_ifchannel *ch,
740 struct pim_assert_metric winner_metric)
741 {
742 assert_action_a2(ch, winner_metric);
743
744 /*
745 If (I is RPF_interface(S)) AND (UpstreamJPState(S,G) == true) set
746 SPTbit(S,G) to TRUE.
747 */
748 if (ch->upstream->rpf.source_nexthop.interface == ch->interface)
749 if (ch->upstream->join_state == PIM_UPSTREAM_JOINED)
750 ch->upstream->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
751
752 if (ch->ifassert_state != PIM_IFASSERT_I_AM_LOSER) {
753 if (PIM_DEBUG_PIM_EVENTS)
754 zlog_warn(
755 "%s: channel%s not in PIM_IFASSERT_I_AM_LOSER state as expected",
756 __PRETTY_FUNCTION__, ch->sg_str);
757 }
758 }