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_DEFAULT);
 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 void pim_zebra_init(void)
 443 {
 444         /* Socket for receiving updates from Zebra daemon */
 445         zclient = zclient_new(router->master, &zclient_options_default);
 446
 447         zclient->zebra_capabilities = pim_zebra_capabilities;
 448         zclient->zebra_connected = pim_zebra_connected;
 449         zclient->router_id_update = pim_router_id_update_zebra;
 450         zclient->interface_address_add = pim_zebra_if_address_add;
 451         zclient->interface_address_delete = pim_zebra_if_address_del;
 452         zclient->interface_vrf_update = pim_zebra_interface_vrf_update;
 453         zclient->nexthop_update = pim_parse_nexthop_update;
 454         zclient->vxlan_sg_add = pim_zebra_vxlan_sg_proc;
 455         zclient->vxlan_sg_del = pim_zebra_vxlan_sg_proc;
 456         zclient->mlag_process_up = pim_zebra_mlag_process_up;
 457         zclient->mlag_process_down = pim_zebra_mlag_process_down;
 458         zclient->mlag_handle_msg = pim_zebra_mlag_handle_msg;
 459
 460         zclient_init(zclient, ZEBRA_ROUTE_PIM, 0, &pimd_privs);
 461         if (PIM_DEBUG_PIM_TRACE) {
 462                 zlog_notice("%s: zclient socket initialized", __func__);
 463         }
 464
 465         zclient_lookup_new();
 466 }
 467
 468 void igmp_anysource_forward_start(struct pim_instance *pim,
 469                                   struct igmp_group *group)
 470 {
 471         struct igmp_source *source;
 472         struct in_addr src_addr = {.s_addr = 0};
 473         /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
 474         assert(group->group_filtermode_isexcl);
 475         assert(listcount(group->group_source_list) < 1);
 476
 477         source = source_new(group, src_addr);
 478         if (!source) {
 479                 zlog_warn("%s: Failure to create * source", __func__);
 480                 return;
 481         }
 482
 483         igmp_source_forward_start(pim, source);
 484 }
 485
 486 void igmp_anysource_forward_stop(struct igmp_group *group)
 487 {
 488         struct igmp_source *source;
 489         struct in_addr star = {.s_addr = 0};
 490
 491         source = igmp_find_source_by_addr(group, star);
 492         if (source)
 493                 igmp_source_forward_stop(source);
 494 }
 495
 496 static void igmp_source_forward_reevaluate_one(struct pim_instance *pim,
 497                                                struct igmp_source *source)
 498 {
 499         struct prefix_sg sg;
 500         struct igmp_group *group = source->source_group;
 501         struct pim_ifchannel *ch;
 502
 503         if ((source->source_addr.s_addr != INADDR_ANY)
 504             || !IGMP_SOURCE_TEST_FORWARDING(source->source_flags))
 505                 return;
 506
 507         memset(&sg, 0, sizeof(struct prefix_sg));
 508         sg.src = source->source_addr;
 509         sg.grp = group->group_addr;
 510
 511         ch = pim_ifchannel_find(group->group_igmp_sock->interface, &sg);
 512         if (pim_is_grp_ssm(pim, group->group_addr)) {
 513                 /* If SSM group withdraw local membership */
 514                 if (ch
 515                     && (ch->local_ifmembership == PIM_IFMEMBERSHIP_INCLUDE)) {
 516                         if (PIM_DEBUG_PIM_EVENTS)
 517                                 zlog_debug(
 518                                         "local membership del for %s as G is now SSM",
 519                                         pim_str_sg_dump(&sg));
 520                         pim_ifchannel_local_membership_del(
 521                                 group->group_igmp_sock->interface, &sg);
 522                 }
 523         } else {
 524                 /* If ASM group add local membership */
 525                 if (!ch
 526                     || (ch->local_ifmembership == PIM_IFMEMBERSHIP_NOINFO)) {
 527                         if (PIM_DEBUG_PIM_EVENTS)
 528                                 zlog_debug(
 529                                         "local membership add for %s as G is now ASM",
 530                                         pim_str_sg_dump(&sg));
 531                         pim_ifchannel_local_membership_add(
 532                                 group->group_igmp_sock->interface, &sg,
 533                                 false /*is_vxlan*/);
 534                 }
 535         }
 536 }
 537
 538 void igmp_source_forward_reevaluate_all(struct pim_instance *pim)
 539 {
 540         struct interface *ifp;
 541
 542         FOR_ALL_INTERFACES (pim->vrf, ifp) {
 543                 struct pim_interface *pim_ifp = ifp->info;
 544                 struct listnode *sock_node;
 545                 struct igmp_sock *igmp;
 546
 547                 if (!pim_ifp)
 548                         continue;
 549
 550                 /* scan igmp sockets */
 551                 for (ALL_LIST_ELEMENTS_RO(pim_ifp->igmp_socket_list, sock_node,
 552                                           igmp)) {
 553                         struct listnode *grpnode;
 554                         struct igmp_group *grp;
 555
 556                         /* scan igmp groups */
 557                         for (ALL_LIST_ELEMENTS_RO(igmp->igmp_group_list,
 558                                                   grpnode, grp)) {
 559                                 struct listnode *srcnode;
 560                                 struct igmp_source *src;
 561
 562                                 /* scan group sources */
 563                                 for (ALL_LIST_ELEMENTS_RO(
 564                                              grp->group_source_list, srcnode,
 565                                              src)) {
 566                                         igmp_source_forward_reevaluate_one(pim,
 567                                                                            src);
 568                                 } /* scan group sources */
 569                         }        /* scan igmp groups */
 570                 }                 /* scan igmp sockets */
 571         }                         /* scan interfaces */
 572 }
 573
 574 void igmp_source_forward_start(struct pim_instance *pim,
 575                                struct igmp_source *source)
 576 {
 577         struct pim_interface *pim_oif;
 578         struct igmp_group *group;
 579         struct prefix_sg sg;
 580         int result;
 581         int input_iface_vif_index = 0;
 582
 583         memset(&sg, 0, sizeof(struct prefix_sg));
 584         sg.src = source->source_addr;
 585         sg.grp = source->source_group->group_addr;
 586
 587         if (PIM_DEBUG_IGMP_TRACE) {
 588                 zlog_debug(
 589                         "%s: (S,G)=%s igmp_sock=%d oif=%s fwd=%d", __func__,
 590                         pim_str_sg_dump(&sg),
 591                         source->source_group->group_igmp_sock->fd,
 592                         source->source_group->group_igmp_sock->interface->name,
 593                         IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
 594         }
 595
 596         /* Prevent IGMP interface from installing multicast route multiple
 597            times */
 598         if (IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
 599                 return;
 600         }
 601
 602         group = source->source_group;
 603         pim_oif = group->group_igmp_sock->interface->info;
 604         if (!pim_oif) {
 605                 if (PIM_DEBUG_IGMP_TRACE) {
 606                         zlog_debug("%s: multicast not enabled on oif=%s ?",
 607                                    __func__,
 608                                    source->source_group->group_igmp_sock
 609                                            ->interface->name);
 610                 }
 611                 return;
 612         }
 613
 614         if (!source->source_channel_oil) {
 615                 struct in_addr vif_source;
 616                 struct prefix src, grp;
 617                 struct pim_nexthop nexthop;
 618                 struct pim_upstream *up = NULL;
 619
 620                 if (!pim_rp_set_upstream_addr(pim, &vif_source,
 621                                               source->source_addr, sg.grp)) {
 622                         /*Create a dummy channel oil */
 623                         source->source_channel_oil =
 624                                 pim_channel_oil_add(pim, &sg, __func__);
 625                 }
 626
 627                 else {
 628                         src.family = AF_INET;
 629                         src.prefixlen = IPV4_MAX_BITLEN;
 630                         src.u.prefix4 = vif_source; // RP or Src address
 631                         grp.family = AF_INET;
 632                         grp.prefixlen = IPV4_MAX_BITLEN;
 633                         grp.u.prefix4 = sg.grp;
 634
 635                         up = pim_upstream_find(pim, &sg);
 636                         if (up) {
 637                                 memcpy(&nexthop, &up->rpf.source_nexthop,
 638                                        sizeof(struct pim_nexthop));
 639                                 pim_ecmp_nexthop_lookup(pim, &nexthop, &src,
 640                                                         &grp, 0);
 641                                 if (nexthop.interface)
 642                                         input_iface_vif_index =
 643                                                 pim_if_find_vifindex_by_ifindex(
 644                                                         pim,
 645                                                         nexthop.interface->ifindex);
 646                         } else
 647                                 input_iface_vif_index =
 648                                         pim_ecmp_fib_lookup_if_vif_index(
 649                                                 pim, &src, &grp);
 650
 651                         if (PIM_DEBUG_ZEBRA) {
 652                                 char buf2[INET_ADDRSTRLEN];
 653
 654                                 pim_inet4_dump("<source?>", vif_source, buf2,
 655                                                sizeof(buf2));
 656                                 zlog_debug(
 657                                         "%s: NHT %s vif_source %s vif_index:%d ",
 658                                         __func__, pim_str_sg_dump(&sg), buf2,
 659                                         input_iface_vif_index);
 660                         }
 661
 662                         if (input_iface_vif_index < 1) {
 663                                 if (PIM_DEBUG_IGMP_TRACE) {
 664                                         char source_str[INET_ADDRSTRLEN];
 665                                         pim_inet4_dump("<source?>",
 666                                                 source->source_addr,
 667                                                 source_str, sizeof(source_str));
 668                                         zlog_debug(
 669                                                 "%s %s: could not find input interface for source %s",
 670                                                 __FILE__, __func__, source_str);
 671                                 }
 672                                 source->source_channel_oil =
 673                                         pim_channel_oil_add(pim, &sg, __func__);
 674                         }
 675
 676                         else {
 677                                 /*
 678                                  * Protect IGMP against adding looped MFC
 679                                  * entries created by both source and receiver
 680                                  * attached to the same interface. See TODO
 681                                  * T22. Block only when the intf is non DR
 682                                  * DR must create upstream.
 683                                  */
 684                                 if ((input_iface_vif_index ==
 685                                     pim_oif->mroute_vif_index) &&
 686                                     !(PIM_I_am_DR(pim_oif))) {
 687                                         /* ignore request for looped MFC entry
 688                                          */
 689                                         if (PIM_DEBUG_IGMP_TRACE) {
 690                                                 zlog_debug(
 691                                                         "%s: ignoring request for looped MFC entry (S,G)=%s: igmp_sock=%d oif=%s vif_index=%d",
 692                                                         __func__,
 693                                                         pim_str_sg_dump(&sg),
 694                                                         source->source_group
 695                                                                 ->group_igmp_sock
 696                                                                 ->fd,
 697                                                         source->source_group
 698                                                                 ->group_igmp_sock
 699                                                                 ->interface->name,
 700                                                         input_iface_vif_index);
 701                                         }
 702                                         return;
 703                                 }
 704
 705                                 source->source_channel_oil =
 706                                         pim_channel_oil_add(pim, &sg, __func__);
 707                                 if (!source->source_channel_oil) {
 708                                         if (PIM_DEBUG_IGMP_TRACE) {
 709                                                 zlog_debug(
 710                                                         "%s %s: could not create OIL for channel (S,G)=%s",
 711                                                         __FILE__, __func__,
 712                                                         pim_str_sg_dump(&sg));
 713                                         }
 714                                         return;
 715                                 }
 716                         }
 717                 }
 718         }
 719
 720         if (PIM_I_am_DR(pim_oif) || PIM_I_am_DualActive(pim_oif)) {
 721                 result = pim_channel_add_oif(source->source_channel_oil,
 722                                              group->group_igmp_sock->interface,
 723                                              PIM_OIF_FLAG_PROTO_IGMP, __func__);
 724                 if (result) {
 725                         if (PIM_DEBUG_MROUTE) {
 726                                 zlog_warn("%s: add_oif() failed with return=%d",
 727                                           __func__, result);
 728                         }
 729                         return;
 730                 }
 731         } else {
 732                 if (PIM_DEBUG_IGMP_TRACE)
 733                         zlog_debug(
 734                                 "%s: %s was received on %s interface but we are not DR for that interface",
 735                                 __func__, pim_str_sg_dump(&sg),
 736                                 group->group_igmp_sock->interface->name);
 737
 738                 return;
 739         }
 740         /*
 741           Feed IGMPv3-gathered local membership information into PIM
 742           per-interface (S,G) state.
 743          */
 744         if (!pim_ifchannel_local_membership_add(
 745                                                 group->group_igmp_sock->interface, &sg,
 746                                                 false /*is_vxlan*/)) {
 747                 if (PIM_DEBUG_MROUTE)
 748                         zlog_warn("%s: Failure to add local membership for %s",
 749                                   __func__, pim_str_sg_dump(&sg));
 750
 751                 pim_channel_del_oif(source->source_channel_oil,
 752                                     group->group_igmp_sock->interface,
 753                                     PIM_OIF_FLAG_PROTO_IGMP, __func__);
 754                 return;
 755         }
 756
 757         IGMP_SOURCE_DO_FORWARDING(source->source_flags);
 758 }
 759
 760 /*
 761   igmp_source_forward_stop: stop fowarding, but keep the source
 762   igmp_source_delete:       stop fowarding, and delete the source
 763  */
 764 void igmp_source_forward_stop(struct igmp_source *source)
 765 {
 766         struct igmp_group *group;
 767         struct prefix_sg sg;
 768         int result;
 769
 770         memset(&sg, 0, sizeof(struct prefix_sg));
 771         sg.src = source->source_addr;
 772         sg.grp = source->source_group->group_addr;
 773
 774         if (PIM_DEBUG_IGMP_TRACE) {
 775                 zlog_debug(
 776                         "%s: (S,G)=%s igmp_sock=%d oif=%s fwd=%d", __func__,
 777                         pim_str_sg_dump(&sg),
 778                         source->source_group->group_igmp_sock->fd,
 779                         source->source_group->group_igmp_sock->interface->name,
 780                         IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
 781         }
 782
 783         /* Prevent IGMP interface from removing multicast route multiple
 784            times */
 785         if (!IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
 786                 return;
 787         }
 788
 789         group = source->source_group;
 790
 791         /*
 792          It appears that in certain circumstances that
 793          igmp_source_forward_stop is called when IGMP forwarding
 794          was not enabled in oif_flags for this outgoing interface.
 795          Possibly because of multiple calls. When that happens, we
 796          enter the below if statement and this function returns early
 797          which in turn triggers the calling function to assert.
 798          Making the call to pim_channel_del_oif and ignoring the return code
 799          fixes the issue without ill effect, similar to
 800          pim_forward_stop below.
 801         */
 802         result = pim_channel_del_oif(source->source_channel_oil,
 803                                      group->group_igmp_sock->interface,
 804                                          PIM_OIF_FLAG_PROTO_IGMP,
 805                                          __func__);
 806         if (result) {
 807                 if (PIM_DEBUG_IGMP_TRACE)
 808                         zlog_debug(
 809                                 "%s: pim_channel_del_oif() failed with return=%d",
 810                                 __func__, result);
 811                 return;
 812         }
 813
 814         /*
 815           Feed IGMPv3-gathered local membership information into PIM
 816           per-interface (S,G) state.
 817          */
 818         pim_ifchannel_local_membership_del(group->group_igmp_sock->interface,
 819                                            &sg);
 820
 821         IGMP_SOURCE_DONT_FORWARDING(source->source_flags);
 822 }
 823
 824 void pim_forward_start(struct pim_ifchannel *ch)
 825 {
 826         struct pim_upstream *up = ch->upstream;
 827         uint32_t mask = 0;
 828
 829         if (PIM_DEBUG_PIM_TRACE) {
 830                 char source_str[INET_ADDRSTRLEN];
 831                 char group_str[INET_ADDRSTRLEN];
 832                 char upstream_str[INET_ADDRSTRLEN];
 833
 834                 pim_inet4_dump("<source?>", ch->sg.src, source_str,
 835                                sizeof(source_str));
 836                 pim_inet4_dump("<group?>", ch->sg.grp, group_str,
 837                                sizeof(group_str));
 838                 pim_inet4_dump("<upstream?>", up->upstream_addr, upstream_str,
 839                                sizeof(upstream_str));
 840                 zlog_debug("%s: (S,G)=(%s,%s) oif=%s (%pI4)", __func__,
 841                            source_str, group_str, ch->interface->name,
 842                            &up->upstream_addr);
 843         }
 844
 845         if (PIM_IF_FLAG_TEST_PROTO_IGMP(ch->flags))
 846                 mask = PIM_OIF_FLAG_PROTO_IGMP;
 847
 848         if (PIM_IF_FLAG_TEST_PROTO_PIM(ch->flags))
 849                 mask |= PIM_OIF_FLAG_PROTO_PIM;
 850
 851         pim_channel_add_oif(up->channel_oil, ch->interface,
 852                         mask, __func__);
 853 }
 854
 855 void pim_forward_stop(struct pim_ifchannel *ch, bool install_it)
 856 {
 857         struct pim_upstream *up = ch->upstream;
 858
 859         if (PIM_DEBUG_PIM_TRACE) {
 860                 zlog_debug("%s: (S,G)=%s oif=%s install_it: %d installed: %d",
 861                            __func__, ch->sg_str, ch->interface->name,
 862                            install_it, up->channel_oil->installed);
 863         }
 864
 865         /*
 866          * If a channel is being removed, check to see if we still need
 867          * to inherit the interface.  If so make sure it is added in
 868          */
 869         if (pim_upstream_evaluate_join_desired_interface(up, ch, ch->parent))
 870                 pim_channel_add_oif(up->channel_oil, ch->interface,
 871                                     PIM_OIF_FLAG_PROTO_PIM, __func__);
 872         else
 873                 pim_channel_del_oif(up->channel_oil, ch->interface,
 874                                     PIM_OIF_FLAG_PROTO_PIM, __func__);
 875
 876         if (install_it && !up->channel_oil->installed)
 877                 pim_upstream_mroute_add(up->channel_oil, __func__);
 878 }
 879
 880 void pim_zebra_zclient_update(struct vty *vty)
 881 {
 882         vty_out(vty, "Zclient update socket: ");
 883
 884         if (zclient) {
 885                 vty_out(vty, "%d failures=%d\n", zclient->sock, zclient->fail);
 886         } else {
 887                 vty_out(vty, "<null zclient>\n");
 888         }
 889 }
 890
 891 struct zclient *pim_zebra_zclient_get(void)
 892 {
 893         if (zclient)
 894                 return zclient;
 895         else
 896                 return NULL;
 897 }
 898
 899 void pim_zebra_interface_set_master(struct interface *vrf,
 900                                     struct interface *ifp)
 901 {
 902         zclient_interface_set_master(zclient, vrf, ifp);
 903 }