pimd/pim_iface.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * PIM for Quagga
   4  * Copyright (C) 2008  Everton da Silva Marques
   5  */
   6
   7 #include <zebra.h>
   8
   9 #include "if.h"
  10 #include "log.h"
  11 #include "vty.h"
  12 #include "memory.h"
  13 #include "prefix.h"
  14 #include "vrf.h"
  15 #include "linklist.h"
  16 #include "plist.h"
  17 #include "hash.h"
  18 #include "ferr.h"
  19 #include "network.h"
  20
  21 #include "pimd.h"
  22 #include "pim_instance.h"
  23 #include "pim_zebra.h"
  24 #include "pim_iface.h"
  25 #include "pim_igmp.h"
  26 #include "pim_mroute.h"
  27 #include "pim_oil.h"
  28 #include "pim_str.h"
  29 #include "pim_pim.h"
  30 #include "pim_neighbor.h"
  31 #include "pim_ifchannel.h"
  32 #include "pim_sock.h"
  33 #include "pim_time.h"
  34 #include "pim_ssmpingd.h"
  35 #include "pim_rp.h"
  36 #include "pim_nht.h"
  37 #include "pim_jp_agg.h"
  38 #include "pim_igmp_join.h"
  39 #include "pim_vxlan.h"
  40
  41 #include "pim6_mld.h"
  42
  43 #if PIM_IPV == 4
  44 static void pim_if_igmp_join_del_all(struct interface *ifp);
  45 #endif
  46 static int gm_join_sock(const char *ifname, ifindex_t ifindex,
  47                         pim_addr group_addr, pim_addr source_addr,
  48                         struct pim_interface *pim_ifp);
  49
  50 void pim_if_init(struct pim_instance *pim)
  51 {
  52         int i;
  53
  54         for (i = 0; i < MAXVIFS; i++)
  55                 pim->iface_vif_index[i] = 0;
  56 }
  57
  58 void pim_if_terminate(struct pim_instance *pim)
  59 {
  60         struct interface *ifp;
  61
  62         FOR_ALL_INTERFACES (pim->vrf, ifp) {
  63                 struct pim_interface *pim_ifp = ifp->info;
  64
  65                 if (!pim_ifp)
  66                         continue;
  67
  68                 pim_if_delete(ifp);
  69         }
  70         return;
  71 }
  72
  73 static void pim_sec_addr_free(struct pim_secondary_addr *sec_addr)
  74 {
  75         XFREE(MTYPE_PIM_SEC_ADDR, sec_addr);
  76 }
  77
  78 __attribute__((unused))
  79 static int pim_sec_addr_comp(const void *p1, const void *p2)
  80 {
  81         const struct pim_secondary_addr *sec1 = p1;
  82         const struct pim_secondary_addr *sec2 = p2;
  83
  84         if (sec1->addr.family == AF_INET && sec2->addr.family == AF_INET6)
  85                 return -1;
  86
  87         if (sec1->addr.family == AF_INET6 && sec2->addr.family == AF_INET)
  88                 return 1;
  89
  90         if (sec1->addr.family == AF_INET) {
  91                 if (ntohl(sec1->addr.u.prefix4.s_addr)
  92                     < ntohl(sec2->addr.u.prefix4.s_addr))
  93                         return -1;
  94
  95                 if (ntohl(sec1->addr.u.prefix4.s_addr)
  96                     > ntohl(sec2->addr.u.prefix4.s_addr))
  97                         return 1;
  98         } else {
  99                 return memcmp(&sec1->addr.u.prefix6, &sec2->addr.u.prefix6,
 100                               sizeof(struct in6_addr));
 101         }
 102
 103         return 0;
 104 }
 105
 106 struct pim_interface *pim_if_new(struct interface *ifp, bool gm, bool pim,
 107                                  bool ispimreg, bool is_vxlan_term)
 108 {
 109         struct pim_interface *pim_ifp;
 110
 111         assert(ifp);
 112         assert(!ifp->info);
 113
 114         pim_ifp = XCALLOC(MTYPE_PIM_INTERFACE, sizeof(*pim_ifp));
 115
 116         pim_ifp->pim = ifp->vrf->info;
 117         pim_ifp->mroute_vif_index = -1;
 118
 119         pim_ifp->igmp_version = IGMP_DEFAULT_VERSION;
 120         pim_ifp->mld_version = MLD_DEFAULT_VERSION;
 121         pim_ifp->gm_default_robustness_variable =
 122                 GM_DEFAULT_ROBUSTNESS_VARIABLE;
 123         pim_ifp->gm_default_query_interval = GM_GENERAL_QUERY_INTERVAL;
 124         pim_ifp->gm_query_max_response_time_dsec =
 125                 GM_QUERY_MAX_RESPONSE_TIME_DSEC;
 126         pim_ifp->gm_specific_query_max_response_time_dsec =
 127                 GM_SPECIFIC_QUERY_MAX_RESPONSE_TIME_DSEC;
 128         pim_ifp->gm_last_member_query_count = GM_DEFAULT_ROBUSTNESS_VARIABLE;
 129
 130         /* BSM config on interface: true by default */
 131         pim_ifp->bsm_enable = true;
 132         pim_ifp->ucast_bsm_accept = true;
 133         pim_ifp->am_i_dr = false;
 134
 135         /*
 136           RFC 3376: 8.3. Query Response Interval
 137           The number of seconds represented by the [Query Response Interval]
 138           must be less than the [Query Interval].
 139          */
 140         assert(pim_ifp->gm_query_max_response_time_dsec <
 141                pim_ifp->gm_default_query_interval);
 142
 143         pim_ifp->pim_enable = pim;
 144         pim_ifp->pim_passive_enable = false;
 145         pim_ifp->gm_enable = gm;
 146
 147         pim_ifp->gm_join_list = NULL;
 148         pim_ifp->pim_neighbor_list = NULL;
 149         pim_ifp->upstream_switch_list = NULL;
 150         pim_ifp->pim_generation_id = 0;
 151
 152         /* list of struct gm_sock */
 153         pim_igmp_if_init(pim_ifp, ifp);
 154
 155         /* list of struct pim_neighbor */
 156         pim_ifp->pim_neighbor_list = list_new();
 157         pim_ifp->pim_neighbor_list->del = (void (*)(void *))pim_neighbor_free;
 158
 159         pim_ifp->upstream_switch_list = list_new();
 160         pim_ifp->upstream_switch_list->del =
 161                 (void (*)(void *))pim_jp_agg_group_list_free;
 162         pim_ifp->upstream_switch_list->cmp = pim_jp_agg_group_list_cmp;
 163
 164         pim_ifp->sec_addr_list = list_new();
 165         pim_ifp->sec_addr_list->del = (void (*)(void *))pim_sec_addr_free;
 166         pim_ifp->sec_addr_list->cmp =
 167                 (int (*)(void *, void *))pim_sec_addr_comp;
 168
 169         pim_ifp->activeactive = false;
 170
 171         RB_INIT(pim_ifchannel_rb, &pim_ifp->ifchannel_rb);
 172
 173         ifp->info = pim_ifp;
 174
 175         pim_sock_reset(ifp);
 176
 177         pim_if_add_vif(ifp, ispimreg, is_vxlan_term);
 178         pim_ifp->pim->mcast_if_count++;
 179
 180         return pim_ifp;
 181 }
 182
 183 void pim_if_delete(struct interface *ifp)
 184 {
 185         struct pim_interface *pim_ifp;
 186
 187         assert(ifp);
 188         pim_ifp = ifp->info;
 189         assert(pim_ifp);
 190
 191         pim_ifp->pim->mcast_if_count--;
 192 #if PIM_IPV == 4
 193         if (pim_ifp->gm_join_list) {
 194                 pim_if_igmp_join_del_all(ifp);
 195         }
 196 #endif
 197
 198         pim_ifchannel_delete_all(ifp);
 199 #if PIM_IPV == 4
 200         igmp_sock_delete_all(ifp);
 201 #endif
 202         if (pim_ifp->pim_sock_fd >= 0)
 203                 pim_sock_delete(ifp, "Interface removed from configuration");
 204
 205         pim_if_del_vif(ifp);
 206
 207         pim_igmp_if_fini(pim_ifp);
 208
 209         list_delete(&pim_ifp->pim_neighbor_list);
 210         list_delete(&pim_ifp->upstream_switch_list);
 211         list_delete(&pim_ifp->sec_addr_list);
 212
 213         if (pim_ifp->bfd_config.profile)
 214                 XFREE(MTYPE_TMP, pim_ifp->bfd_config.profile);
 215
 216         XFREE(MTYPE_PIM_INTERFACE, pim_ifp->boundary_oil_plist);
 217         XFREE(MTYPE_PIM_INTERFACE, pim_ifp);
 218
 219         ifp->info = NULL;
 220 }
 221
 222 void pim_if_update_could_assert(struct interface *ifp)
 223 {
 224         struct pim_interface *pim_ifp;
 225         struct pim_ifchannel *ch;
 226
 227         pim_ifp = ifp->info;
 228         assert(pim_ifp);
 229
 230         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
 231                 pim_ifchannel_update_could_assert(ch);
 232         }
 233 }
 234
 235 static void pim_if_update_my_assert_metric(struct interface *ifp)
 236 {
 237         struct pim_interface *pim_ifp;
 238         struct pim_ifchannel *ch;
 239
 240         pim_ifp = ifp->info;
 241         assert(pim_ifp);
 242
 243         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
 244                 pim_ifchannel_update_my_assert_metric(ch);
 245         }
 246 }
 247
 248 static void pim_addr_change(struct interface *ifp)
 249 {
 250         struct pim_interface *pim_ifp;
 251
 252         pim_ifp = ifp->info;
 253         assert(pim_ifp);
 254
 255         pim_if_dr_election(ifp); /* router's own DR Priority (addr) changes --
 256                                     Done TODO T30 */
 257         pim_if_update_join_desired(pim_ifp); /* depends on DR */
 258         pim_if_update_could_assert(ifp);     /* depends on DR */
 259         pim_if_update_my_assert_metric(ifp); /* depends on could_assert */
 260         pim_if_update_assert_tracking_desired(
 261                 ifp); /* depends on DR, join_desired */
 262
 263         /*
 264           RFC 4601: 4.3.1.  Sending Hello Messages
 265
 266           1) Before an interface goes down or changes primary IP address, a
 267           Hello message with a zero HoldTime should be sent immediately
 268           (with the old IP address if the IP address changed).
 269           -- Done at the caller of the function as new ip already updated here
 270
 271           2) After an interface has changed its IP address, it MUST send a
 272           Hello message with its new IP address.
 273           -- DONE below
 274
 275           3) If an interface changes one of its secondary IP addresses, a
 276           Hello message with an updated Address_List option and a non-zero
 277           HoldTime should be sent immediately.
 278           -- FIXME See TODO T31
 279          */
 280         PIM_IF_FLAG_UNSET_HELLO_SENT(pim_ifp->flags);
 281         if (pim_ifp->pim_sock_fd < 0)
 282                 return;
 283         pim_hello_restart_now(ifp); /* send hello and restart timer */
 284 }
 285
 286 static int detect_primary_address_change(struct interface *ifp,
 287                                          int force_prim_as_any,
 288                                          const char *caller)
 289 {
 290         struct pim_interface *pim_ifp = ifp->info;
 291         pim_addr new_prim_addr;
 292         int changed;
 293
 294         if (force_prim_as_any)
 295                 new_prim_addr = PIMADDR_ANY;
 296         else
 297                 new_prim_addr = pim_find_primary_addr(ifp);
 298
 299         changed = pim_addr_cmp(new_prim_addr, pim_ifp->primary_address);
 300
 301         if (PIM_DEBUG_ZEBRA)
 302                 zlog_debug("%s: old=%pPA new=%pPA on interface %s: %s",
 303                            __func__, &pim_ifp->primary_address, &new_prim_addr,
 304                            ifp->name, changed ? "changed" : "unchanged");
 305
 306         if (changed) {
 307                 /* Before updating pim_ifp send Hello time with 0 hold time */
 308                 if (pim_ifp->pim_enable) {
 309                         pim_hello_send(ifp, 0 /* zero-sec holdtime */);
 310                 }
 311                 pim_ifp->primary_address = new_prim_addr;
 312         }
 313
 314         return changed;
 315 }
 316
 317 static struct pim_secondary_addr *
 318 pim_sec_addr_find(struct pim_interface *pim_ifp, struct prefix *addr)
 319 {
 320         struct pim_secondary_addr *sec_addr;
 321         struct listnode *node;
 322
 323         for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node, sec_addr)) {
 324                 if (prefix_cmp(&sec_addr->addr, addr) == 0) {
 325                         return sec_addr;
 326                 }
 327         }
 328
 329         return NULL;
 330 }
 331
 332 static void pim_sec_addr_del(struct pim_interface *pim_ifp,
 333                              struct pim_secondary_addr *sec_addr)
 334 {
 335         listnode_delete(pim_ifp->sec_addr_list, sec_addr);
 336         pim_sec_addr_free(sec_addr);
 337 }
 338
 339 static int pim_sec_addr_add(struct pim_interface *pim_ifp, struct prefix *addr)
 340 {
 341         int changed = 0;
 342         struct pim_secondary_addr *sec_addr;
 343
 344         sec_addr = pim_sec_addr_find(pim_ifp, addr);
 345         if (sec_addr) {
 346                 sec_addr->flags &= ~PIM_SEC_ADDRF_STALE;
 347                 return changed;
 348         }
 349
 350         sec_addr = XCALLOC(MTYPE_PIM_SEC_ADDR, sizeof(*sec_addr));
 351
 352         changed = 1;
 353         sec_addr->addr = *addr;
 354         listnode_add_sort(pim_ifp->sec_addr_list, sec_addr);
 355
 356         return changed;
 357 }
 358
 359 static int pim_sec_addr_del_all(struct pim_interface *pim_ifp)
 360 {
 361         int changed = 0;
 362
 363         if (!list_isempty(pim_ifp->sec_addr_list)) {
 364                 changed = 1;
 365                 /* remove all nodes and free up the list itself */
 366                 list_delete_all_node(pim_ifp->sec_addr_list);
 367         }
 368
 369         return changed;
 370 }
 371
 372 static int pim_sec_addr_update(struct interface *ifp)
 373 {
 374         struct pim_interface *pim_ifp = ifp->info;
 375         struct connected *ifc;
 376         struct listnode *node;
 377         struct listnode *nextnode;
 378         struct pim_secondary_addr *sec_addr;
 379         int changed = 0;
 380
 381         for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node, sec_addr)) {
 382                 sec_addr->flags |= PIM_SEC_ADDRF_STALE;
 383         }
 384
 385         for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 386                 pim_addr addr = pim_addr_from_prefix(ifc->address);
 387
 388                 if (pim_addr_is_any(addr))
 389                         continue;
 390
 391                 if (!pim_addr_cmp(addr, pim_ifp->primary_address)) {
 392                         /* don't add the primary address into the secondary
 393                          * address list */
 394                         continue;
 395                 }
 396
 397                 if (pim_sec_addr_add(pim_ifp, ifc->address)) {
 398                         changed = 1;
 399                 }
 400         }
 401
 402         /* Drop stale entries */
 403         for (ALL_LIST_ELEMENTS(pim_ifp->sec_addr_list, node, nextnode,
 404                                sec_addr)) {
 405                 if (sec_addr->flags & PIM_SEC_ADDRF_STALE) {
 406                         pim_sec_addr_del(pim_ifp, sec_addr);
 407                         changed = 1;
 408                 }
 409         }
 410
 411         return changed;
 412 }
 413
 414 static int detect_secondary_address_change(struct interface *ifp,
 415                                            int force_prim_as_any,
 416                                            const char *caller)
 417 {
 418         struct pim_interface *pim_ifp = ifp->info;
 419         int changed = 0;
 420
 421         if (force_prim_as_any) {
 422                 /* if primary address is being forced to zero just flush the
 423                  * secondary address list */
 424                 changed = pim_sec_addr_del_all(pim_ifp);
 425         } else {
 426                 /* re-evaluate the secondary address list */
 427                 changed = pim_sec_addr_update(ifp);
 428         }
 429
 430         return changed;
 431 }
 432
 433 static void detect_address_change(struct interface *ifp, int force_prim_as_any,
 434                                   const char *caller)
 435 {
 436         int changed = 0;
 437         struct pim_interface *pim_ifp;
 438
 439         pim_ifp = ifp->info;
 440         if (!pim_ifp)
 441                 return;
 442
 443         if (detect_primary_address_change(ifp, force_prim_as_any, caller)) {
 444                 changed = 1;
 445         }
 446
 447         if (detect_secondary_address_change(ifp, force_prim_as_any, caller)) {
 448                 changed = 1;
 449         }
 450
 451
 452         if (changed) {
 453                 if (!pim_ifp->pim_enable) {
 454                         return;
 455                 }
 456
 457                 pim_addr_change(ifp);
 458         }
 459
 460         /* XXX: if we have unnumbered interfaces we need to run detect address
 461          * address change on all of them when the lo address changes */
 462 }
 463
 464 int pim_update_source_set(struct interface *ifp, pim_addr source)
 465 {
 466         struct pim_interface *pim_ifp = ifp->info;
 467
 468         if (!pim_ifp) {
 469                 return PIM_IFACE_NOT_FOUND;
 470         }
 471
 472         if (!pim_addr_cmp(pim_ifp->update_source, source)) {
 473                 return PIM_UPDATE_SOURCE_DUP;
 474         }
 475
 476         pim_ifp->update_source = source;
 477         detect_address_change(ifp, 0 /* force_prim_as_any */, __func__);
 478
 479         return PIM_SUCCESS;
 480 }
 481
 482 void pim_if_addr_add(struct connected *ifc)
 483 {
 484         struct pim_interface *pim_ifp;
 485         struct interface *ifp;
 486         bool vxlan_term;
 487
 488         assert(ifc);
 489
 490         ifp = ifc->ifp;
 491         assert(ifp);
 492         pim_ifp = ifp->info;
 493         if (!pim_ifp)
 494                 return;
 495
 496         if (!if_is_operative(ifp))
 497                 return;
 498
 499         if (PIM_DEBUG_ZEBRA)
 500                 zlog_debug("%s: %s ifindex=%d connected IP address %pFX %s",
 501                            __func__, ifp->name, ifp->ifindex, ifc->address,
 502                            CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY)
 503                                    ? "secondary"
 504                                    : "primary");
 505 #if PIM_IPV != 4
 506         if (IN6_IS_ADDR_LINKLOCAL(&ifc->address->u.prefix6) ||
 507             IN6_IS_ADDR_LOOPBACK(&ifc->address->u.prefix6)) {
 508                 if (IN6_IS_ADDR_UNSPECIFIED(&pim_ifp->ll_lowest))
 509                         pim_ifp->ll_lowest = ifc->address->u.prefix6;
 510                 else if (IPV6_ADDR_CMP(&ifc->address->u.prefix6,
 511                                        &pim_ifp->ll_lowest) < 0)
 512                         pim_ifp->ll_lowest = ifc->address->u.prefix6;
 513
 514                 if (IPV6_ADDR_CMP(&ifc->address->u.prefix6,
 515                                   &pim_ifp->ll_highest) > 0)
 516                         pim_ifp->ll_highest = ifc->address->u.prefix6;
 517
 518                 if (PIM_DEBUG_ZEBRA)
 519                         zlog_debug(
 520                                 "%s: new link-local %pI6, lowest now %pI6, highest %pI6",
 521                                 ifc->ifp->name, &ifc->address->u.prefix6,
 522                                 &pim_ifp->ll_lowest, &pim_ifp->ll_highest);
 523         }
 524 #endif
 525
 526         detect_address_change(ifp, 0, __func__);
 527
 528         // if (ifc->address->family != AF_INET)
 529         //  return;
 530
 531 #if PIM_IPV == 4
 532         struct in_addr ifaddr = ifc->address->u.prefix4;
 533
 534         if (pim_ifp->gm_enable) {
 535                 struct gm_sock *igmp;
 536
 537                 /* lookup IGMP socket */
 538                 igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->gm_socket_list,
 539                                                    ifaddr);
 540                 if (!igmp) {
 541                         /* if addr new, add IGMP socket */
 542                         if (ifc->address->family == AF_INET)
 543                                 pim_igmp_sock_add(pim_ifp->gm_socket_list,
 544                                                   ifaddr, ifp, false);
 545                 } else if (igmp->mtrace_only) {
 546                         igmp_sock_delete(igmp);
 547                         pim_igmp_sock_add(pim_ifp->gm_socket_list, ifaddr, ifp,
 548                                           false);
 549                 }
 550
 551                 /* Replay Static IGMP groups */
 552                 if (pim_ifp->gm_join_list) {
 553                         struct listnode *node;
 554                         struct listnode *nextnode;
 555                         struct gm_join *ij;
 556                         int join_fd;
 557
 558                         for (ALL_LIST_ELEMENTS(pim_ifp->gm_join_list, node,
 559                                                nextnode, ij)) {
 560                                 /* Close socket and reopen with Source and Group
 561                                  */
 562                                 close(ij->sock_fd);
 563                                 join_fd = gm_join_sock(
 564                                         ifp->name, ifp->ifindex, ij->group_addr,
 565                                         ij->source_addr, pim_ifp);
 566                                 if (join_fd < 0) {
 567                                         char group_str[INET_ADDRSTRLEN];
 568                                         char source_str[INET_ADDRSTRLEN];
 569                                         pim_inet4_dump("<grp?>", ij->group_addr,
 570                                                        group_str,
 571                                                        sizeof(group_str));
 572                                         pim_inet4_dump(
 573                                                 "<src?>", ij->source_addr,
 574                                                 source_str, sizeof(source_str));
 575                                         zlog_warn(
 576                                                 "%s: gm_join_sock() failure for IGMP group %s source %s on interface %s",
 577                                                 __func__, group_str, source_str,
 578                                                 ifp->name);
 579                                         /* warning only */
 580                                 } else
 581                                         ij->sock_fd = join_fd;
 582                         }
 583                 }
 584         } /* igmp */
 585         else {
 586                 struct gm_sock *igmp;
 587
 588                 /* lookup IGMP socket */
 589                 igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->gm_socket_list,
 590                                                    ifaddr);
 591                 if (ifc->address->family == AF_INET) {
 592                         if (igmp)
 593                                 igmp_sock_delete(igmp);
 594                         /* if addr new, add IGMP socket */
 595                         pim_igmp_sock_add(pim_ifp->gm_socket_list, ifaddr, ifp,
 596                                           true);
 597                 }
 598         } /* igmp mtrace only */
 599 #endif
 600
 601         if (pim_ifp->pim_enable) {
 602
 603                 if (!pim_addr_is_any(pim_ifp->primary_address)) {
 604
 605                         /* Interface has a valid socket ? */
 606                         if (pim_ifp->pim_sock_fd < 0) {
 607                                 if (pim_sock_add(ifp)) {
 608                                         zlog_warn(
 609                                                 "Failure creating PIM socket for interface %s",
 610                                                 ifp->name);
 611                                 }
 612                         }
 613                         struct pim_nexthop_cache *pnc = NULL;
 614                         struct pim_rpf rpf;
 615                         struct zclient *zclient = NULL;
 616
 617                         zclient = pim_zebra_zclient_get();
 618                         /* RP config might come prior to (local RP's interface)
 619                            IF UP event.
 620                            In this case, pnc would not have pim enabled
 621                            nexthops.
 622                            Once Interface is UP and pim info is available,
 623                            reregister
 624                            with RNH address to receive update and add the
 625                            interface as nexthop. */
 626                         memset(&rpf, 0, sizeof(struct pim_rpf));
 627                         rpf.rpf_addr = pim_addr_from_prefix(ifc->address);
 628                         pnc = pim_nexthop_cache_find(pim_ifp->pim, &rpf);
 629                         if (pnc)
 630                                 pim_sendmsg_zebra_rnh(pim_ifp->pim, zclient,
 631                                                       pnc,
 632                                                       ZEBRA_NEXTHOP_REGISTER);
 633                 }
 634         } /* pim */
 635
 636         /*
 637           PIM or IGMP is enabled on interface, and there is at least one
 638           address assigned, then try to create a vif_index.
 639         */
 640         if (pim_ifp->mroute_vif_index < 0) {
 641                 vxlan_term = pim_vxlan_is_term_dev_cfg(pim_ifp->pim, ifp);
 642                 pim_if_add_vif(ifp, false, vxlan_term);
 643         }
 644         gm_ifp_update(ifp);
 645         pim_ifchannel_scan_forward_start(ifp);
 646 }
 647
 648 static void pim_if_addr_del_igmp(struct connected *ifc)
 649 {
 650 #if PIM_IPV == 4
 651         struct pim_interface *pim_ifp = ifc->ifp->info;
 652         struct gm_sock *igmp;
 653         struct in_addr ifaddr;
 654
 655         if (ifc->address->family != AF_INET) {
 656                 /* non-IPv4 address */
 657                 return;
 658         }
 659
 660         if (!pim_ifp) {
 661                 /* IGMP not enabled on interface */
 662                 return;
 663         }
 664
 665         ifaddr = ifc->address->u.prefix4;
 666
 667         /* lookup IGMP socket */
 668         igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->gm_socket_list, ifaddr);
 669         if (igmp) {
 670                 /* if addr found, del IGMP socket */
 671                 igmp_sock_delete(igmp);
 672         }
 673 #endif
 674 }
 675
 676 static void pim_if_addr_del_pim(struct connected *ifc)
 677 {
 678         struct pim_interface *pim_ifp = ifc->ifp->info;
 679
 680         if (ifc->address->family != PIM_AF) {
 681                 /* non-IPv4 address */
 682                 return;
 683         }
 684
 685         if (!pim_ifp) {
 686                 /* PIM not enabled on interface */
 687                 return;
 688         }
 689
 690         if (!pim_addr_is_any(pim_ifp->primary_address)) {
 691                 /* Interface keeps a valid primary address */
 692                 return;
 693         }
 694
 695         if (pim_ifp->pim_sock_fd < 0) {
 696                 /* Interface does not hold a valid socket any longer */
 697                 return;
 698         }
 699
 700         /*
 701           pim_sock_delete() closes the socket, stops read and timer threads,
 702           and kills all neighbors.
 703          */
 704         pim_sock_delete(ifc->ifp,
 705                         "last address has been removed from interface");
 706 }
 707
 708 void pim_if_addr_del(struct connected *ifc, int force_prim_as_any)
 709 {
 710         struct interface *ifp;
 711
 712         assert(ifc);
 713         ifp = ifc->ifp;
 714         assert(ifp);
 715
 716         if (PIM_DEBUG_ZEBRA)
 717                 zlog_debug("%s: %s ifindex=%d disconnected IP address %pFX %s",
 718                            __func__, ifp->name, ifp->ifindex, ifc->address,
 719                            CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY)
 720                                    ? "secondary"
 721                                    : "primary");
 722
 723 #if PIM_IPV == 6
 724         struct pim_interface *pim_ifp = ifc->ifp->info;
 725
 726         if (pim_ifp &&
 727             (!IPV6_ADDR_CMP(&ifc->address->u.prefix6, &pim_ifp->ll_lowest) ||
 728              !IPV6_ADDR_CMP(&ifc->address->u.prefix6, &pim_ifp->ll_highest))) {
 729                 struct listnode *cnode;
 730                 struct connected *cc;
 731
 732                 memset(&pim_ifp->ll_lowest, 0xff, sizeof(pim_ifp->ll_lowest));
 733                 memset(&pim_ifp->ll_highest, 0, sizeof(pim_ifp->ll_highest));
 734
 735                 for (ALL_LIST_ELEMENTS_RO(ifc->ifp->connected, cnode, cc)) {
 736                         if (!IN6_IS_ADDR_LINKLOCAL(&cc->address->u.prefix6) &&
 737                             !IN6_IS_ADDR_LOOPBACK(&cc->address->u.prefix6))
 738                                 continue;
 739
 740                         if (IPV6_ADDR_CMP(&cc->address->u.prefix6,
 741                                           &pim_ifp->ll_lowest) < 0)
 742                                 pim_ifp->ll_lowest = cc->address->u.prefix6;
 743                         if (IPV6_ADDR_CMP(&cc->address->u.prefix6,
 744                                           &pim_ifp->ll_highest) > 0)
 745                                 pim_ifp->ll_highest = cc->address->u.prefix6;
 746                 }
 747
 748                 if (pim_ifp->ll_lowest.s6_addr[0] == 0xff)
 749                         memset(&pim_ifp->ll_lowest, 0,
 750                                sizeof(pim_ifp->ll_lowest));
 751
 752                 if (PIM_DEBUG_ZEBRA)
 753                         zlog_debug(
 754                                 "%s: removed link-local %pI6, lowest now %pI6, highest %pI6",
 755                                 ifc->ifp->name, &ifc->address->u.prefix6,
 756                                 &pim_ifp->ll_lowest, &pim_ifp->ll_highest);
 757
 758                 gm_ifp_update(ifp);
 759         }
 760 #endif
 761
 762         detect_address_change(ifp, force_prim_as_any, __func__);
 763
 764         pim_if_addr_del_igmp(ifc);
 765         pim_if_addr_del_pim(ifc);
 766 }
 767
 768 void pim_if_addr_add_all(struct interface *ifp)
 769 {
 770         struct connected *ifc;
 771         struct listnode *node;
 772         struct listnode *nextnode;
 773         int v4_addrs = 0;
 774         int v6_addrs = 0;
 775         struct pim_interface *pim_ifp = ifp->info;
 776         bool vxlan_term;
 777
 778
 779         /* PIM/IGMP enabled ? */
 780         if (!pim_ifp)
 781                 return;
 782
 783         for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
 784                 struct prefix *p = ifc->address;
 785
 786                 if (p->family != AF_INET)
 787                         v6_addrs++;
 788                 else
 789                         v4_addrs++;
 790                 pim_if_addr_add(ifc);
 791         }
 792
 793         if (!v4_addrs && v6_addrs && !if_is_loopback(ifp) &&
 794             pim_ifp->pim_enable && !pim_addr_is_any(pim_ifp->primary_address) &&
 795             pim_ifp->pim_sock_fd < 0 && pim_sock_add(ifp)) {
 796                 /* Interface has a valid primary address ? */
 797                 /* Interface has a valid socket ? */
 798                 zlog_warn("Failure creating PIM socket for interface %s",
 799                           ifp->name);
 800         }
 801         /*
 802          * PIM or IGMP/MLD is enabled on interface, and there is at least one
 803          * address assigned, then try to create a vif_index.
 804          */
 805         if (pim_ifp->mroute_vif_index < 0) {
 806                 vxlan_term = pim_vxlan_is_term_dev_cfg(pim_ifp->pim, ifp);
 807                 pim_if_add_vif(ifp, false, vxlan_term);
 808         }
 809         gm_ifp_update(ifp);
 810         pim_ifchannel_scan_forward_start(ifp);
 811
 812         pim_rp_setup(pim_ifp->pim);
 813         pim_rp_check_on_if_add(pim_ifp);
 814 }
 815
 816 void pim_if_addr_del_all(struct interface *ifp)
 817 {
 818         struct connected *ifc;
 819         struct listnode *node;
 820         struct listnode *nextnode;
 821         struct pim_instance *pim;
 822
 823         pim = ifp->vrf->info;
 824         if (!pim)
 825                 return;
 826
 827         /* PIM/IGMP enabled ? */
 828         if (!ifp->info)
 829                 return;
 830
 831         for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
 832                 struct prefix *p = ifc->address;
 833
 834                 if (p->family != PIM_AF)
 835                         continue;
 836
 837                 pim_if_addr_del(ifc, 1 /* force_prim_as_any=true */);
 838         }
 839
 840         pim_rp_setup(pim);
 841         pim_i_am_rp_re_evaluate(pim);
 842 }
 843
 844 void pim_if_addr_del_all_igmp(struct interface *ifp)
 845 {
 846         struct connected *ifc;
 847         struct listnode *node;
 848         struct listnode *nextnode;
 849
 850         /* PIM/IGMP enabled ? */
 851         if (!ifp->info)
 852                 return;
 853
 854         for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
 855                 struct prefix *p = ifc->address;
 856
 857                 if (p->family != AF_INET)
 858                         continue;
 859
 860                 pim_if_addr_del_igmp(ifc);
 861         }
 862 }
 863
 864 pim_addr pim_find_primary_addr(struct interface *ifp)
 865 {
 866         struct connected *ifc;
 867         struct listnode *node;
 868         struct pim_interface *pim_ifp = ifp->info;
 869
 870         if (pim_ifp && !pim_addr_is_any(pim_ifp->update_source))
 871                 return pim_ifp->update_source;
 872
 873 #if PIM_IPV == 6
 874         if (pim_ifp && !pim_addr_is_any(pim_ifp->ll_highest))
 875                 return pim_ifp->ll_highest;
 876
 877         pim_addr best_addr = PIMADDR_ANY;
 878
 879         for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 880                 pim_addr addr;
 881
 882                 if (ifc->address->family != AF_INET6)
 883                         continue;
 884
 885                 addr = pim_addr_from_prefix(ifc->address);
 886                 if (!IN6_IS_ADDR_LINKLOCAL(&addr))
 887                         continue;
 888                 if (pim_addr_cmp(addr, best_addr) > 0)
 889                         best_addr = addr;
 890         }
 891
 892         return best_addr;
 893 #else
 894         int v4_addrs = 0;
 895         int v6_addrs = 0;
 896
 897         for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 898                 switch (ifc->address->family) {
 899                 case AF_INET:
 900                         v4_addrs++;
 901                         break;
 902                 case AF_INET6:
 903                         v6_addrs++;
 904                         break;
 905                 default:
 906                         continue;
 907                 }
 908
 909                 if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY))
 910                         continue;
 911
 912                 if (ifc->address->family != PIM_AF)
 913                         continue;
 914
 915                 return pim_addr_from_prefix(ifc->address);
 916         }
 917
 918         /*
 919          * If we have no v4_addrs and v6 is configured
 920          * We probably are using unnumbered
 921          * So let's grab the loopbacks v4 address
 922          * and use that as the primary address
 923          */
 924         if (!v4_addrs && v6_addrs) {
 925                 struct interface *lo_ifp;
 926
 927                 // DBS - Come back and check here
 928                 if (ifp->vrf->vrf_id == VRF_DEFAULT)
 929                         lo_ifp = if_lookup_by_name("lo", ifp->vrf->vrf_id);
 930                 else
 931                         lo_ifp = if_lookup_by_name(ifp->vrf->name,
 932                                                    ifp->vrf->vrf_id);
 933
 934                 if (lo_ifp && (lo_ifp != ifp))
 935                         return pim_find_primary_addr(lo_ifp);
 936         }
 937         return PIMADDR_ANY;
 938 #endif
 939 }
 940
 941 static int pim_iface_next_vif_index(struct interface *ifp)
 942 {
 943         struct pim_interface *pim_ifp = ifp->info;
 944         struct pim_instance *pim = pim_ifp->pim;
 945         int i;
 946
 947         /*
 948          * The pimreg vif is always going to be in index 0
 949          * of the table.
 950          */
 951         if (ifp->ifindex == PIM_OIF_PIM_REGISTER_VIF)
 952                 return 0;
 953
 954         for (i = 1; i < MAXVIFS; i++) {
 955                 if (pim->iface_vif_index[i] == 0)
 956                         return i;
 957         }
 958         return MAXVIFS;
 959 }
 960
 961 /*
 962   pim_if_add_vif() uses ifindex as vif_index
 963
 964   see also pim_if_find_vifindex_by_ifindex()
 965  */
 966 int pim_if_add_vif(struct interface *ifp, bool ispimreg, bool is_vxlan_term)
 967 {
 968         struct pim_interface *pim_ifp = ifp->info;
 969         pim_addr ifaddr;
 970         unsigned char flags = 0;
 971
 972         assert(pim_ifp);
 973
 974         if (pim_ifp->mroute_vif_index > 0) {
 975                 zlog_warn("%s: vif_index=%d > 0 on interface %s ifindex=%d",
 976                           __func__, pim_ifp->mroute_vif_index, ifp->name,
 977                           ifp->ifindex);
 978                 return -1;
 979         }
 980
 981         if (ifp->ifindex < 0) {
 982                 zlog_warn("%s: ifindex=%d < 0 on interface %s", __func__,
 983                           ifp->ifindex, ifp->name);
 984                 return -2;
 985         } else if ((ifp->ifindex == PIM_OIF_PIM_REGISTER_VIF) &&
 986                    ((strncmp(ifp->name, "pimreg", 6)) &&
 987                     (strncmp(ifp->name, "pim6reg", 7)))) {
 988                 zlog_warn("%s: ifindex=%d on interface %s", __func__,
 989                           ifp->ifindex, ifp->name);
 990                 return -2;
 991         }
 992
 993         ifaddr = pim_ifp->primary_address;
 994 #if PIM_IPV != 6
 995         /* IPv6 API is always by interface index */
 996         if (!ispimreg && !is_vxlan_term && pim_addr_is_any(ifaddr)) {
 997                 zlog_warn(
 998                         "%s: could not get address for interface %s ifindex=%d",
 999                         __func__, ifp->name, ifp->ifindex);
1000                 return -4;
1001         }
1002 #endif
1003
1004         pim_ifp->mroute_vif_index = pim_iface_next_vif_index(ifp);
1005
1006         if (pim_ifp->mroute_vif_index >= MAXVIFS) {
1007                 zlog_warn(
1008                         "%s: Attempting to configure more than MAXVIFS=%d on pim enabled interface %s",
1009                         __func__, MAXVIFS, ifp->name);
1010                 return -3;
1011         }
1012
1013         if (ifp->ifindex == PIM_OIF_PIM_REGISTER_VIF)
1014                 flags = VIFF_REGISTER;
1015 #ifdef VIFF_USE_IFINDEX
1016         else
1017                 flags = VIFF_USE_IFINDEX;
1018 #endif
1019
1020         if (pim_mroute_add_vif(ifp, ifaddr, flags)) {
1021                 /* pim_mroute_add_vif reported error */
1022                 return -5;
1023         }
1024
1025         pim_ifp->pim->iface_vif_index[pim_ifp->mroute_vif_index] = 1;
1026
1027         if (!ispimreg)
1028                 gm_ifp_update(ifp);
1029
1030         /* if the device qualifies as pim_vxlan iif/oif update vxlan entries */
1031         pim_vxlan_add_vif(ifp);
1032         return 0;
1033 }
1034
1035 int pim_if_del_vif(struct interface *ifp)
1036 {
1037         struct pim_interface *pim_ifp = ifp->info;
1038
1039         if (pim_ifp->mroute_vif_index < 1) {
1040                 zlog_warn("%s: vif_index=%d < 1 on interface %s ifindex=%d",
1041                           __func__, pim_ifp->mroute_vif_index, ifp->name,
1042                           ifp->ifindex);
1043                 return -1;
1044         }
1045
1046         /* if the device was a pim_vxlan iif/oif update vxlan mroute entries */
1047         pim_vxlan_del_vif(ifp);
1048
1049         gm_ifp_teardown(ifp);
1050
1051         pim_mroute_del_vif(ifp);
1052
1053         /*
1054           Update vif_index
1055          */
1056         pim_ifp->pim->iface_vif_index[pim_ifp->mroute_vif_index] = 0;
1057
1058         pim_ifp->mroute_vif_index = -1;
1059         return 0;
1060 }
1061
1062 // DBS - VRF Revist
1063 struct interface *pim_if_find_by_vif_index(struct pim_instance *pim,
1064                                            ifindex_t vif_index)
1065 {
1066         struct interface *ifp;
1067
1068         FOR_ALL_INTERFACES (pim->vrf, ifp) {
1069                 if (ifp->info) {
1070                         struct pim_interface *pim_ifp;
1071                         pim_ifp = ifp->info;
1072
1073                         if (vif_index == pim_ifp->mroute_vif_index)
1074                                 return ifp;
1075                 }
1076         }
1077
1078         return 0;
1079 }
1080
1081 /*
1082   pim_if_add_vif() uses ifindex as vif_index
1083  */
1084 int pim_if_find_vifindex_by_ifindex(struct pim_instance *pim, ifindex_t ifindex)
1085 {
1086         struct pim_interface *pim_ifp;
1087         struct interface *ifp;
1088
1089         ifp = if_lookup_by_index(ifindex, pim->vrf->vrf_id);
1090         if (!ifp || !ifp->info)
1091                 return -1;
1092         pim_ifp = ifp->info;
1093
1094         return pim_ifp->mroute_vif_index;
1095 }
1096
1097 int pim_if_lan_delay_enabled(struct interface *ifp)
1098 {
1099         struct pim_interface *pim_ifp;
1100
1101         pim_ifp = ifp->info;
1102         assert(pim_ifp);
1103         assert(pim_ifp->pim_number_of_nonlandelay_neighbors >= 0);
1104
1105         return pim_ifp->pim_number_of_nonlandelay_neighbors == 0;
1106 }
1107
1108 uint16_t pim_if_effective_propagation_delay_msec(struct interface *ifp)
1109 {
1110         if (pim_if_lan_delay_enabled(ifp)) {
1111                 struct pim_interface *pim_ifp;
1112                 pim_ifp = ifp->info;
1113                 return pim_ifp->pim_neighbors_highest_propagation_delay_msec;
1114         } else {
1115                 return PIM_DEFAULT_PROPAGATION_DELAY_MSEC;
1116         }
1117 }
1118
1119 uint16_t pim_if_effective_override_interval_msec(struct interface *ifp)
1120 {
1121         if (pim_if_lan_delay_enabled(ifp)) {
1122                 struct pim_interface *pim_ifp;
1123                 pim_ifp = ifp->info;
1124                 return pim_ifp->pim_neighbors_highest_override_interval_msec;
1125         } else {
1126                 return PIM_DEFAULT_OVERRIDE_INTERVAL_MSEC;
1127         }
1128 }
1129
1130 int pim_if_t_override_msec(struct interface *ifp)
1131 {
1132         int effective_override_interval_msec;
1133         int t_override_msec;
1134
1135         effective_override_interval_msec =
1136                 pim_if_effective_override_interval_msec(ifp);
1137
1138         t_override_msec =
1139                 frr_weak_random() % (effective_override_interval_msec + 1);
1140
1141         return t_override_msec;
1142 }
1143
1144 uint16_t pim_if_jp_override_interval_msec(struct interface *ifp)
1145 {
1146         return pim_if_effective_propagation_delay_msec(ifp)
1147                + pim_if_effective_override_interval_msec(ifp);
1148 }
1149
1150 /*
1151   RFC 4601: 4.1.6.  State Summarization Macros
1152
1153   The function NBR( I, A ) uses information gathered through PIM Hello
1154   messages to map the IP address A of a directly connected PIM
1155   neighbor router on interface I to the primary IP address of the same
1156   router (Section 4.3.4).  The primary IP address of a neighbor is the
1157   address that it uses as the source of its PIM Hello messages.
1158 */
1159 struct pim_neighbor *pim_if_find_neighbor(struct interface *ifp, pim_addr addr)
1160 {
1161         struct listnode *neighnode;
1162         struct pim_neighbor *neigh;
1163         struct pim_interface *pim_ifp;
1164         struct prefix p;
1165
1166         assert(ifp);
1167
1168         pim_ifp = ifp->info;
1169         if (!pim_ifp) {
1170                 zlog_warn("%s: multicast not enabled on interface %s", __func__,
1171                           ifp->name);
1172                 return 0;
1173         }
1174
1175         pim_addr_to_prefix(&p, addr);
1176
1177         for (ALL_LIST_ELEMENTS_RO(pim_ifp->pim_neighbor_list, neighnode,
1178                                   neigh)) {
1179
1180                 /* primary address ? */
1181                 if (!pim_addr_cmp(neigh->source_addr, addr))
1182                         return neigh;
1183
1184                 /* secondary address ? */
1185                 if (pim_neighbor_find_secondary(neigh, &p))
1186                         return neigh;
1187         }
1188
1189         if (PIM_DEBUG_PIM_TRACE)
1190                 zlog_debug(
1191                         "%s: neighbor not found for address %pPA on interface %s",
1192                         __func__, &addr, ifp->name);
1193
1194         return NULL;
1195 }
1196
1197 long pim_if_t_suppressed_msec(struct interface *ifp)
1198 {
1199         struct pim_interface *pim_ifp;
1200         long t_suppressed_msec;
1201         uint32_t ramount = 0;
1202
1203         pim_ifp = ifp->info;
1204         assert(pim_ifp);
1205
1206         /* join suppression disabled ? */
1207         if (pim_ifp->pim_can_disable_join_suppression)
1208                 return 0;
1209
1210         /* t_suppressed = t_periodic * rand(1.1, 1.4) */
1211         ramount = 1100 + (frr_weak_random() % (1400 - 1100 + 1));
1212         t_suppressed_msec = router->t_periodic * ramount;
1213
1214         return t_suppressed_msec;
1215 }
1216
1217 static void gm_join_free(struct gm_join *ij)
1218 {
1219         XFREE(MTYPE_PIM_IGMP_JOIN, ij);
1220 }
1221
1222 static struct gm_join *gm_join_find(struct list *join_list, pim_addr group_addr,
1223                                     pim_addr source_addr)
1224 {
1225         struct listnode *node;
1226         struct gm_join *ij;
1227
1228         assert(join_list);
1229
1230         for (ALL_LIST_ELEMENTS_RO(join_list, node, ij)) {
1231                 if ((!pim_addr_cmp(group_addr, ij->group_addr)) &&
1232                     (!pim_addr_cmp(source_addr, ij->source_addr)))
1233                         return ij;
1234         }
1235
1236         return 0;
1237 }
1238
1239 static int gm_join_sock(const char *ifname, ifindex_t ifindex,
1240                         pim_addr group_addr, pim_addr source_addr,
1241                         struct pim_interface *pim_ifp)
1242 {
1243         int join_fd;
1244
1245         pim_ifp->igmp_ifstat_joins_sent++;
1246
1247         join_fd = pim_socket_raw(IPPROTO_GM);
1248         if (join_fd < 0) {
1249                 pim_ifp->igmp_ifstat_joins_failed++;
1250                 return -1;
1251         }
1252
1253         if (pim_gm_join_source(join_fd, ifindex, group_addr, source_addr)) {
1254                 zlog_warn(
1255                         "%s: setsockopt(fd=%d) failure for " GM
1256                         " group %pPAs source %pPAs ifindex %d on interface %s: errno=%d: %s",
1257                         __func__, join_fd, &group_addr, &source_addr, ifindex,
1258                         ifname, errno, safe_strerror(errno));
1259
1260                 pim_ifp->igmp_ifstat_joins_failed++;
1261
1262                 close(join_fd);
1263                 return -2;
1264         }
1265
1266         return join_fd;
1267 }
1268
1269 static struct gm_join *gm_join_new(struct interface *ifp, pim_addr group_addr,
1270                                    pim_addr source_addr)
1271 {
1272         struct pim_interface *pim_ifp;
1273         struct gm_join *ij;
1274         int join_fd;
1275
1276         pim_ifp = ifp->info;
1277         assert(pim_ifp);
1278
1279         join_fd = gm_join_sock(ifp->name, ifp->ifindex, group_addr, source_addr,
1280                                pim_ifp);
1281         if (join_fd < 0) {
1282                 zlog_warn("%s: gm_join_sock() failure for " GM
1283                           " group %pPAs source %pPAs on interface %s",
1284                           __func__, &group_addr, &source_addr, ifp->name);
1285                 return 0;
1286         }
1287
1288         ij = XCALLOC(MTYPE_PIM_IGMP_JOIN, sizeof(*ij));
1289
1290         ij->sock_fd = join_fd;
1291         ij->group_addr = group_addr;
1292         ij->source_addr = source_addr;
1293         ij->sock_creation = pim_time_monotonic_sec();
1294
1295         listnode_add(pim_ifp->gm_join_list, ij);
1296
1297         return ij;
1298 }
1299
1300 ferr_r pim_if_gm_join_add(struct interface *ifp, pim_addr group_addr,
1301                           pim_addr source_addr)
1302 {
1303         struct pim_interface *pim_ifp;
1304         struct gm_join *ij;
1305
1306         pim_ifp = ifp->info;
1307         if (!pim_ifp) {
1308                 return ferr_cfg_invalid("multicast not enabled on interface %s",
1309                                         ifp->name);
1310         }
1311
1312         if (!pim_ifp->gm_join_list) {
1313                 pim_ifp->gm_join_list = list_new();
1314                 pim_ifp->gm_join_list->del = (void (*)(void *))gm_join_free;
1315         }
1316
1317         ij = gm_join_find(pim_ifp->gm_join_list, group_addr, source_addr);
1318
1319         /* This interface has already been configured to join this IGMP/MLD
1320          * group
1321          */
1322         if (ij) {
1323                 return ferr_ok();
1324         }
1325
1326         (void)gm_join_new(ifp, group_addr, source_addr);
1327
1328         if (PIM_DEBUG_GM_EVENTS) {
1329                 zlog_debug(
1330                         "%s: issued static " GM
1331                         " join for channel (S,G)=(%pPA,%pPA) on interface %s",
1332                         __func__, &source_addr, &group_addr, ifp->name);
1333         }
1334
1335         return ferr_ok();
1336 }
1337
1338 int pim_if_gm_join_del(struct interface *ifp, pim_addr group_addr,
1339                        pim_addr source_addr)
1340 {
1341         struct pim_interface *pim_ifp;
1342         struct gm_join *ij;
1343
1344         pim_ifp = ifp->info;
1345         if (!pim_ifp) {
1346                 zlog_warn("%s: multicast not enabled on interface %s", __func__,
1347                           ifp->name);
1348                 return -1;
1349         }
1350
1351         if (!pim_ifp->gm_join_list) {
1352                 zlog_warn("%s: no " GM " join on interface %s", __func__,
1353                           ifp->name);
1354                 return -2;
1355         }
1356
1357         ij = gm_join_find(pim_ifp->gm_join_list, group_addr, source_addr);
1358         if (!ij) {
1359                 zlog_warn("%s: could not find " GM
1360                           " group %pPAs source %pPAs on interface %s",
1361                           __func__, &group_addr, &source_addr, ifp->name);
1362                 return -3;
1363         }
1364
1365         if (close(ij->sock_fd)) {
1366                 zlog_warn(
1367                         "%s: failure closing sock_fd=%d for " GM
1368                         " group %pPAs source %pPAs on interface %s: errno=%d: %s",
1369                         __func__, ij->sock_fd, &group_addr, &source_addr,
1370                         ifp->name, errno, safe_strerror(errno));
1371                 /* warning only */
1372         }
1373         listnode_delete(pim_ifp->gm_join_list, ij);
1374         gm_join_free(ij);
1375         if (listcount(pim_ifp->gm_join_list) < 1) {
1376                 list_delete(&pim_ifp->gm_join_list);
1377                 pim_ifp->gm_join_list = 0;
1378         }
1379
1380         return 0;
1381 }
1382
1383 #if PIM_IPV == 4
1384 __attribute__((unused))
1385 static void pim_if_igmp_join_del_all(struct interface *ifp)
1386 {
1387         struct pim_interface *pim_ifp;
1388         struct listnode *node;
1389         struct listnode *nextnode;
1390         struct gm_join *ij;
1391
1392         pim_ifp = ifp->info;
1393         if (!pim_ifp) {
1394                 zlog_warn("%s: multicast not enabled on interface %s", __func__,
1395                           ifp->name);
1396                 return;
1397         }
1398
1399         if (!pim_ifp->gm_join_list)
1400                 return;
1401
1402         for (ALL_LIST_ELEMENTS(pim_ifp->gm_join_list, node, nextnode, ij))
1403                 pim_if_gm_join_del(ifp, ij->group_addr, ij->source_addr);
1404 }
1405 #endif /* PIM_IPV == 4 */
1406
1407 /*
1408   RFC 4601
1409
1410   Transitions from "I am Assert Loser" State
1411
1412   Current Winner's GenID Changes or NLT Expires
1413
1414   The Neighbor Liveness Timer associated with the current winner
1415   expires or we receive a Hello message from the current winner
1416   reporting a different GenID from the one it previously reported.
1417   This indicates that the current winner's interface or router has
1418   gone down (and may have come back up), and so we must assume it no
1419   longer knows it was the winner.
1420  */
1421 void pim_if_assert_on_neighbor_down(struct interface *ifp, pim_addr neigh_addr)
1422 {
1423         struct pim_interface *pim_ifp;
1424         struct pim_ifchannel *ch;
1425
1426         pim_ifp = ifp->info;
1427         assert(pim_ifp);
1428
1429         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
1430                 /* Is (S,G,I) assert loser ? */
1431                 if (ch->ifassert_state != PIM_IFASSERT_I_AM_LOSER)
1432                         continue;
1433                 /* Dead neighbor was winner ? */
1434                 if (pim_addr_cmp(ch->ifassert_winner, neigh_addr))
1435                         continue;
1436
1437                 assert_action_a5(ch);
1438         }
1439 }
1440
1441 void pim_if_update_join_desired(struct pim_interface *pim_ifp)
1442 {
1443         struct pim_ifchannel *ch;
1444
1445         /* clear off flag from interface's upstreams */
1446         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
1447                 PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED_UPDATED(
1448                         ch->upstream->flags);
1449         }
1450
1451         /* scan per-interface (S,G,I) state on this I interface */
1452         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
1453                 struct pim_upstream *up = ch->upstream;
1454
1455                 if (PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED_UPDATED(up->flags))
1456                         continue;
1457
1458                 /* update join_desired for the global (S,G) state */
1459                 pim_upstream_update_join_desired(pim_ifp->pim, up);
1460                 PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED_UPDATED(up->flags);
1461         }
1462 }
1463
1464 void pim_if_update_assert_tracking_desired(struct interface *ifp)
1465 {
1466         struct pim_interface *pim_ifp;
1467         struct pim_ifchannel *ch;
1468
1469         pim_ifp = ifp->info;
1470         if (!pim_ifp)
1471                 return;
1472
1473         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
1474                 pim_ifchannel_update_assert_tracking_desired(ch);
1475         }
1476 }
1477
1478 /*
1479  * PIM wants to have an interface pointer for everything it does.
1480  * The pimreg is a special interface that we have that is not
1481  * quite an interface but a VIF is created for it.
1482  */
1483 void pim_if_create_pimreg(struct pim_instance *pim)
1484 {
1485         char pimreg_name[INTERFACE_NAMSIZ];
1486
1487         if (!pim->regiface) {
1488                 if (pim->vrf->vrf_id == VRF_DEFAULT)
1489                         strlcpy(pimreg_name, PIMREG, sizeof(pimreg_name));
1490                 else
1491                         snprintf(pimreg_name, sizeof(pimreg_name), PIMREG "%u",
1492                                  pim->vrf->data.l.table_id);
1493
1494                 pim->regiface = if_get_by_name(pimreg_name, pim->vrf->vrf_id,
1495                                                pim->vrf->name);
1496                 pim->regiface->ifindex = PIM_OIF_PIM_REGISTER_VIF;
1497
1498                 if (!pim->regiface->info)
1499                         pim_if_new(pim->regiface, false, false, true,
1500                                    false /*vxlan_term*/);
1501
1502                 /*
1503                  * On vrf moves we delete the interface if there
1504                  * is nothing going on with it.  We cannot have
1505                  * the pimregiface deleted.
1506                  */
1507                 pim->regiface->configured = true;
1508
1509         }
1510 }
1511
1512 struct prefix *pim_if_connected_to_source(struct interface *ifp, pim_addr src)
1513 {
1514         struct listnode *cnode;
1515         struct connected *c;
1516         struct prefix p;
1517
1518         if (!ifp)
1519                 return NULL;
1520
1521         pim_addr_to_prefix(&p, src);
1522
1523         for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
1524                 if (c->address->family != PIM_AF)
1525                         continue;
1526                 if (prefix_match(c->address, &p))
1527                         return c->address;
1528                 if (CONNECTED_PEER(c) && prefix_match(c->destination, &p))
1529                         /* this is not a typo, on PtP we need to return the
1530                          * *local* address that lines up with src.
1531                          */
1532                         return c->address;
1533         }
1534
1535         return NULL;
1536 }
1537
1538 bool pim_if_is_vrf_device(struct interface *ifp)
1539 {
1540         if (if_is_vrf(ifp))
1541                 return true;
1542
1543         return false;
1544 }
1545
1546 int pim_if_ifchannel_count(struct pim_interface *pim_ifp)
1547 {
1548         struct pim_ifchannel *ch;
1549         int count = 0;
1550
1551         RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
1552                 count++;
1553         }
1554
1555         return count;
1556 }
1557
1558 static int pim_ifp_create(struct interface *ifp)
1559 {
1560         struct pim_instance *pim;
1561
1562         pim = ifp->vrf->info;
1563         if (PIM_DEBUG_ZEBRA) {
1564                 zlog_debug(
1565                         "%s: %s index %d vrf %s(%u) flags %ld metric %d mtu %d operative %d",
1566                         __func__, ifp->name, ifp->ifindex, ifp->vrf->name,
1567                         ifp->vrf->vrf_id, (long)ifp->flags, ifp->metric,
1568                         ifp->mtu, if_is_operative(ifp));
1569         }
1570
1571         if (if_is_operative(ifp)) {
1572                 struct pim_interface *pim_ifp;
1573
1574                 pim_ifp = ifp->info;
1575                 /*
1576                  * If we have a pim_ifp already and this is an if_add
1577                  * that means that we probably have a vrf move event
1578                  * If that is the case, set the proper vrfness.
1579                  */
1580                 if (pim_ifp)
1581                         pim_ifp->pim = pim;
1582                 pim_if_addr_add_all(ifp);
1583
1584                 /*
1585                  * Due to ordering issues based upon when
1586                  * a command is entered we should ensure that
1587                  * the pim reg is created for this vrf if we
1588                  * have configuration for it already.
1589                  *
1590                  * this is a no-op if it's already been done.
1591                  */
1592                 pim_if_create_pimreg(pim);
1593         }
1594
1595 #if PIM_IPV == 4
1596         /*
1597          * If we are a vrf device that is up, open up the pim_socket for
1598          * listening
1599          * to incoming pim messages irrelevant if the user has configured us
1600          * for pim or not.
1601          */
1602         if (pim_if_is_vrf_device(ifp)) {
1603                 struct pim_interface *pim_ifp;
1604
1605                 if (!ifp->info) {
1606                         pim_ifp = pim_if_new(ifp, false, false, false,
1607                                              false /*vxlan_term*/);
1608                         ifp->info = pim_ifp;
1609                 }
1610
1611                 pim_sock_add(ifp);
1612         }
1613
1614         if (!strncmp(ifp->name, PIM_VXLAN_TERM_DEV_NAME,
1615                      sizeof(PIM_VXLAN_TERM_DEV_NAME))) {
1616                 if (pim->mcast_if_count < MAXVIFS)
1617                         pim_vxlan_add_term_dev(pim, ifp);
1618                 else
1619                         zlog_warn(
1620                                 "%s: Cannot enable pim on %s. MAXVIFS(%d) reached. Deleting and readding the vxlan termimation device after unconfiguring pim from other interfaces may succeed.",
1621                                 __func__, ifp->name, MAXVIFS);
1622         }
1623 #endif
1624
1625         return 0;
1626 }
1627
1628 static int pim_ifp_up(struct interface *ifp)
1629 {
1630         uint32_t table_id;
1631         struct pim_interface *pim_ifp;
1632         struct pim_instance *pim;
1633
1634         if (PIM_DEBUG_ZEBRA) {
1635                 zlog_debug(
1636                         "%s: %s index %d vrf %s(%u) flags %ld metric %d mtu %d operative %d",
1637                         __func__, ifp->name, ifp->ifindex, ifp->vrf->name,
1638                         ifp->vrf->vrf_id, (long)ifp->flags, ifp->metric,
1639                         ifp->mtu, if_is_operative(ifp));
1640         }
1641
1642         pim = ifp->vrf->info;
1643
1644         pim_ifp = ifp->info;
1645         /*
1646          * If we have a pim_ifp already and this is an if_add
1647          * that means that we probably have a vrf move event
1648          * If that is the case, set the proper vrfness.
1649          */
1650         if (pim_ifp)
1651                 pim_ifp->pim = pim;
1652
1653         /*
1654           pim_if_addr_add_all() suffices for bringing up both IGMP and
1655           PIM
1656         */
1657         pim_if_addr_add_all(ifp);
1658
1659         /*
1660          * If we have a pimreg device callback and it's for a specific
1661          * table set the master appropriately
1662          */
1663         if (sscanf(ifp->name, "" PIMREG "%" SCNu32, &table_id) == 1) {
1664                 struct vrf *vrf;
1665                 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1666                         if ((table_id == vrf->data.l.table_id)
1667                             && (ifp->vrf->vrf_id != vrf->vrf_id)) {
1668                                 struct interface *master = if_lookup_by_name(
1669                                         vrf->name, vrf->vrf_id);
1670
1671                                 if (!master) {
1672                                         zlog_debug(
1673                                                 "%s: Unable to find Master interface for %s",
1674                                                 __func__, vrf->name);
1675                                         return 0;
1676                                 }
1677                                 pim_zebra_interface_set_master(master, ifp);
1678                         }
1679                 }
1680         }
1681         return 0;
1682 }
1683
1684 static int pim_ifp_down(struct interface *ifp)
1685 {
1686         if (PIM_DEBUG_ZEBRA) {
1687                 zlog_debug(
1688                         "%s: %s index %d vrf %s(%u) flags %ld metric %d mtu %d operative %d",
1689                         __func__, ifp->name, ifp->ifindex, ifp->vrf->name,
1690                         ifp->vrf->vrf_id, (long)ifp->flags, ifp->metric,
1691                         ifp->mtu, if_is_operative(ifp));
1692         }
1693
1694         if (!if_is_operative(ifp)) {
1695                 pim_ifchannel_delete_all(ifp);
1696                 /*
1697                   pim_if_addr_del_all() suffices for shutting down IGMP,
1698                   but not for shutting down PIM
1699                 */
1700                 pim_if_addr_del_all(ifp);
1701
1702                 /*
1703                   pim_sock_delete() closes the socket, stops read and timer
1704                   threads,
1705                   and kills all neighbors.
1706                 */
1707                 if (ifp->info) {
1708                         pim_sock_delete(ifp, "link down");
1709                 }
1710         }
1711
1712         if (ifp->info) {
1713                 pim_if_del_vif(ifp);
1714                 pim_ifstat_reset(ifp);
1715         }
1716
1717         return 0;
1718 }
1719
1720 static int pim_ifp_destroy(struct interface *ifp)
1721 {
1722         if (PIM_DEBUG_ZEBRA) {
1723                 zlog_debug(
1724                         "%s: %s index %d vrf %s(%u) flags %ld metric %d mtu %d operative %d",
1725                         __func__, ifp->name, ifp->ifindex, ifp->vrf->name,
1726                         ifp->vrf->vrf_id, (long)ifp->flags, ifp->metric,
1727                         ifp->mtu, if_is_operative(ifp));
1728         }
1729
1730         if (!if_is_operative(ifp))
1731                 pim_if_addr_del_all(ifp);
1732
1733 #if PIM_IPV == 4
1734         struct pim_instance *pim;
1735
1736         pim = ifp->vrf->info;
1737         if (pim && pim->vxlan.term_if == ifp)
1738                 pim_vxlan_del_term_dev(pim);
1739 #endif
1740
1741         return 0;
1742 }
1743
1744 static int pim_if_new_hook(struct interface *ifp)
1745 {
1746         return 0;
1747 }
1748
1749 static int pim_if_delete_hook(struct interface *ifp)
1750 {
1751         if (ifp->info)
1752                 pim_if_delete(ifp);
1753
1754         return 0;
1755 }
1756
1757 void pim_iface_init(void)
1758 {
1759         hook_register_prio(if_add, 0, pim_if_new_hook);
1760         hook_register_prio(if_del, 0, pim_if_delete_hook);
1761
1762         if_zapi_callbacks(pim_ifp_create, pim_ifp_up, pim_ifp_down,
1763                           pim_ifp_destroy);
1764 }