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
  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 "zebra/rib.h"
  26
  27 #include "if.h"
  28 #include "log.h"
  29 #include "prefix.h"
  30 #include "zclient.h"
  31 #include "stream.h"
  32 #include "network.h"
  33
  34 #include "pimd.h"
  35 #include "pim_pim.h"
  36 #include "pim_zebra.h"
  37 #include "pim_iface.h"
  38 #include "pim_str.h"
  39 #include "pim_oil.h"
  40 #include "pim_rpf.h"
  41 #include "pim_time.h"
  42 #include "pim_join.h"
  43 #include "pim_zlookup.h"
  44 #include "pim_ifchannel.h"
  45
  46 #undef PIM_DEBUG_IFADDR_DUMP
  47 #define PIM_DEBUG_IFADDR_DUMP
  48
  49 static int fib_lookup_if_vif_index(struct in_addr addr);
  50 static int del_oif(struct channel_oil *channel_oil,
  51                    struct interface *oif,
  52                    uint32_t proto_mask);
  53
  54 static void zclient_broken(struct zclient *zclient)
  55 {
  56   struct listnode  *ifnode;
  57   struct interface *ifp;
  58
  59   zlog_warn("%s %s: broken zclient connection",
  60             __FILE__, __PRETTY_FUNCTION__);
  61
  62   for (ALL_LIST_ELEMENTS_RO(iflist, ifnode, ifp)) {
  63     pim_if_addr_del_all(ifp);
  64   }
  65
  66   /* upon return, zclient will discard connected addresses */
  67 }
  68
  69 /* Router-id update message from zebra. */
  70 static int pim_router_id_update_zebra(int command, struct zclient *zclient,
  71                                       zebra_size_t length)
  72 {
  73   struct prefix router_id;
  74
  75   zebra_router_id_update_read(zclient->ibuf, &router_id);
  76
  77   return 0;
  78 }
  79
  80 static int pim_zebra_if_add(int command, struct zclient *zclient,
  81                             zebra_size_t length)
  82 {
  83   struct interface *ifp;
  84
  85   /*
  86     zebra api adds/dels interfaces using the same call
  87     interface_add_read below, see comments in lib/zclient.c
  88   */
  89   ifp = zebra_interface_add_read(zclient->ibuf);
  90   if (!ifp)
  91     return 0;
  92
  93   if (PIM_DEBUG_ZEBRA) {
  94     zlog_debug("%s: %s index %d flags %ld metric %d mtu %d operative %d",
  95                __PRETTY_FUNCTION__,
  96                ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric,
  97                ifp->mtu, if_is_operative(ifp));
  98   }
  99
 100   if (if_is_operative(ifp))
 101     pim_if_addr_add_all(ifp);
 102
 103   return 0;
 104 }
 105
 106 static int pim_zebra_if_del(int command, struct zclient *zclient,
 107                             zebra_size_t length)
 108 {
 109   struct interface *ifp;
 110
 111   /*
 112     zebra api adds/dels interfaces using the same call
 113     interface_add_read below, see comments in lib/zclient.c
 114
 115     comments in lib/zclient.c seem to indicate that calling
 116     zebra_interface_add_read is the correct call, but that
 117     results in an attemted out of bounds read which causes
 118     pimd to assert. Other clients use zebra_interface_state_read
 119     and it appears to work just fine.
 120   */
 121   ifp = zebra_interface_state_read(zclient->ibuf);
 122   if (!ifp)
 123     return 0;
 124
 125   if (PIM_DEBUG_ZEBRA) {
 126     zlog_debug("%s: %s index %d flags %ld metric %d mtu %d operative %d",
 127                __PRETTY_FUNCTION__,
 128                ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric,
 129                ifp->mtu, if_is_operative(ifp));
 130   }
 131
 132   if (!if_is_operative(ifp))
 133     pim_if_addr_del_all(ifp);
 134
 135   return 0;
 136 }
 137
 138 static int pim_zebra_if_state_up(int command, struct zclient *zclient,
 139                                  zebra_size_t length)
 140 {
 141   struct interface *ifp;
 142
 143   /*
 144     zebra api notifies interface up/down events by using the same call
 145     zebra_interface_state_read below, see comments in lib/zclient.c
 146   */
 147   ifp = zebra_interface_state_read(zclient->ibuf);
 148   if (!ifp)
 149     return 0;
 150
 151   zlog_info("INTERFACE UP: %s ifindex=%d", ifp->name, ifp->ifindex);
 152
 153   if (PIM_DEBUG_ZEBRA) {
 154     zlog_debug("%s: %s index %d flags %ld metric %d mtu %d operative %d",
 155                __PRETTY_FUNCTION__,
 156                ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric,
 157                ifp->mtu, if_is_operative(ifp));
 158   }
 159
 160   if (if_is_operative(ifp)) {
 161     /*
 162       pim_if_addr_add_all() suffices for bringing up both IGMP and PIM
 163     */
 164     pim_if_addr_add_all(ifp);
 165   }
 166
 167   return 0;
 168 }
 169
 170 static int pim_zebra_if_state_down(int command, struct zclient *zclient,
 171                                    zebra_size_t length)
 172 {
 173   struct interface *ifp;
 174
 175   /*
 176     zebra api notifies interface up/down events by using the same call
 177     zebra_interface_state_read below, see comments in lib/zclient.c
 178   */
 179   ifp = zebra_interface_state_read(zclient->ibuf);
 180   if (!ifp)
 181     return 0;
 182
 183   zlog_info("INTERFACE DOWN: %s ifindex=%d", ifp->name, ifp->ifindex);
 184
 185   if (PIM_DEBUG_ZEBRA) {
 186     zlog_debug("%s: %s index %d flags %ld metric %d mtu %d operative %d",
 187                __PRETTY_FUNCTION__,
 188                ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric,
 189                ifp->mtu, if_is_operative(ifp));
 190   }
 191
 192   if (!if_is_operative(ifp)) {
 193     /*
 194       pim_if_addr_del_all() suffices for shutting down IGMP,
 195       but not for shutting down PIM
 196     */
 197     pim_if_addr_del_all(ifp);
 198
 199     /*
 200       pim_sock_delete() closes the socket, stops read and timer threads,
 201       and kills all neighbors.
 202     */
 203     if (ifp->info) {
 204       pim_sock_delete(ifp, "link down");
 205     }
 206   }
 207
 208   return 0;
 209 }
 210
 211 #ifdef PIM_DEBUG_IFADDR_DUMP
 212 static void dump_if_address(struct interface *ifp)
 213 {
 214   struct connected *ifc;
 215   struct listnode *node;
 216
 217   zlog_debug("%s %s: interface %s addresses:",
 218              __FILE__, __PRETTY_FUNCTION__,
 219              ifp->name);
 220
 221   for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 222     struct prefix *p = ifc->address;
 223
 224     if (p->family != AF_INET)
 225       continue;
 226
 227     zlog_debug("%s %s: interface %s address %s %s",
 228                __FILE__, __PRETTY_FUNCTION__,
 229                ifp->name,
 230                inet_ntoa(p->u.prefix4),
 231                CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY) ?
 232                "secondary" : "primary");
 233   }
 234 }
 235 #endif
 236
 237 static int pim_zebra_if_address_add(int command, struct zclient *zclient,
 238                                     zebra_size_t length)
 239 {
 240   struct connected *c;
 241   struct prefix *p;
 242
 243   zassert(command == ZEBRA_INTERFACE_ADDRESS_ADD);
 244
 245   /*
 246     zebra api notifies address adds/dels events by using the same call
 247     interface_add_read below, see comments in lib/zclient.c
 248
 249     zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD, ...)
 250     will add address to interface list by calling
 251     connected_add_by_prefix()
 252   */
 253   c = zebra_interface_address_read(command, zclient->ibuf);
 254   if (!c)
 255     return 0;
 256
 257   p = c->address;
 258   if (p->family != AF_INET)
 259     return 0;
 260
 261   if (PIM_DEBUG_ZEBRA) {
 262     char buf[BUFSIZ];
 263     prefix2str(p, buf, BUFSIZ);
 264     zlog_debug("%s: %s connected IP address %s flags %u %s",
 265                __PRETTY_FUNCTION__,
 266                c->ifp->name, buf, c->flags,
 267                CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY) ? "secondary" : "primary");
 268
 269 #ifdef PIM_DEBUG_IFADDR_DUMP
 270     dump_if_address(c->ifp);
 271 #endif
 272   }
 273
 274   if (!CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)) {
 275     /* trying to add primary address */
 276
 277     struct in_addr primary_addr = pim_find_primary_addr(c->ifp);
 278     if (primary_addr.s_addr != p->u.prefix4.s_addr) {
 279       /* but we had a primary address already */
 280
 281       char buf[BUFSIZ];
 282       char old[100];
 283
 284       prefix2str(p, buf, BUFSIZ);
 285       pim_inet4_dump("<old?>", primary_addr, old, sizeof(old));
 286
 287       zlog_warn("%s: %s primary addr old=%s: forcing secondary flag on new=%s",
 288                 __PRETTY_FUNCTION__,
 289                 c->ifp->name, old, buf);
 290       SET_FLAG(c->flags, ZEBRA_IFA_SECONDARY);
 291     }
 292   }
 293
 294   pim_if_addr_add(c);
 295
 296   return 0;
 297 }
 298
 299 static int pim_zebra_if_address_del(int command, struct zclient *client,
 300                                     zebra_size_t length)
 301 {
 302   struct connected *c;
 303   struct prefix *p;
 304
 305   zassert(command == ZEBRA_INTERFACE_ADDRESS_DELETE);
 306
 307   /*
 308     zebra api notifies address adds/dels events by using the same call
 309     interface_add_read below, see comments in lib/zclient.c
 310
 311     zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE, ...)
 312     will remove address from interface list by calling
 313     connected_delete_by_prefix()
 314   */
 315   c = zebra_interface_address_read(command, client->ibuf);
 316   if (!c)
 317     return 0;
 318
 319   p = c->address;
 320   if (p->family != AF_INET)
 321     return 0;
 322
 323   if (PIM_DEBUG_ZEBRA) {
 324     char buf[BUFSIZ];
 325     prefix2str(p, buf, BUFSIZ);
 326     zlog_debug("%s: %s disconnected IP address %s flags %u %s",
 327                __PRETTY_FUNCTION__,
 328                c->ifp->name, buf, c->flags,
 329                CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY) ? "secondary" : "primary");
 330
 331 #ifdef PIM_DEBUG_IFADDR_DUMP
 332     dump_if_address(c->ifp);
 333 #endif
 334   }
 335
 336   pim_if_addr_del(c, 0);
 337
 338   return 0;
 339 }
 340
 341 static void scan_upstream_rpf_cache()
 342 {
 343   struct listnode     *up_node;
 344   struct listnode     *up_nextnode;
 345   struct pim_upstream *up;
 346
 347   for (ALL_LIST_ELEMENTS(qpim_upstream_list, up_node, up_nextnode, up)) {
 348     struct in_addr      old_rpf_addr;
 349     enum pim_rpf_result rpf_result;
 350
 351     rpf_result = pim_rpf_update(up, &old_rpf_addr);
 352     if (rpf_result == PIM_RPF_FAILURE)
 353       continue;
 354
 355     if (rpf_result == PIM_RPF_CHANGED) {
 356
 357       if (up->join_state == PIM_UPSTREAM_JOINED) {
 358
 359         /*
 360           RFC 4601: 4.5.7.  Sending (S,G) Join/Prune Messages
 361
 362           Transitions from Joined State
 363
 364           RPF'(S,G) changes not due to an Assert
 365
 366           The upstream (S,G) state machine remains in Joined
 367           state. Send Join(S,G) to the new upstream neighbor, which is
 368           the new value of RPF'(S,G).  Send Prune(S,G) to the old
 369           upstream neighbor, which is the old value of RPF'(S,G).  Set
 370           the Join Timer (JT) to expire after t_periodic seconds.
 371         */
 372
 373
 374         /* send Prune(S,G) to the old upstream neighbor */
 375         pim_joinprune_send(up->rpf.source_nexthop.interface,
 376                            old_rpf_addr,
 377                            up->source_addr,
 378                            up->group_addr,
 379                            0 /* prune */);
 380
 381         /* send Join(S,G) to the current upstream neighbor */
 382         pim_joinprune_send(up->rpf.source_nexthop.interface,
 383                            up->rpf.rpf_addr,
 384                            up->source_addr,
 385                            up->group_addr,
 386                            1 /* join */);
 387
 388         pim_upstream_join_timer_restart(up);
 389       } /* up->join_state == PIM_UPSTREAM_JOINED */
 390
 391       /* FIXME can join_desired actually be changed by pim_rpf_update()
 392          returning PIM_RPF_CHANGED ? */
 393       pim_upstream_update_join_desired(up);
 394
 395     } /* PIM_RPF_CHANGED */
 396
 397   } /* for (qpim_upstream_list) */
 398
 399 }
 400
 401 void pim_scan_oil()
 402 {
 403   struct listnode    *node;
 404   struct listnode    *nextnode;
 405   struct channel_oil *c_oil;
 406
 407   qpim_scan_oil_last = pim_time_monotonic_sec();
 408   ++qpim_scan_oil_events;
 409
 410   for (ALL_LIST_ELEMENTS(qpim_channel_oil_list, node, nextnode, c_oil)) {
 411     int old_vif_index;
 412     int input_iface_vif_index = fib_lookup_if_vif_index(c_oil->oil.mfcc_origin);
 413     if (input_iface_vif_index < 1) {
 414       char source_str[100];
 415       char group_str[100];
 416       pim_inet4_dump("<source?>", c_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 417       pim_inet4_dump("<group?>", c_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 418       zlog_warn("%s %s: could not find input interface for (S,G)=(%s,%s)",
 419                 __FILE__, __PRETTY_FUNCTION__,
 420                 source_str, group_str);
 421       continue;
 422     }
 423
 424     if (input_iface_vif_index == c_oil->oil.mfcc_parent) {
 425       /* RPF unchanged */
 426       continue;
 427     }
 428
 429     if (PIM_DEBUG_ZEBRA) {
 430       struct interface *old_iif = pim_if_find_by_vif_index(c_oil->oil.mfcc_parent);
 431       struct interface *new_iif = pim_if_find_by_vif_index(input_iface_vif_index);
 432       char source_str[100];
 433       char group_str[100];
 434       pim_inet4_dump("<source?>", c_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 435       pim_inet4_dump("<group?>", c_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 436       zlog_debug("%s %s: (S,G)=(%s,%s) input interface changed from %s vif_index=%d to %s vif_index=%d",
 437                  __FILE__, __PRETTY_FUNCTION__,
 438                  source_str, group_str,
 439                  old_iif ? old_iif->name : "<old_iif?>", c_oil->oil.mfcc_parent,
 440                  new_iif ? new_iif->name : "<new_iif?>", input_iface_vif_index);
 441     }
 442
 443     /* new iif loops to existing oif ? */
 444     if (c_oil->oil.mfcc_ttls[input_iface_vif_index]) {
 445       struct interface *new_iif = pim_if_find_by_vif_index(input_iface_vif_index);
 446
 447       if (PIM_DEBUG_ZEBRA) {
 448         char source_str[100];
 449         char group_str[100];
 450         pim_inet4_dump("<source?>", c_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 451         pim_inet4_dump("<group?>", c_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 452         zlog_debug("%s %s: (S,G)=(%s,%s) new iif loops to existing oif: %s vif_index=%d",
 453                    __FILE__, __PRETTY_FUNCTION__,
 454                    source_str, group_str,
 455                    new_iif ? new_iif->name : "<new_iif?>", input_iface_vif_index);
 456       }
 457
 458       del_oif(c_oil, new_iif, PIM_OIF_FLAG_PROTO_ANY);
 459     }
 460
 461     /* update iif vif_index */
 462     old_vif_index = c_oil->oil.mfcc_parent;
 463     c_oil->oil.mfcc_parent = input_iface_vif_index;
 464
 465     /* update kernel multicast forwarding cache (MFC) */
 466     if (pim_mroute_add(&c_oil->oil)) {
 467       /* just log warning */
 468       struct interface *old_iif = pim_if_find_by_vif_index(old_vif_index);
 469       struct interface *new_iif = pim_if_find_by_vif_index(input_iface_vif_index);
 470       char source_str[100];
 471       char group_str[100];
 472       pim_inet4_dump("<source?>", c_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 473       pim_inet4_dump("<group?>", c_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 474       zlog_warn("%s %s: (S,G)=(%s,%s) failure updating input interface from %s vif_index=%d to %s vif_index=%d",
 475                  __FILE__, __PRETTY_FUNCTION__,
 476                  source_str, group_str,
 477                  old_iif ? old_iif->name : "<old_iif?>", c_oil->oil.mfcc_parent,
 478                  new_iif ? new_iif->name : "<new_iif?>", input_iface_vif_index);
 479       continue;
 480     }
 481
 482   } /* for (qpim_channel_oil_list) */
 483 }
 484
 485 static int on_rpf_cache_refresh(struct thread *t)
 486 {
 487   zassert(t);
 488   zassert(qpim_rpf_cache_refresher);
 489
 490   qpim_rpf_cache_refresher = 0;
 491
 492   /* update PIM protocol state */
 493   scan_upstream_rpf_cache();
 494
 495   /* update kernel multicast forwarding cache (MFC) */
 496   pim_scan_oil();
 497
 498   qpim_rpf_cache_refresh_last = pim_time_monotonic_sec();
 499   ++qpim_rpf_cache_refresh_events;
 500
 501   return 0;
 502 }
 503
 504 static void sched_rpf_cache_refresh()
 505 {
 506   ++qpim_rpf_cache_refresh_requests;
 507
 508   if (qpim_rpf_cache_refresher) {
 509     /* Refresh timer is already running */
 510     return;
 511   }
 512
 513   /* Start refresh timer */
 514
 515   if (PIM_DEBUG_ZEBRA) {
 516     zlog_debug("%s: triggering %ld msec timer",
 517                __PRETTY_FUNCTION__,
 518                qpim_rpf_cache_refresh_delay_msec);
 519   }
 520
 521   THREAD_TIMER_MSEC_ON(master, qpim_rpf_cache_refresher,
 522                        on_rpf_cache_refresh,
 523                        0, qpim_rpf_cache_refresh_delay_msec);
 524 }
 525
 526 static int redist_read_ipv4_route(int command, struct zclient *zclient,
 527                                   zebra_size_t length)
 528 {
 529   struct stream *s;
 530   struct zapi_ipv4 api;
 531   unsigned long ifindex;
 532   struct in_addr nexthop;
 533   struct prefix_ipv4 p;
 534   int min_len = 4;
 535
 536   if (length < min_len) {
 537     zlog_warn("%s %s: short buffer: length=%d min=%d",
 538               __FILE__, __PRETTY_FUNCTION__,
 539               length, min_len);
 540     return -1;
 541   }
 542
 543   s = zclient->ibuf;
 544   ifindex = 0;
 545   nexthop.s_addr = 0;
 546
 547   /* Type, flags, message. */
 548   api.type = stream_getc(s);
 549   api.flags = stream_getc(s);
 550   api.message = stream_getc(s);
 551
 552   /* IPv4 prefix length. */
 553   memset(&p, 0, sizeof(struct prefix_ipv4));
 554   p.family = AF_INET;
 555   p.prefixlen = stream_getc(s);
 556
 557   min_len +=
 558     PSIZE(p.prefixlen) +
 559     CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP) ? 5 : 0 +
 560     CHECK_FLAG(api.message, ZAPI_MESSAGE_IFINDEX) ? 5 : 0 +
 561     CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ? 1 : 0 +
 562     CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ? 4 : 0;
 563
 564   if (PIM_DEBUG_ZEBRA) {
 565     zlog_debug("%s %s: length=%d min_len=%d flags=%s%s%s%s",
 566                __FILE__, __PRETTY_FUNCTION__,
 567                length, min_len,
 568                CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP) ? "nh" : "",
 569                CHECK_FLAG(api.message, ZAPI_MESSAGE_IFINDEX) ? " ifi" : "",
 570                CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ? " dist" : "",
 571                CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ? " metr" : "");
 572   }
 573
 574   if (length < min_len) {
 575     zlog_warn("%s %s: short buffer: length=%d min_len=%d flags=%s%s%s%s",
 576               __FILE__, __PRETTY_FUNCTION__,
 577               length, min_len,
 578               CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP) ? "nh" : "",
 579               CHECK_FLAG(api.message, ZAPI_MESSAGE_IFINDEX) ? " ifi" : "",
 580               CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ? " dist" : "",
 581               CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ? " metr" : "");
 582     return -1;
 583   }
 584
 585   /* IPv4 prefix. */
 586   stream_get(&p.prefix, s, PSIZE(p.prefixlen));
 587
 588   /* Nexthop, ifindex, distance, metric. */
 589   if (CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP)) {
 590     api.nexthop_num = stream_getc(s);
 591     nexthop.s_addr = stream_get_ipv4(s);
 592   }
 593   if (CHECK_FLAG(api.message, ZAPI_MESSAGE_IFINDEX)) {
 594     api.ifindex_num = stream_getc(s);
 595     ifindex = stream_getl(s);
 596   }
 597
 598   api.distance = CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ?
 599     stream_getc(s) :
 600     0;
 601
 602   api.metric = CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ?
 603     stream_getl(s) :
 604     0;
 605
 606   switch (command) {
 607   case ZEBRA_IPV4_ROUTE_ADD:
 608     if (PIM_DEBUG_ZEBRA) {
 609       char buf[2][INET_ADDRSTRLEN];
 610       zlog_debug("%s: add %s %s/%d "
 611                  "nexthop %s ifindex %ld metric%s %u distance%s %u",
 612                  __PRETTY_FUNCTION__,
 613                  zebra_route_string(api.type),
 614                  inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
 615                  p.prefixlen,
 616                  inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
 617                  ifindex,
 618                  CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ? "-recv" : "-miss",
 619                  api.metric,
 620                  CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ? "-recv" : "-miss",
 621                  api.distance);
 622     }
 623     break;
 624   case ZEBRA_IPV4_ROUTE_DELETE:
 625     if (PIM_DEBUG_ZEBRA) {
 626       char buf[2][INET_ADDRSTRLEN];
 627       zlog_debug("%s: delete %s %s/%d "
 628                  "nexthop %s ifindex %ld metric%s %u distance%s %u",
 629                  __PRETTY_FUNCTION__,
 630                  zebra_route_string(api.type),
 631                  inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
 632                  p.prefixlen,
 633                  inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
 634                  ifindex,
 635                  CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC) ? "-recv" : "-miss",
 636                  api.metric,
 637                  CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE) ? "-recv" : "-miss",
 638                  api.distance);
 639     }
 640     break;
 641   default:
 642     zlog_warn("%s: unknown command=%d", __PRETTY_FUNCTION__, command);
 643     return -1;
 644   }
 645
 646   sched_rpf_cache_refresh();
 647
 648   return 0;
 649 }
 650
 651 void pim_zebra_init(char *zebra_sock_path)
 652 {
 653   int i;
 654
 655   if (zebra_sock_path)
 656     zclient_serv_path_set(zebra_sock_path);
 657
 658 #ifdef HAVE_TCP_ZEBRA
 659   zlog_notice("zclient update contacting ZEBRA daemon at socket TCP %s,%d", "127.0.0.1", ZEBRA_PORT);
 660 #else
 661   zlog_notice("zclient update contacting ZEBRA daemon at socket UNIX %s", zclient_serv_path_get());
 662 #endif
 663
 664   /* Socket for receiving updates from Zebra daemon */
 665   qpim_zclient_update = zclient_new();
 666
 667   qpim_zclient_update->router_id_update         = pim_router_id_update_zebra;
 668   qpim_zclient_update->interface_add            = pim_zebra_if_add;
 669   qpim_zclient_update->interface_delete         = pim_zebra_if_del;
 670   qpim_zclient_update->interface_up             = pim_zebra_if_state_up;
 671   qpim_zclient_update->interface_down           = pim_zebra_if_state_down;
 672   qpim_zclient_update->interface_address_add    = pim_zebra_if_address_add;
 673   qpim_zclient_update->interface_address_delete = pim_zebra_if_address_del;
 674   qpim_zclient_update->ipv4_route_add           = redist_read_ipv4_route;
 675   qpim_zclient_update->ipv4_route_delete        = redist_read_ipv4_route;
 676
 677   zclient_init(qpim_zclient_update, ZEBRA_ROUTE_PIM);
 678   if (PIM_DEBUG_PIM_TRACE) {
 679     zlog_info("zclient_init cleared redistribution request");
 680   }
 681
 682   zassert(qpim_zclient_update->redist_default == ZEBRA_ROUTE_PIM);
 683
 684   /* Request all redistribution */
 685   for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 686     if (i == qpim_zclient_update->redist_default)
 687       continue;
 688     qpim_zclient_update->redist[i] = 1;
 689     if (PIM_DEBUG_PIM_TRACE) {
 690       zlog_debug("%s: requesting redistribution for %s (%i)",
 691                  __PRETTY_FUNCTION__, zebra_route_string(i), i);
 692     }
 693   }
 694
 695   /* Request default information */
 696   zclient_redistribute_default (ZEBRA_REDISTRIBUTE_DEFAULT_ADD,
 697                                 qpim_zclient_update, VRF_DEFAULT);
 698
 699   if (PIM_DEBUG_PIM_TRACE) {
 700     zlog_info("%s: requesting default information redistribution",
 701               __PRETTY_FUNCTION__);
 702
 703     zlog_notice("%s: zclient update socket initialized",
 704                 __PRETTY_FUNCTION__);
 705   }
 706
 707   zassert(!qpim_zclient_lookup);
 708   qpim_zclient_lookup = zclient_lookup_new();
 709   zassert(qpim_zclient_lookup);
 710 }
 711
 712 void igmp_anysource_forward_start(struct igmp_group *group)
 713 {
 714   /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
 715   zassert(group->group_filtermode_isexcl);
 716   zassert(listcount(group->group_source_list) < 1);
 717
 718   if (PIM_DEBUG_IGMP_TRACE) {
 719     zlog_debug("%s %s: UNIMPLEMENTED",
 720                __FILE__, __PRETTY_FUNCTION__);
 721   }
 722 }
 723
 724 void igmp_anysource_forward_stop(struct igmp_group *group)
 725 {
 726   /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
 727   zassert((!group->group_filtermode_isexcl) || (listcount(group->group_source_list) > 0));
 728
 729   if (PIM_DEBUG_IGMP_TRACE) {
 730     zlog_debug("%s %s: UNIMPLEMENTED",
 731                __FILE__, __PRETTY_FUNCTION__);
 732   }
 733 }
 734
 735 static int fib_lookup_if_vif_index(struct in_addr addr)
 736 {
 737   struct pim_zlookup_nexthop nexthop_tab[PIM_NEXTHOP_IFINDEX_TAB_SIZE];
 738   int num_ifindex;
 739   int vif_index;
 740   int first_ifindex;
 741
 742   num_ifindex = zclient_lookup_nexthop(qpim_zclient_lookup, nexthop_tab,
 743                                        PIM_NEXTHOP_IFINDEX_TAB_SIZE, addr,
 744                                        PIM_NEXTHOP_LOOKUP_MAX);
 745   if (num_ifindex < 1) {
 746     char addr_str[100];
 747     pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
 748     zlog_warn("%s %s: could not find nexthop ifindex for address %s",
 749               __FILE__, __PRETTY_FUNCTION__,
 750               addr_str);
 751     return -1;
 752   }
 753
 754   first_ifindex = nexthop_tab[0].ifindex;
 755
 756   if (num_ifindex > 1) {
 757     char addr_str[100];
 758     pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
 759     zlog_debug("%s %s: FIXME ignoring multiple nexthop ifindex'es num_ifindex=%d for address %s (using only ifindex=%d)",
 760                __FILE__, __PRETTY_FUNCTION__,
 761                num_ifindex, addr_str, first_ifindex);
 762     /* debug warning only, do not return */
 763   }
 764
 765   if (PIM_DEBUG_ZEBRA) {
 766     char addr_str[100];
 767     pim_inet4_dump("<ifaddr?>", addr, addr_str, sizeof(addr_str));
 768     zlog_debug("%s %s: found nexthop ifindex=%d (interface %s) for address %s",
 769                __FILE__, __PRETTY_FUNCTION__,
 770                first_ifindex, ifindex2ifname(first_ifindex), addr_str);
 771   }
 772
 773   vif_index = pim_if_find_vifindex_by_ifindex(first_ifindex);
 774
 775   if (vif_index < 1) {
 776     char addr_str[100];
 777     pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
 778     zlog_warn("%s %s: low vif_index=%d < 1 nexthop for address %s",
 779               __FILE__, __PRETTY_FUNCTION__,
 780               vif_index, addr_str);
 781     return -2;
 782   }
 783
 784   zassert(qpim_mroute_oif_highest_vif_index < MAXVIFS);
 785
 786   if (vif_index > qpim_mroute_oif_highest_vif_index) {
 787     char addr_str[100];
 788     pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
 789     zlog_warn("%s %s: high vif_index=%d > highest_vif_index=%d nexthop for address %s",
 790               __FILE__, __PRETTY_FUNCTION__,
 791               vif_index, qpim_mroute_oif_highest_vif_index, addr_str);
 792
 793     zlog_warn("%s %s: pim disabled on interface %s vif_index=%d ?",
 794               __FILE__, __PRETTY_FUNCTION__,
 795               ifindex2ifname(vif_index),
 796               vif_index);
 797
 798     return -3;
 799   }
 800
 801   return vif_index;
 802 }
 803
 804 static int add_oif(struct channel_oil *channel_oil,
 805                    struct interface *oif,
 806                    uint32_t proto_mask)
 807 {
 808   struct pim_interface *pim_ifp;
 809   int old_ttl;
 810
 811   zassert(channel_oil);
 812
 813   pim_ifp = oif->info;
 814
 815   if (PIM_DEBUG_MROUTE) {
 816     char group_str[100];
 817     char source_str[100];
 818     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 819     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 820     zlog_debug("%s %s: (S,G)=(%s,%s): proto_mask=%u OIF=%s vif_index=%d",
 821                __FILE__, __PRETTY_FUNCTION__,
 822                source_str, group_str,
 823                proto_mask, oif->name, pim_ifp->mroute_vif_index);
 824   }
 825
 826   if (pim_ifp->mroute_vif_index < 1) {
 827     zlog_warn("%s %s: interface %s vif_index=%d < 1",
 828               __FILE__, __PRETTY_FUNCTION__,
 829               oif->name, pim_ifp->mroute_vif_index);
 830     return -1;
 831   }
 832
 833 #ifdef PIM_ENFORCE_LOOPFREE_MFC
 834   /*
 835     Prevent creating MFC entry with OIF=IIF.
 836
 837     This is a protection against implementation mistakes.
 838
 839     PIM protocol implicitely ensures loopfree multicast topology.
 840
 841     IGMP must be protected against adding looped MFC entries created
 842     by both source and receiver attached to the same interface. See
 843     TODO T22.
 844   */
 845   if (pim_ifp->mroute_vif_index == channel_oil->oil.mfcc_parent) {
 846     char group_str[100];
 847     char source_str[100];
 848     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 849     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 850     zlog_warn("%s %s: refusing protocol mask %u request for IIF=OIF=%s (vif_index=%d) for channel (S,G)=(%s,%s)",
 851               __FILE__, __PRETTY_FUNCTION__,
 852               proto_mask, oif->name, pim_ifp->mroute_vif_index,
 853               source_str, group_str);
 854     return -2;
 855   }
 856 #endif
 857
 858   zassert(qpim_mroute_oif_highest_vif_index < MAXVIFS);
 859   zassert(pim_ifp->mroute_vif_index <= qpim_mroute_oif_highest_vif_index);
 860
 861   /* Prevent single protocol from subscribing same interface to
 862      channel (S,G) multiple times */
 863   if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask) {
 864     char group_str[100];
 865     char source_str[100];
 866     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 867     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 868     zlog_warn("%s %s: existing protocol mask %u requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 869               __FILE__, __PRETTY_FUNCTION__,
 870               proto_mask, oif->name, pim_ifp->mroute_vif_index,
 871               channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index],
 872               source_str, group_str);
 873     return -3;
 874   }
 875
 876   /* Allow other protocol to request subscription of same interface to
 877      channel (S,G) multiple times, by silently ignoring further
 878      requests */
 879   if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & PIM_OIF_FLAG_PROTO_ANY) {
 880
 881     /* Check the OIF really exists before returning, and only log
 882        warning otherwise */
 883     if (channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] < 1) {
 884       char group_str[100];
 885       char source_str[100];
 886       pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 887       pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 888       zlog_warn("%s %s: new protocol mask %u requested nonexistent OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 889                 __FILE__, __PRETTY_FUNCTION__,
 890                 proto_mask, oif->name, pim_ifp->mroute_vif_index,
 891                 channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index],
 892                 source_str, group_str);
 893     }
 894
 895     return 0;
 896   }
 897
 898   old_ttl = channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index];
 899
 900   if (old_ttl > 0) {
 901     char group_str[100];
 902     char source_str[100];
 903     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 904     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 905     zlog_warn("%s %s: interface %s (vif_index=%d) is existing output for channel (S,G)=(%s,%s)",
 906               __FILE__, __PRETTY_FUNCTION__,
 907               oif->name, pim_ifp->mroute_vif_index,
 908               source_str, group_str);
 909     return -4;
 910   }
 911
 912   channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] = PIM_MROUTE_MIN_TTL;
 913
 914   if (pim_mroute_add(&channel_oil->oil)) {
 915     char group_str[100];
 916     char source_str[100];
 917     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 918     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 919     zlog_warn("%s %s: could not add output interface %s (vif_index=%d) for channel (S,G)=(%s,%s)",
 920               __FILE__, __PRETTY_FUNCTION__,
 921               oif->name, pim_ifp->mroute_vif_index,
 922               source_str, group_str);
 923
 924     channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] = old_ttl;
 925     return -5;
 926   }
 927
 928   channel_oil->oif_creation[pim_ifp->mroute_vif_index] = pim_time_monotonic_sec();
 929   ++channel_oil->oil_size;
 930   channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;
 931
 932   if (PIM_DEBUG_MROUTE) {
 933     char group_str[100];
 934     char source_str[100];
 935     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 936     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 937     zlog_debug("%s %s: (S,G)=(%s,%s): proto_mask=%u OIF=%s vif_index=%d: DONE",
 938                __FILE__, __PRETTY_FUNCTION__,
 939                source_str, group_str,
 940                proto_mask, oif->name, pim_ifp->mroute_vif_index);
 941   }
 942
 943   return 0;
 944 }
 945
 946 static int del_oif(struct channel_oil *channel_oil,
 947                    struct interface *oif,
 948                    uint32_t proto_mask)
 949 {
 950   struct pim_interface *pim_ifp;
 951   int old_ttl;
 952
 953   zassert(channel_oil);
 954
 955   pim_ifp = oif->info;
 956
 957   zassert(pim_ifp->mroute_vif_index >= 1);
 958   zassert(qpim_mroute_oif_highest_vif_index < MAXVIFS);
 959   zassert(pim_ifp->mroute_vif_index <= qpim_mroute_oif_highest_vif_index);
 960
 961   if (PIM_DEBUG_MROUTE) {
 962     char group_str[100];
 963     char source_str[100];
 964     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 965     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 966     zlog_debug("%s %s: (S,G)=(%s,%s): proto_mask=%u OIF=%s vif_index=%d",
 967                __FILE__, __PRETTY_FUNCTION__,
 968                source_str, group_str,
 969                proto_mask, oif->name, pim_ifp->mroute_vif_index);
 970   }
 971
 972   /* Prevent single protocol from unsubscribing same interface from
 973      channel (S,G) multiple times */
 974   if (!(channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask)) {
 975     char group_str[100];
 976     char source_str[100];
 977     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
 978     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
 979     zlog_warn("%s %s: nonexistent protocol mask %u removed OIF %s (vif_index=%d, min_ttl=%d) from channel (S,G)=(%s,%s)",
 980               __FILE__, __PRETTY_FUNCTION__,
 981               proto_mask, oif->name, pim_ifp->mroute_vif_index,
 982               channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index],
 983               source_str, group_str);
 984     return -2;
 985   }
 986
 987   /* Mark that protocol is no longer interested in this OIF */
 988   channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~proto_mask;
 989
 990   /* Allow multiple protocols to unsubscribe same interface from
 991      channel (S,G) multiple times, by silently ignoring requests while
 992      there is at least one protocol interested in the channel */
 993   if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & PIM_OIF_FLAG_PROTO_ANY) {
 994
 995     /* Check the OIF keeps existing before returning, and only log
 996        warning otherwise */
 997     if (channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] < 1) {
 998       char group_str[100];
 999       char source_str[100];
1000       pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
1001       pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
1002       zlog_warn("%s %s: protocol mask %u removing nonexistent OIF %s (vif_index=%d, min_ttl=%d) from channel (S,G)=(%s,%s)",
1003                 __FILE__, __PRETTY_FUNCTION__,
1004                 proto_mask, oif->name, pim_ifp->mroute_vif_index,
1005                 channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index],
1006                 source_str, group_str);
1007     }
1008
1009     return 0;
1010   }
1011
1012   old_ttl = channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index];
1013
1014   if (old_ttl < 1) {
1015     char group_str[100];
1016     char source_str[100];
1017     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
1018     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
1019     zlog_warn("%s %s: interface %s (vif_index=%d) is not output for channel (S,G)=(%s,%s)",
1020               __FILE__, __PRETTY_FUNCTION__,
1021               oif->name, pim_ifp->mroute_vif_index,
1022               source_str, group_str);
1023     return -3;
1024   }
1025
1026   channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] = 0;
1027
1028   if (pim_mroute_add(&channel_oil->oil)) {
1029     char group_str[100];
1030     char source_str[100];
1031     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
1032     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
1033     zlog_warn("%s %s: could not remove output interface %s (vif_index=%d) from channel (S,G)=(%s,%s)",
1034               __FILE__, __PRETTY_FUNCTION__,
1035               oif->name, pim_ifp->mroute_vif_index,
1036               source_str, group_str);
1037
1038     channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] = old_ttl;
1039     return -4;
1040   }
1041
1042   --channel_oil->oil_size;
1043
1044   if (channel_oil->oil_size < 1) {
1045     if (pim_mroute_del(&channel_oil->oil)) {
1046       /* just log a warning in case of failure */
1047       char group_str[100];
1048       char source_str[100];
1049       pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
1050       pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
1051       zlog_warn("%s %s: failure removing OIL for channel (S,G)=(%s,%s)",
1052                 __FILE__, __PRETTY_FUNCTION__,
1053                 source_str, group_str);
1054     }
1055   }
1056
1057   if (PIM_DEBUG_MROUTE) {
1058     char group_str[100];
1059     char source_str[100];
1060     pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp, group_str, sizeof(group_str));
1061     pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin, source_str, sizeof(source_str));
1062     zlog_debug("%s %s: (S,G)=(%s,%s): proto_mask=%u OIF=%s vif_index=%d: DONE",
1063                __FILE__, __PRETTY_FUNCTION__,
1064                source_str, group_str,
1065                proto_mask, oif->name, pim_ifp->mroute_vif_index);
1066   }
1067
1068   return 0;
1069 }
1070
1071 void igmp_source_forward_start(struct igmp_source *source)
1072 {
1073   struct igmp_group *group;
1074   int result;
1075
1076   if (PIM_DEBUG_IGMP_TRACE) {
1077     char source_str[100];
1078     char group_str[100];
1079     pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
1080     pim_inet4_dump("<group?>", source->source_group->group_addr, group_str, sizeof(group_str));
1081     zlog_debug("%s: (S,G)=(%s,%s) igmp_sock=%d oif=%s fwd=%d",
1082                __PRETTY_FUNCTION__,
1083                source_str, group_str,
1084                source->source_group->group_igmp_sock->fd,
1085                source->source_group->group_igmp_sock->interface->name,
1086                IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
1087   }
1088
1089   /* Prevent IGMP interface from installing multicast route multiple
1090      times */
1091   if (IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
1092     return;
1093   }
1094
1095   group = source->source_group;
1096
1097   if (!source->source_channel_oil) {
1098     struct pim_interface *pim_oif;
1099     int input_iface_vif_index = fib_lookup_if_vif_index(source->source_addr);
1100     if (input_iface_vif_index < 1) {
1101       char source_str[100];
1102       pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
1103       zlog_warn("%s %s: could not find input interface for source %s",
1104                 __FILE__, __PRETTY_FUNCTION__,
1105                 source_str);
1106       return;
1107     }
1108
1109     /*
1110       Protect IGMP against adding looped MFC entries created by both
1111       source and receiver attached to the same interface. See TODO
1112       T22.
1113     */
1114     pim_oif = source->source_group->group_igmp_sock->interface->info;
1115     if (!pim_oif) {
1116       zlog_warn("%s: multicast not enabled on oif=%s ?",
1117                 __PRETTY_FUNCTION__,
1118                 source->source_group->group_igmp_sock->interface->name);
1119       return;
1120     }
1121     if (pim_oif->mroute_vif_index < 1) {
1122       zlog_warn("%s %s: oif=%s vif_index=%d < 1",
1123                 __FILE__, __PRETTY_FUNCTION__,
1124                 source->source_group->group_igmp_sock->interface->name,
1125                 pim_oif->mroute_vif_index);
1126       return;
1127     }
1128     if (input_iface_vif_index == pim_oif->mroute_vif_index) {
1129       /* ignore request for looped MFC entry */
1130       if (PIM_DEBUG_IGMP_TRACE) {
1131         char source_str[100];
1132         char group_str[100];
1133         pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
1134         pim_inet4_dump("<group?>", source->source_group->group_addr, group_str, sizeof(group_str));
1135         zlog_debug("%s: ignoring request for looped MFC entry (S,G)=(%s,%s): igmp_sock=%d oif=%s vif_index=%d",
1136                    __PRETTY_FUNCTION__,
1137                    source_str, group_str,
1138                    source->source_group->group_igmp_sock->fd,
1139                    source->source_group->group_igmp_sock->interface->name,
1140                    input_iface_vif_index);
1141       }
1142       return;
1143     }
1144
1145     source->source_channel_oil = pim_channel_oil_add(group->group_addr,
1146                                                      source->source_addr,
1147                                                      input_iface_vif_index);
1148     if (!source->source_channel_oil) {
1149       char group_str[100];
1150       char source_str[100];
1151       pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1152       pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
1153       zlog_warn("%s %s: could not create OIL for channel (S,G)=(%s,%s)",
1154                 __FILE__, __PRETTY_FUNCTION__,
1155                 source_str, group_str);
1156       return;
1157     }
1158   }
1159
1160   result = add_oif(source->source_channel_oil,
1161                    group->group_igmp_sock->interface,
1162                    PIM_OIF_FLAG_PROTO_IGMP);
1163   if (result) {
1164     zlog_warn("%s: add_oif() failed with return=%d",
1165               __func__, result);
1166     return;
1167   }
1168
1169   /*
1170     Feed IGMPv3-gathered local membership information into PIM
1171     per-interface (S,G) state.
1172    */
1173   pim_ifchannel_local_membership_add(group->group_igmp_sock->interface,
1174                                      source->source_addr, group->group_addr);
1175
1176   IGMP_SOURCE_DO_FORWARDING(source->source_flags);
1177 }
1178
1179 /*
1180   igmp_source_forward_stop: stop fowarding, but keep the source
1181   igmp_source_delete:       stop fowarding, and delete the source
1182  */
1183 void igmp_source_forward_stop(struct igmp_source *source)
1184 {
1185   struct igmp_group *group;
1186   int result;
1187
1188   if (PIM_DEBUG_IGMP_TRACE) {
1189     char source_str[100];
1190     char group_str[100];
1191     pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
1192     pim_inet4_dump("<group?>", source->source_group->group_addr, group_str, sizeof(group_str));
1193     zlog_debug("%s: (S,G)=(%s,%s) igmp_sock=%d oif=%s fwd=%d",
1194                __PRETTY_FUNCTION__,
1195                source_str, group_str,
1196                source->source_group->group_igmp_sock->fd,
1197                source->source_group->group_igmp_sock->interface->name,
1198                IGMP_SOURCE_TEST_FORWARDING(source->source_flags));
1199   }
1200
1201   /* Prevent IGMP interface from removing multicast route multiple
1202      times */
1203   if (!IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
1204     return;
1205   }
1206
1207   group = source->source_group;
1208
1209   /*
1210    It appears that in certain circumstances that
1211    igmp_source_forward_stop is called when IGMP forwarding
1212    was not enabled in oif_flags for this outgoing interface.
1213    Possibly because of multiple calls. When that happens, we
1214    enter the below if statement and this function returns early
1215    which in turn triggers the calling function to assert.
1216    Making the call to del_oif and ignoring the return code
1217    fixes the issue without ill effect, similar to
1218    pim_forward_stop below.
1219   */
1220   result = del_oif(source->source_channel_oil,
1221                    group->group_igmp_sock->interface,
1222                    PIM_OIF_FLAG_PROTO_IGMP);
1223   if (result) {
1224     zlog_warn("%s: del_oif() failed with return=%d",
1225               __func__, result);
1226     return;
1227   }
1228
1229   /*
1230     Feed IGMPv3-gathered local membership information into PIM
1231     per-interface (S,G) state.
1232    */
1233   pim_ifchannel_local_membership_del(group->group_igmp_sock->interface,
1234                                      source->source_addr, group->group_addr);
1235
1236   IGMP_SOURCE_DONT_FORWARDING(source->source_flags);
1237 }
1238
1239 void pim_forward_start(struct pim_ifchannel *ch)
1240 {
1241   struct pim_upstream *up = ch->upstream;
1242
1243   if (PIM_DEBUG_PIM_TRACE) {
1244     char source_str[100];
1245     char group_str[100];
1246     pim_inet4_dump("<source?>", ch->source_addr, source_str, sizeof(source_str));
1247     pim_inet4_dump("<group?>", ch->group_addr, group_str, sizeof(group_str));
1248     zlog_debug("%s: (S,G)=(%s,%s) oif=%s",
1249                __PRETTY_FUNCTION__,
1250                source_str, group_str, ch->interface->name);
1251   }
1252
1253   if (!up->channel_oil) {
1254     int input_iface_vif_index = fib_lookup_if_vif_index(up->source_addr);
1255     if (input_iface_vif_index < 1) {
1256       char source_str[100];
1257       pim_inet4_dump("<source?>", up->source_addr, source_str, sizeof(source_str));
1258       zlog_warn("%s %s: could not find input interface for source %s",
1259                 __FILE__, __PRETTY_FUNCTION__,
1260                 source_str);
1261       return;
1262     }
1263
1264     up->channel_oil = pim_channel_oil_add(up->group_addr, up->source_addr,
1265                                           input_iface_vif_index);
1266     if (!up->channel_oil) {
1267       char group_str[100];
1268       char source_str[100];
1269       pim_inet4_dump("<group?>", up->group_addr, group_str, sizeof(group_str));
1270       pim_inet4_dump("<source?>", up->source_addr, source_str, sizeof(source_str));
1271       zlog_warn("%s %s: could not create OIL for channel (S,G)=(%s,%s)",
1272                 __FILE__, __PRETTY_FUNCTION__,
1273                 source_str, group_str);
1274       return;
1275     }
1276   }
1277
1278   add_oif(up->channel_oil,
1279           ch->interface,
1280           PIM_OIF_FLAG_PROTO_PIM);
1281 }
1282
1283 void pim_forward_stop(struct pim_ifchannel *ch)
1284 {
1285   struct pim_upstream *up = ch->upstream;
1286
1287   if (PIM_DEBUG_PIM_TRACE) {
1288     char source_str[100];
1289     char group_str[100];
1290     pim_inet4_dump("<source?>", ch->source_addr, source_str, sizeof(source_str));
1291     pim_inet4_dump("<group?>", ch->group_addr, group_str, sizeof(group_str));
1292     zlog_debug("%s: (S,G)=(%s,%s) oif=%s",
1293                __PRETTY_FUNCTION__,
1294                source_str, group_str, ch->interface->name);
1295   }
1296
1297   if (!up->channel_oil) {
1298     char source_str[100];
1299     char group_str[100];
1300     pim_inet4_dump("<source?>", ch->source_addr, source_str, sizeof(source_str));
1301     pim_inet4_dump("<group?>", ch->group_addr, group_str, sizeof(group_str));
1302     zlog_warn("%s: (S,G)=(%s,%s) oif=%s missing channel OIL",
1303                __PRETTY_FUNCTION__,
1304                source_str, group_str, ch->interface->name);
1305
1306     return;
1307   }
1308
1309   del_oif(up->channel_oil,
1310           ch->interface,
1311           PIM_OIF_FLAG_PROTO_PIM);
1312 }