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