pimd/pim_zebra.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 "if.h"
  23 #include "log.h"
  24 #include "prefix.h"
  25 #include "zclient.h"
  26 #include "stream.h"
  27 #include "network.h"
  28 #include "vty.h"
  29 #include "plist.h"
  30 #include "lib/bfd.h"
  31
  32 #include "pimd.h"
  33 #include "pim_pim.h"
  34 #include "pim_zebra.h"
  35 #include "pim_iface.h"
  36 #include "pim_str.h"
  37 #include "pim_oil.h"
  38 #include "pim_rpf.h"
  39 #include "pim_time.h"
  40 #include "pim_join.h"
  41 #include "pim_zlookup.h"
  42 #include "pim_ifchannel.h"
  43 #include "pim_rp.h"
  44 #include "pim_igmpv3.h"
  45 #include "pim_jp_agg.h"
  46 #include "pim_nht.h"
  47 #include "pim_ssm.h"
  48 #include "pim_vxlan.h"
  49 #include "pim_mlag.h"
  50
  51 #undef PIM_DEBUG_IFADDR_DUMP
  52 #define PIM_DEBUG_IFADDR_DUMP
  53
  54 struct zclient *zclient;
  55
  56
  57 /* Router-id update message from zebra. */
  58 static int pim_router_id_update_zebra(ZAPI_CALLBACK_ARGS)
  59 {
  60         struct prefix router_id;
  61
  62         zebra_router_id_update_read(zclient->ibuf, &router_id);
  63
  64         return 0;
  65 }
  66
  67 static int pim_zebra_interface_vrf_update(ZAPI_CALLBACK_ARGS)
  68 {
  69         struct interface *ifp;
  70         vrf_id_t new_vrf_id;
  71
  72         ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
  73                                               &new_vrf_id);
  74         if (!ifp)
  75                 return 0;
  76
  77         if (PIM_DEBUG_ZEBRA)
  78                 zlog_debug("%s: %s updating from %u to %u", __func__, ifp->name,
  79                            vrf_id, new_vrf_id);
  80
  81         if_update_to_new_vrf(ifp, new_vrf_id);
  82
  83         return 0;
  84 }
  85
  86 #ifdef PIM_DEBUG_IFADDR_DUMP
  87 static void dump_if_address(struct interface *ifp)
  88 {
  89         struct connected *ifc;
  90         struct listnode *node;
  91
  92         zlog_debug("%s %s: interface %s addresses:", __FILE__, __func__,
  93                    ifp->name);
  94
  95         for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
  96                 struct prefix *p = ifc->address;
  97
  98                 if (p->family != AF_INET)
  99                         continue;
 100
 101                 zlog_debug("%s %s: interface %s address %pI4 %s", __FILE__,
 102                            __func__, ifp->name, &p->u.prefix4,
 103                            CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY)
 104                                    ? "secondary"
 105                                    : "primary");
 106         }
 107 }
 108 #endif
 109
 110 static int pim_zebra_if_address_add(ZAPI_CALLBACK_ARGS)
 111 {
 112         struct connected *c;
 113         struct prefix *p;
 114         struct pim_interface *pim_ifp;
 115         struct pim_instance *pim;
 116
 117         /*
 118           zebra api notifies address adds/dels events by using the same call
 119           interface_add_read below, see comments in lib/zclient.c
 120
 121           zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD, ...)
 122           will add address to interface list by calling
 123           connected_add_by_prefix()
 124         */
 125         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 126         if (!c)
 127                 return 0;
 128
 129         pim_ifp = c->ifp->info;
 130         p = c->address;
 131
 132         if (PIM_DEBUG_ZEBRA) {
 133                 zlog_debug("%s: %s(%u) connected IP address %pFX flags %u %s",
 134                            __func__, c->ifp->name, vrf_id, p, c->flags,
 135                            CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)
 136                                    ? "secondary"
 137                                    : "primary");
 138
 139 #ifdef PIM_DEBUG_IFADDR_DUMP
 140                 dump_if_address(c->ifp);
 141 #endif
 142         }
 143
 144         if (!CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)) {
 145                 /* trying to add primary address */
 146
 147                 struct in_addr primary_addr = pim_find_primary_addr(c->ifp);
 148                 if (p->family != AF_INET
 149                     || primary_addr.s_addr != p->u.prefix4.s_addr) {
 150                         if (PIM_DEBUG_ZEBRA)
 151                                 zlog_warn(
 152                                         "%s: %s : forcing secondary flag on %pFX",
 153                                         __func__, c->ifp->name, p);
 154                         SET_FLAG(c->flags, ZEBRA_IFA_SECONDARY);
 155                 }
 156         }
 157
 158         pim_if_addr_add(c);
 159         if (pim_ifp) {
 160                 pim = pim_get_pim_instance(vrf_id);
 161                 pim_ifp->pim = pim;
 162
 163                 pim_rp_check_on_if_add(pim_ifp);
 164         }
 165
 166         if (if_is_loopback(c->ifp)) {
 167                 struct vrf *vrf = vrf_lookup_by_id(vrf_id);
 168                 struct interface *ifp;
 169
 170                 FOR_ALL_INTERFACES (vrf, ifp) {
 171                         if (!if_is_loopback(ifp) && if_is_operative(ifp))
 172                                 pim_if_addr_add_all(ifp);
 173                 }
 174         }
 175
 176         return 0;
 177 }
 178
 179 static int pim_zebra_if_address_del(ZAPI_CALLBACK_ARGS)
 180 {
 181         struct connected *c;
 182         struct prefix *p;
 183         struct vrf *vrf = vrf_lookup_by_id(vrf_id);
 184         struct pim_instance *pim;
 185
 186         if (!vrf)
 187                 return 0;
 188         pim = vrf->info;
 189
 190         /*
 191           zebra api notifies address adds/dels events by using the same call
 192           interface_add_read below, see comments in lib/zclient.c
 193
 194           zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE, ...)
 195           will remove address from interface list by calling
 196           connected_delete_by_prefix()
 197         */
 198         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 199         if (!c)
 200                 return 0;
 201
 202         p = c->address;
 203         if (p->family == AF_INET) {
 204                 if (PIM_DEBUG_ZEBRA) {
 205                         zlog_debug(
 206                                 "%s: %s(%u) disconnected IP address %pFX flags %u %s",
 207                                 __func__, c->ifp->name, vrf_id, p, c->flags,
 208                                 CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)
 209                                         ? "secondary"
 210                                         : "primary");
 211
 212 #ifdef PIM_DEBUG_IFADDR_DUMP
 213                         dump_if_address(c->ifp);
 214 #endif
 215                 }
 216
 217                 pim_if_addr_del(c, 0);
 218                 pim_rp_setup(pim);
 219                 pim_i_am_rp_re_evaluate(pim);
 220         }
 221
 222         connected_free(&c);
 223         return 0;
 224 }
 225
 226 void pim_zebra_update_all_interfaces(struct pim_instance *pim)
 227 {
 228         struct interface *ifp;
 229
 230         FOR_ALL_INTERFACES (pim->vrf, ifp) {
 231                 struct pim_interface *pim_ifp = ifp->info;
 232                 struct pim_iface_upstream_switch *us;
 233                 struct listnode *node;
 234
 235                 if (!pim_ifp)
 236                         continue;
 237
 238                 for (ALL_LIST_ELEMENTS_RO(pim_ifp->upstream_switch_list, node,
 239                                           us)) {
 240                         struct pim_rpf rpf;
 241
 242                         rpf.source_nexthop.interface = ifp;
 243                         rpf.rpf_addr.u.prefix4 = us->address;
 244                         pim_joinprune_send(&rpf, us->us);
 245                         pim_jp_agg_clear_group(us->us);
 246                 }
 247         }
 248 }
 249
 250 void pim_zebra_upstream_rpf_changed(struct pim_instance *pim,
 251                                     struct pim_upstream *up,
 252                                     struct pim_rpf *old)
 253 {
 254         if (old->source_nexthop.interface) {
 255                 struct pim_neighbor *nbr;
 256
 257                 nbr = pim_neighbor_find(old->source_nexthop.interface,
 258                                         old->rpf_addr.u.prefix4);
 259                 if (nbr)
 260                         pim_jp_agg_remove_group(nbr->upstream_jp_agg, up, nbr);
 261
 262                 /*
 263                  * We have detected a case where we might need
 264                  * to rescan the inherited o_list so do it.
 265                  */
 266                 if (up->channel_oil->oil_inherited_rescan) {
 267                         pim_upstream_inherited_olist_decide(pim, up);
 268                         up->channel_oil->oil_inherited_rescan = 0;
 269                 }
 270
 271                 if (up->join_state == PIM_UPSTREAM_JOINED) {
 272                         /*
 273                          * If we come up real fast we can be here
 274                          * where the mroute has not been installed
 275                          * so install it.
 276                          */
 277                         if (!up->channel_oil->installed)
 278                                 pim_upstream_mroute_add(up->channel_oil,
 279                                                         __func__);
 280
 281                         /*
 282                          * RFC 4601: 4.5.7.  Sending (S,G)
 283                          * Join/Prune Messages
 284                          *
 285                          * Transitions from Joined State
 286                          *
 287                          * RPF'(S,G) changes not due to an Assert
 288                          *
 289                          * The upstream (S,G) state machine remains
 290                          * in Joined state. Send Join(S,G) to the new
 291                          * upstream neighbor, which is the new value
 292                          * of RPF'(S,G).  Send Prune(S,G) to the old
 293                          * upstream neighbor, which is the old value
 294                          * of RPF'(S,G).  Set the Join Timer (JT) to
 295                          * expire after t_periodic seconds.
 296                          */
 297                         pim_jp_agg_switch_interface(old, &up->rpf, up);
 298
 299                         pim_upstream_join_timer_restart(up, old);
 300                 } /* up->join_state == PIM_UPSTREAM_JOINED */
 301         }
 302
 303         else {
 304                 /*
 305                  * We have detected a case where we might need
 306                  * to rescan the inherited o_list so do it.
 307                  */
 308                 if (up->channel_oil->oil_inherited_rescan) {
 309                         pim_upstream_inherited_olist_decide(pim, up);
 310                         up->channel_oil->oil_inherited_rescan = 0;
 311                 }
 312
 313                 if (up->join_state == PIM_UPSTREAM_JOINED)
 314                         pim_jp_agg_switch_interface(old, &up->rpf, up);
 315
 316                 if (!up->channel_oil->installed)
 317                         pim_upstream_mroute_add(up->channel_oil, __func__);
 318         }
 319
 320         /* FIXME can join_desired actually be changed by pim_rpf_update()
 321          * returning PIM_RPF_CHANGED ?
 322          */
 323         pim_upstream_update_join_desired(pim, up);
 324 }
 325
 326 static int pim_zebra_vxlan_sg_proc(ZAPI_CALLBACK_ARGS)
 327 {
 328         struct stream *s;
 329         struct pim_instance *pim;
 330         struct prefix_sg sg;
 331
 332         pim = pim_get_pim_instance(vrf_id);
 333         if (!pim)
 334                 return 0;
 335
 336         s = zclient->ibuf;
 337
 338         sg.family = AF_INET;
 339         sg.prefixlen = stream_getl(s);
 340         stream_get(&sg.src.s_addr, s, sg.prefixlen);
 341         stream_get(&sg.grp.s_addr, s, sg.prefixlen);
 342
 343         if (PIM_DEBUG_ZEBRA) {
 344                 char sg_str[PIM_SG_LEN];
 345
 346                 pim_str_sg_set(&sg, sg_str);
 347                 zlog_debug("%u:recv SG %s %s", vrf_id,
 348                         (cmd == ZEBRA_VXLAN_SG_ADD)?"add":"del",
 349                         sg_str);
 350         }
 351
 352         if (cmd == ZEBRA_VXLAN_SG_ADD)
 353                 pim_vxlan_sg_add(pim, &sg);
 354         else
 355                 pim_vxlan_sg_del(pim, &sg);
 356
 357         return 0;
 358 }
 359
 360 static void pim_zebra_vxlan_replay(void)
 361 {
 362         struct stream *s = NULL;
 363
 364         /* Check socket. */
 365         if (!zclient || zclient->sock < 0)
 366                 return;
 367
 368         s = zclient->obuf;
 369         stream_reset(s);
 370
 371         zclient_create_header(s, ZEBRA_VXLAN_SG_REPLAY, VRF_DEFAULT);
 372         stream_putw_at(s, 0, stream_get_endp(s));
 373
 374         zclient_send_message(zclient);
 375 }
 376
 377 void pim_scan_oil(struct pim_instance *pim)
 378 {
 379         struct channel_oil *c_oil;
 380
 381         pim->scan_oil_last = pim_time_monotonic_sec();
 382         ++pim->scan_oil_events;
 383
 384         frr_each (rb_pim_oil, &pim->channel_oil_head, c_oil)
 385                 pim_upstream_mroute_iif_update(c_oil, __func__);
 386 }
 387
 388 static int on_rpf_cache_refresh(struct thread *t)
 389 {
 390         struct pim_instance *pim = THREAD_ARG(t);
 391
 392         /* update kernel multicast forwarding cache (MFC) */
 393         pim_scan_oil(pim);
 394
 395         pim->rpf_cache_refresh_last = pim_time_monotonic_sec();
 396         ++pim->rpf_cache_refresh_events;
 397
 398         // It is called as part of pim_neighbor_add
 399         // pim_rp_setup ();
 400         return 0;
 401 }
 402
 403 void sched_rpf_cache_refresh(struct pim_instance *pim)
 404 {
 405         ++pim->rpf_cache_refresh_requests;
 406
 407         pim_rpf_set_refresh_time(pim);
 408
 409         if (pim->rpf_cache_refresher) {
 410                 /* Refresh timer is already running */
 411                 return;
 412         }
 413
 414         /* Start refresh timer */
 415
 416         if (PIM_DEBUG_ZEBRA) {
 417                 zlog_debug("%s: triggering %ld msec timer", __func__,
 418                            router->rpf_cache_refresh_delay_msec);
 419         }
 420
 421         thread_add_timer_msec(router->master, on_rpf_cache_refresh, pim,
 422                               router->rpf_cache_refresh_delay_msec,
 423                               &pim->rpf_cache_refresher);
 424 }
 425
 426 static void pim_zebra_connected(struct zclient *zclient)
 427 {
 428         /* Send the client registration */
 429         bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, router->vrf_id);
 430
 431         zclient_send_reg_requests(zclient, router->vrf_id);
 432
 433         /* request for VxLAN BUM group addresses */
 434         pim_zebra_vxlan_replay();
 435 }
 436
 437 static void pim_zebra_capabilities(struct zclient_capabilities *cap)
 438 {
 439         router->mlag_role = cap->role;
 440 }
 441
 442 static zclient_handler *const pim_handlers[] = {
 443         [ZEBRA_ROUTER_ID_UPDATE] = pim_router_id_update_zebra,
 444         [ZEBRA_INTERFACE_ADDRESS_ADD] = pim_zebra_if_address_add,
 445         [ZEBRA_INTERFACE_ADDRESS_DELETE] = pim_zebra_if_address_del,
 446         [ZEBRA_INTERFACE_VRF_UPDATE] = pim_zebra_interface_vrf_update,
 447         [ZEBRA_NEXTHOP_UPDATE] = pim_parse_nexthop_update,
 448
 449         [ZEBRA_VXLAN_SG_ADD] = pim_zebra_vxlan_sg_proc,
 450         [ZEBRA_VXLAN_SG_DEL] = pim_zebra_vxlan_sg_proc,
 451
 452         [ZEBRA_MLAG_PROCESS_UP] = pim_zebra_mlag_process_up,
 453         [ZEBRA_MLAG_PROCESS_DOWN] = pim_zebra_mlag_process_down,
 454         [ZEBRA_MLAG_FORWARD_MSG] = pim_zebra_mlag_handle_msg,
 455 };
 456
 457 void pim_zebra_init(void)
 458 {
 459         /* Socket for receiving updates from Zebra daemon */
 460         zclient = zclient_new(router->master, &zclient_options_default,
 461                               pim_handlers, array_size(pim_handlers));
 462
 463         zclient->zebra_capabilities = pim_zebra_capabilities;
 464         zclient->zebra_connected = pim_zebra_connected;
 465
 466         zclient_init(zclient, ZEBRA_ROUTE_PIM, 0, &pimd_privs);
 467         if (PIM_DEBUG_PIM_TRACE) {
 468                 zlog_notice("%s: zclient socket initialized", __func__);
 469         }
 470
 471         zclient_lookup_new();
 472 }
 473
 474 void igmp_anysource_forward_start(struct pim_instance *pim,
 475                                   struct igmp_group *group)
 476 {
 477         struct igmp_source *source;
 478         struct in_addr src_addr = {.s_addr = 0};
 479         /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
 480         assert(group->group_filtermode_isexcl);
 481         assert(listcount(group->group_source_list) < 1);
 482
 483         source = igmp_get_source_by_addr(group, src_addr, NULL);
 484         if (!source) {
 485                 zlog_warn("%s: Failure to create * source", __func__);
 486                 return;
 487         }
 488
 489         igmp_source_forward_start(pim, source);
 490 }
 491
 492 void igmp_anysource_forward_stop(struct igmp_group *group)
 493 {
 494         struct igmp_source *source;
 495         struct in_addr star = {.s_addr = 0};
 496
 497         source = igmp_find_source_by_addr(group, star);
 498         if (source)
 499                 igmp_source_forward_stop(source);
 500 }
 501
 502 static void igmp_source_forward_reevaluate_one(struct pim_instance *pim,
 503                                                struct igmp_source *source)
 504 {
 505         struct prefix_sg sg;
 506         struct igmp_group *group = source->source_group;
 507         struct pim_ifchannel *ch;
 508
 509         if ((source->source_addr.s_addr != INADDR_ANY)
 510             || !IGMP_SOURCE_TEST_FORWARDING(source->source_flags))
 511                 return;
 512
 513         memset(&sg, 0, sizeof(struct prefix_sg));
 514         sg.src = source->source_addr;
 515         sg.grp = group->group_addr;
 516
 517         ch = pim_ifchannel_find(group->interface, &sg);
 518         if (pim_is_grp_ssm(pim, group->group_addr)) {
 519                 /* If SSM group withdraw local membership */
 520                 if (ch
 521                     && (ch->local_ifmembership == PIM_IFMEMBERSHIP_INCLUDE)) {
 522                         if (PIM_DEBUG_PIM_EVENTS)
 523                                 zlog_debug(
 524                                         "local membership del for %s as G is now SSM",
 525                                         pim_str_sg_dump(&sg));
 526                         pim_ifchannel_local_membership_del(group->interface,
 527                                                            &sg);
 528                 }
 529         } else {
 530                 /* If ASM group add local membership */
 531                 if (!ch
 532                     || (ch->local_ifmembership == PIM_IFMEMBERSHIP_NOINFO)) {
 533                         if (PIM_DEBUG_PIM_EVENTS)
 534                                 zlog_debug(
 535                                         "local membership add for %s as G is now ASM",
 536                                         pim_str_sg_dump(&sg));
 537                         pim_ifchannel_local_membership_add(
 538                                 group->interface, &sg, false /*is_vxlan*/);
 539                 }
 540         }
 541 }
 542
 543 void igmp_source_forward_reevaluate_all(struct pim_instance *pim)
 544 {
 545         struct interface *ifp;
 546
 547         FOR_ALL_INTERFACES (pim->vrf, ifp) {
 548                 struct pim_interface *pim_ifp = ifp->info;
 549                 struct listnode *grpnode;
 550                 struct igmp_group *grp;
 551                 struct pim_ifchannel *ch, *ch_temp;
 552
 553                 if (!pim_ifp)
 554                         continue;
 555
 556                 /* scan igmp groups */
 557                 for (ALL_LIST_ELEMENTS_RO(pim_ifp->igmp_group_list, grpnode,
 558                                           grp)) {
 559                         struct listnode *srcnode;
 560                         struct igmp_source *src;
 561
 562                         /* scan group sources */
 563                         for (ALL_LIST_ELEMENTS_RO(grp->group_source_list,
 564                                                   srcnode, src)) {
 565                                 igmp_source_forward_reevaluate_one(pim, src);
 566                         } /* scan group sources */
 567                 }        /* scan igmp groups */
 568
 569                 RB_FOREACH_SAFE (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb,
 570                                  ch_temp) {
 571                         if (pim_is_grp_ssm(pim, ch->sg.grp)) {
 572                                 if (ch->sg.src.s_addr == INADDR_ANY)
 573                                         pim_ifchannel_delete(ch);
 574                         }
 575                 }
 576         } /* scan interfaces */
 577 }
 578
 579 void igmp_source_forward_start(struct pim_instance *pim,
 580                                struct igmp_source *source)
 581 {
 582         struct pim_interface *pim_oif;
 583         struct igmp_group *group;
 584         struct prefix_sg sg;
 585         int result;
 586         int input_iface_vif_index = 0;
 587
 588         memset(&sg, 0, sizeof(struct prefix_sg));
 589         sg.src = source->source_addr;
 590         sg.grp = source->source_group->group_addr;
 591
 592         if (PIM_DEBUG_IGMP_TRACE) {
 593                 zlog_debug("%s: (S,G)=%s oif=%s fwd=%d", __func__,
 594                            pim_str_sg_dump(&sg),
 595                            source->source_group->interface->name,
 596                            IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
 597         }
 598
 599         /* Prevent IGMP interface from installing multicast route multiple
 600            times */
 601         if (IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
 602                 return;
 603         }
 604
 605         group = source->source_group;
 606         pim_oif = group->interface->info;
 607         if (!pim_oif) {
 608                 if (PIM_DEBUG_IGMP_TRACE) {
 609                         zlog_debug("%s: multicast not enabled on oif=%s ?",
 610                                    __func__,
 611                                    source->source_group->interface->name);
 612                 }
 613                 return;
 614         }
 615
 616         if (!source->source_channel_oil) {
 617                 struct in_addr vif_source;
 618                 struct prefix src, grp;
 619                 struct pim_nexthop nexthop;
 620                 struct pim_upstream *up = NULL;
 621
 622                 if (!pim_rp_set_upstream_addr(pim, &vif_source,
 623                                               source->source_addr, sg.grp)) {
 624                         /*Create a dummy channel oil */
 625                         source->source_channel_oil =
 626                                 pim_channel_oil_add(pim, &sg, __func__);
 627                 }
 628
 629                 else {
 630                         src.family = AF_INET;
 631                         src.prefixlen = IPV4_MAX_BITLEN;
 632                         src.u.prefix4 = vif_source; // RP or Src address
 633                         grp.family = AF_INET;
 634                         grp.prefixlen = IPV4_MAX_BITLEN;
 635                         grp.u.prefix4 = sg.grp;
 636
 637                         up = pim_upstream_find(pim, &sg);
 638                         if (up) {
 639                                 memcpy(&nexthop, &up->rpf.source_nexthop,
 640                                        sizeof(struct pim_nexthop));
 641                                 pim_ecmp_nexthop_lookup(pim, &nexthop, &src,
 642                                                         &grp, 0);
 643                                 if (nexthop.interface)
 644                                         input_iface_vif_index =
 645                                                 pim_if_find_vifindex_by_ifindex(
 646                                                         pim,
 647                                                         nexthop.interface->ifindex);
 648                         } else
 649                                 input_iface_vif_index =
 650                                         pim_ecmp_fib_lookup_if_vif_index(
 651                                                 pim, &src, &grp);
 652
 653                         if (PIM_DEBUG_ZEBRA) {
 654                                 char buf2[INET_ADDRSTRLEN];
 655
 656                                 pim_inet4_dump("<source?>", vif_source, buf2,
 657                                                sizeof(buf2));
 658                                 zlog_debug(
 659                                         "%s: NHT %s vif_source %s vif_index:%d ",
 660                                         __func__, pim_str_sg_dump(&sg), buf2,
 661                                         input_iface_vif_index);
 662                         }
 663
 664                         if (input_iface_vif_index < 1) {
 665                                 if (PIM_DEBUG_IGMP_TRACE) {
 666                                         char source_str[INET_ADDRSTRLEN];
 667                                         pim_inet4_dump("<source?>",
 668                                                 source->source_addr,
 669                                                 source_str, sizeof(source_str));
 670                                         zlog_debug(
 671                                                 "%s %s: could not find input interface for source %s",
 672                                                 __FILE__, __func__, source_str);
 673                                 }
 674                                 source->source_channel_oil =
 675                                         pim_channel_oil_add(pim, &sg, __func__);
 676                         }
 677
 678                         else {
 679                                 /*
 680                                  * Protect IGMP against adding looped MFC
 681                                  * entries created by both source and receiver
 682                                  * attached to the same interface. See TODO
 683                                  * T22. Block only when the intf is non DR
 684                                  * DR must create upstream.
 685                                  */
 686                                 if ((input_iface_vif_index ==
 687                                     pim_oif->mroute_vif_index) &&
 688                                     !(PIM_I_am_DR(pim_oif))) {
 689                                         /* ignore request for looped MFC entry
 690                                          */
 691                                         if (PIM_DEBUG_IGMP_TRACE) {
 692                                                 zlog_debug(
 693                                                         "%s: ignoring request for looped MFC entry (S,G)=%s: oif=%s vif_index=%d",
 694                                                         __func__,
 695                                                         pim_str_sg_dump(&sg),
 696                                                         source->source_group
 697                                                                 ->interface->name,
 698                                                         input_iface_vif_index);
 699                                         }
 700                                         return;
 701                                 }
 702
 703                                 source->source_channel_oil =
 704                                         pim_channel_oil_add(pim, &sg, __func__);
 705                                 if (!source->source_channel_oil) {
 706                                         if (PIM_DEBUG_IGMP_TRACE) {
 707                                                 zlog_debug(
 708                                                         "%s %s: could not create OIL for channel (S,G)=%s",
 709                                                         __FILE__, __func__,
 710                                                         pim_str_sg_dump(&sg));
 711                                         }
 712                                         return;
 713                                 }
 714                         }
 715                 }
 716         }
 717
 718         if (PIM_I_am_DR(pim_oif) || PIM_I_am_DualActive(pim_oif)) {
 719                 result = pim_channel_add_oif(source->source_channel_oil,
 720                                              group->interface,
 721                                              PIM_OIF_FLAG_PROTO_IGMP, __func__);
 722                 if (result) {
 723                         if (PIM_DEBUG_MROUTE) {
 724                                 zlog_warn("%s: add_oif() failed with return=%d",
 725                                           __func__, result);
 726                         }
 727                         return;
 728                 }
 729         } else {
 730                 if (PIM_DEBUG_IGMP_TRACE)
 731                         zlog_debug(
 732                                 "%s: %s was received on %s interface but we are not DR for that interface",
 733                                 __func__, pim_str_sg_dump(&sg),
 734                                 group->interface->name);
 735
 736                 return;
 737         }
 738         /*
 739           Feed IGMPv3-gathered local membership information into PIM
 740           per-interface (S,G) state.
 741          */
 742         if (!pim_ifchannel_local_membership_add(group->interface, &sg,
 743                                                 false /*is_vxlan*/)) {
 744                 if (PIM_DEBUG_MROUTE)
 745                         zlog_warn("%s: Failure to add local membership for %s",
 746                                   __func__, pim_str_sg_dump(&sg));
 747
 748                 pim_channel_del_oif(source->source_channel_oil,
 749                                     group->interface, PIM_OIF_FLAG_PROTO_IGMP,
 750                                     __func__);
 751                 return;
 752         }
 753
 754         IGMP_SOURCE_DO_FORWARDING(source->source_flags);
 755 }
 756
 757 /*
 758   igmp_source_forward_stop: stop fowarding, but keep the source
 759   igmp_source_delete:       stop fowarding, and delete the source
 760  */
 761 void igmp_source_forward_stop(struct igmp_source *source)
 762 {
 763         struct igmp_group *group;
 764         struct prefix_sg sg;
 765         int result;
 766
 767         memset(&sg, 0, sizeof(struct prefix_sg));
 768         sg.src = source->source_addr;
 769         sg.grp = source->source_group->group_addr;
 770
 771         if (PIM_DEBUG_IGMP_TRACE) {
 772                 zlog_debug("%s: (S,G)=%s oif=%s fwd=%d", __func__,
 773                            pim_str_sg_dump(&sg),
 774                            source->source_group->interface->name,
 775                            IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
 776         }
 777
 778         /* Prevent IGMP interface from removing multicast route multiple
 779            times */
 780         if (!IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
 781                 return;
 782         }
 783
 784         group = source->source_group;
 785
 786         /*
 787          It appears that in certain circumstances that
 788          igmp_source_forward_stop is called when IGMP forwarding
 789          was not enabled in oif_flags for this outgoing interface.
 790          Possibly because of multiple calls. When that happens, we
 791          enter the below if statement and this function returns early
 792          which in turn triggers the calling function to assert.
 793          Making the call to pim_channel_del_oif and ignoring the return code
 794          fixes the issue without ill effect, similar to
 795          pim_forward_stop below.
 796         */
 797         result = pim_channel_del_oif(source->source_channel_oil,
 798                                      group->interface, PIM_OIF_FLAG_PROTO_IGMP,
 799                                      __func__);
 800         if (result) {
 801                 if (PIM_DEBUG_IGMP_TRACE)
 802                         zlog_debug(
 803                                 "%s: pim_channel_del_oif() failed with return=%d",
 804                                 __func__, result);
 805                 return;
 806         }
 807
 808         /*
 809           Feed IGMPv3-gathered local membership information into PIM
 810           per-interface (S,G) state.
 811          */
 812         pim_ifchannel_local_membership_del(group->interface, &sg);
 813
 814         IGMP_SOURCE_DONT_FORWARDING(source->source_flags);
 815 }
 816
 817 void pim_forward_start(struct pim_ifchannel *ch)
 818 {
 819         struct pim_upstream *up = ch->upstream;
 820         uint32_t mask = 0;
 821
 822         if (PIM_DEBUG_PIM_TRACE) {
 823                 char source_str[INET_ADDRSTRLEN];
 824                 char group_str[INET_ADDRSTRLEN];
 825                 char upstream_str[INET_ADDRSTRLEN];
 826
 827                 pim_inet4_dump("<source?>", ch->sg.src, source_str,
 828                                sizeof(source_str));
 829                 pim_inet4_dump("<group?>", ch->sg.grp, group_str,
 830                                sizeof(group_str));
 831                 pim_inet4_dump("<upstream?>", up->upstream_addr, upstream_str,
 832                                sizeof(upstream_str));
 833                 zlog_debug("%s: (S,G)=(%s,%s) oif=%s (%pI4)", __func__,
 834                            source_str, group_str, ch->interface->name,
 835                            &up->upstream_addr);
 836         }
 837
 838         if (PIM_IF_FLAG_TEST_PROTO_IGMP(ch->flags))
 839                 mask = PIM_OIF_FLAG_PROTO_IGMP;
 840
 841         if (PIM_IF_FLAG_TEST_PROTO_PIM(ch->flags))
 842                 mask |= PIM_OIF_FLAG_PROTO_PIM;
 843
 844         pim_channel_add_oif(up->channel_oil, ch->interface,
 845                         mask, __func__);
 846 }
 847
 848 void pim_forward_stop(struct pim_ifchannel *ch)
 849 {
 850         struct pim_upstream *up = ch->upstream;
 851
 852         if (PIM_DEBUG_PIM_TRACE) {
 853                 zlog_debug("%s: (S,G)=%s oif=%s installed: %d",
 854                            __func__, ch->sg_str, ch->interface->name,
 855                            up->channel_oil->installed);
 856         }
 857
 858         /*
 859          * If a channel is being removed, check to see if we still need
 860          * to inherit the interface.  If so make sure it is added in
 861          */
 862         if (pim_upstream_evaluate_join_desired_interface(up, ch, ch->parent))
 863                 pim_channel_add_oif(up->channel_oil, ch->interface,
 864                                     PIM_OIF_FLAG_PROTO_PIM, __func__);
 865         else
 866                 pim_channel_del_oif(up->channel_oil, ch->interface,
 867                                     PIM_OIF_FLAG_PROTO_PIM, __func__);
 868 }
 869
 870 void pim_zebra_zclient_update(struct vty *vty)
 871 {
 872         vty_out(vty, "Zclient update socket: ");
 873
 874         if (zclient) {
 875                 vty_out(vty, "%d failures=%d\n", zclient->sock, zclient->fail);
 876         } else {
 877                 vty_out(vty, "<null zclient>\n");
 878         }
 879 }
 880
 881 struct zclient *pim_zebra_zclient_get(void)
 882 {
 883         if (zclient)
 884                 return zclient;
 885         else
 886                 return NULL;
 887 }
 888
 889 void pim_zebra_interface_set_master(struct interface *vrf,
 890                                     struct interface *ifp)
 891 {
 892         zclient_interface_set_master(zclient, vrf, ifp);
 893 }