pimd/pim_mroute.c

   1 /*
   2  * PIM for Quagga
   3  * Copyright (C) 2008  Everton da Silva Marques
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21 #include "log.h"
  22 #include "privs.h"
  23 #include "if.h"
  24 #include "prefix.h"
  25 #include "vty.h"
  26 #include "plist.h"
  27 #include "sockopt.h"
  28 #include "lib_errors.h"
  29
  30 #include "pimd.h"
  31 #include "pim_rpf.h"
  32 #include "pim_mroute.h"
  33 #include "pim_oil.h"
  34 #include "pim_str.h"
  35 #include "pim_time.h"
  36 #include "pim_iface.h"
  37 #include "pim_macro.h"
  38 #include "pim_rp.h"
  39 #include "pim_oil.h"
  40 #include "pim_register.h"
  41 #include "pim_ifchannel.h"
  42 #include "pim_zlookup.h"
  43 #include "pim_ssm.h"
  44 #include "pim_sock.h"
  45
  46 static void mroute_read_on(struct pim_instance *pim);
  47
  48 static int pim_mroute_set(struct pim_instance *pim, int enable)
  49 {
  50         int err;
  51         int opt, data;
  52         socklen_t data_len = sizeof(data);
  53         long flags;
  54
  55         /*
  56          * We need to create the VRF table for the pim mroute_socket
  57          */
  58         if (pim->vrf_id != VRF_DEFAULT) {
  59                 frr_elevate_privs(&pimd_privs) {
  60
  61                         data = pim->vrf->data.l.table_id;
  62                         err = setsockopt(pim->mroute_socket, IPPROTO_IP,
  63                                          MRT_TABLE,
  64                                          &data, data_len);
  65                         if (err) {
  66                                 zlog_warn(
  67                                           "%s %s: failure: setsockopt(fd=%d,IPPROTO_IP, MRT_TABLE=%d): errno=%d: %s",
  68                                           __FILE__, __PRETTY_FUNCTION__,
  69                                           pim->mroute_socket, data, errno,
  70                                           safe_strerror(errno));
  71                                 return -1;
  72                         }
  73
  74                 }
  75         }
  76
  77         frr_elevate_privs(&pimd_privs) {
  78                 opt = enable ? MRT_INIT : MRT_DONE;
  79                 /*
  80                  * *BSD *cares* about what value we pass down
  81                  * here
  82                  */
  83                 data = 1;
  84                 err = setsockopt(pim->mroute_socket, IPPROTO_IP,
  85                                  opt, &data, data_len);
  86                 if (err) {
  87                         zlog_warn(
  88                                   "%s %s: failure: setsockopt(fd=%d,IPPROTO_IP,%s=%d): errno=%d: %s",
  89                                   __FILE__, __PRETTY_FUNCTION__,
  90                                   pim->mroute_socket,
  91                                   enable ? "MRT_INIT" : "MRT_DONE", data, errno,
  92                                   safe_strerror(errno));
  93                         return -1;
  94                 }
  95         }
  96
  97 #if defined(HAVE_IP_PKTINFO)
  98         if (enable) {
  99                 /* Linux and Solaris IP_PKTINFO */
 100                 data = 1;
 101                 if (setsockopt(pim->mroute_socket, IPPROTO_IP, IP_PKTINFO,
 102                                &data, data_len)) {
 103                         zlog_warn(
 104                                 "Could not set IP_PKTINFO on socket fd=%d: errno=%d: %s",
 105                                 pim->mroute_socket, errno,
 106                                 safe_strerror(errno));
 107                 }
 108         }
 109 #endif
 110
 111         setsockopt_so_recvbuf(pim->mroute_socket, 1024 * 1024 * 8);
 112
 113         flags = fcntl(pim->mroute_socket, F_GETFL, 0);
 114         if (flags < 0) {
 115                 zlog_warn("Could not get flags on socket fd:%d %d %s",
 116                           pim->mroute_socket, errno, safe_strerror(errno));
 117                 close(pim->mroute_socket);
 118                 return -1;
 119         }
 120         if (fcntl(pim->mroute_socket, F_SETFL, flags | O_NONBLOCK)) {
 121                 zlog_warn("Could not set O_NONBLOCK on socket fd:%d %d %s",
 122                           pim->mroute_socket, errno, safe_strerror(errno));
 123                 close(pim->mroute_socket);
 124                 return -1;
 125         }
 126
 127         if (enable) {
 128 #if defined linux
 129                 int upcalls = IGMPMSG_WRVIFWHOLE;
 130                 opt = MRT_PIM;
 131
 132                 err = setsockopt(pim->mroute_socket, IPPROTO_IP, opt, &upcalls,
 133                                  sizeof(upcalls));
 134                 if (err) {
 135                         zlog_warn(
 136                                 "Failure to register for VIFWHOLE and WRONGVIF upcalls %d %s",
 137                                 errno, safe_strerror(errno));
 138                         return -1;
 139                 }
 140 #else
 141                 zlog_warn(
 142                         "PIM-SM will not work properly on this platform, until the ability to receive the WRVIFWHOLE upcall");
 143 #endif
 144         }
 145
 146         return 0;
 147 }
 148
 149 static const char *igmpmsgtype2str[IGMPMSG_WRVIFWHOLE + 1] = {
 150         "<unknown_upcall?>", "NOCACHE", "WRONGVIF", "WHOLEPKT", "WRVIFWHOLE"};
 151
 152 static int pim_mroute_msg_nocache(int fd, struct interface *ifp,
 153                                   const struct igmpmsg *msg)
 154 {
 155         struct pim_interface *pim_ifp = ifp->info;
 156         struct pim_upstream *up;
 157         struct pim_rpf *rpg;
 158         struct prefix_sg sg;
 159
 160         rpg = pim_ifp ? RP(pim_ifp->pim, msg->im_dst) : NULL;
 161         /*
 162          * If the incoming interface is unknown OR
 163          * the Interface type is SSM we don't need to
 164          * do anything here
 165          */
 166         if (!rpg || pim_rpf_addr_is_inaddr_none(rpg)) {
 167                 if (PIM_DEBUG_MROUTE_DETAIL)
 168                         zlog_debug(
 169                                 "%s: Interface is not configured correctly to handle incoming packet: Could be !pim_ifp, !SM, !RP",
 170                                 __PRETTY_FUNCTION__);
 171
 172                 return 0;
 173         }
 174
 175         /*
 176          * If we've received a multicast packet that isn't connected to
 177          * us
 178          */
 179         if (!pim_if_connected_to_source(ifp, msg->im_src)) {
 180                 if (PIM_DEBUG_MROUTE_DETAIL)
 181                         zlog_debug(
 182                                 "%s: Received incoming packet that doesn't originate on our seg",
 183                                 __PRETTY_FUNCTION__);
 184                 return 0;
 185         }
 186
 187         memset(&sg, 0, sizeof(struct prefix_sg));
 188         sg.src = msg->im_src;
 189         sg.grp = msg->im_dst;
 190
 191         if (!(PIM_I_am_DR(pim_ifp))) {
 192                 struct channel_oil *c_oil;
 193
 194                 if (PIM_DEBUG_MROUTE_DETAIL)
 195                         zlog_debug("%s: Interface is not the DR blackholing incoming traffic for %s",
 196                                    __PRETTY_FUNCTION__, pim_str_sg_dump(&sg));
 197
 198                 /*
 199                  * We are not the DR, but we are still receiving packets
 200                  * Let's blackhole those packets for the moment
 201                  * As that they will be coming up to the cpu
 202                  * and causing us to consider them.
 203                  */
 204                 c_oil = pim_channel_oil_add(pim_ifp->pim, &sg,
 205                                             pim_ifp->mroute_vif_index);
 206                 pim_mroute_add(c_oil, __PRETTY_FUNCTION__);
 207
 208                 return 0;
 209         }
 210
 211         up = pim_upstream_find_or_add(&sg, ifp, PIM_UPSTREAM_FLAG_MASK_FHR,
 212                                       __PRETTY_FUNCTION__);
 213         if (!up) {
 214                 if (PIM_DEBUG_MROUTE) {
 215                         zlog_debug(
 216                                 "%s: Failure to add upstream information for %s",
 217                                 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg));
 218                 }
 219                 return 0;
 220         }
 221
 222         /*
 223          * I moved this debug till after the actual add because
 224          * I want to take advantage of the up->sg_str being filled in.
 225          */
 226         if (PIM_DEBUG_MROUTE) {
 227                 zlog_debug("%s: Adding a Route %s for WHOLEPKT consumption",
 228                            __PRETTY_FUNCTION__, up->sg_str);
 229         }
 230
 231         PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
 232         pim_upstream_keep_alive_timer_start(up, pim_ifp->pim->keep_alive_time);
 233
 234         up->channel_oil->cc.pktcnt++;
 235         PIM_UPSTREAM_FLAG_SET_FHR(up->flags);
 236         // resolve mfcc_parent prior to mroute_add in channel_add_oif
 237         if (up->rpf.source_nexthop.interface &&
 238             up->channel_oil->oil.mfcc_parent >= MAXVIFS) {
 239                 int vif_index = 0;
 240                 vif_index = pim_if_find_vifindex_by_ifindex(
 241                         pim_ifp->pim,
 242                         up->rpf.source_nexthop.interface->ifindex);
 243                 up->channel_oil->oil.mfcc_parent = vif_index;
 244         }
 245         pim_register_join(up);
 246
 247         return 0;
 248 }
 249
 250 static int pim_mroute_msg_wholepkt(int fd, struct interface *ifp,
 251                                    const char *buf)
 252 {
 253         struct pim_interface *pim_ifp;
 254         struct prefix_sg sg;
 255         struct pim_rpf *rpg;
 256         const struct ip *ip_hdr;
 257         struct pim_upstream *up;
 258
 259         pim_ifp = ifp->info;
 260
 261         ip_hdr = (const struct ip *)buf;
 262
 263         memset(&sg, 0, sizeof(struct prefix_sg));
 264         sg.src = ip_hdr->ip_src;
 265         sg.grp = ip_hdr->ip_dst;
 266
 267         up = pim_upstream_find(pim_ifp->pim, &sg);
 268         if (!up) {
 269                 struct prefix_sg star = sg;
 270                 star.src.s_addr = INADDR_ANY;
 271
 272                 up = pim_upstream_find(pim_ifp->pim, &star);
 273
 274                 if (up && PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up->flags)) {
 275                         up = pim_upstream_add(pim_ifp->pim, &sg, ifp,
 276                                               PIM_UPSTREAM_FLAG_MASK_SRC_LHR,
 277                                               __PRETTY_FUNCTION__, NULL);
 278                         if (!up) {
 279                                 if (PIM_DEBUG_MROUTE)
 280                                         zlog_debug(
 281                                                 "%s: Unable to create upstream information for %s",
 282                                                 __PRETTY_FUNCTION__,
 283                                                 pim_str_sg_dump(&sg));
 284                                 return 0;
 285                         }
 286                         pim_upstream_keep_alive_timer_start(
 287                                 up, pim_ifp->pim->keep_alive_time);
 288                         pim_upstream_inherited_olist(pim_ifp->pim, up);
 289                         pim_upstream_switch(pim_ifp->pim, up,
 290                                             PIM_UPSTREAM_JOINED);
 291
 292                         if (PIM_DEBUG_MROUTE)
 293                                 zlog_debug("%s: Creating %s upstream on LHR",
 294                                            __PRETTY_FUNCTION__, up->sg_str);
 295                         return 0;
 296                 }
 297                 if (PIM_DEBUG_MROUTE_DETAIL) {
 298                         zlog_debug(
 299                                 "%s: Unable to find upstream channel WHOLEPKT%s",
 300                                 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg));
 301                 }
 302                 return 0;
 303         }
 304
 305         if (!up->rpf.source_nexthop.interface) {
 306                 if (PIM_DEBUG_TRACE)
 307                         zlog_debug("%s: up %s RPF is not present",
 308                                 __PRETTY_FUNCTION__, up->sg_str);
 309                 return 0;
 310         }
 311
 312         pim_ifp = up->rpf.source_nexthop.interface->info;
 313
 314         rpg = pim_ifp ? RP(pim_ifp->pim, sg.grp) : NULL;
 315
 316         if ((pim_rpf_addr_is_inaddr_none(rpg)) || (!pim_ifp)
 317             || (!(PIM_I_am_DR(pim_ifp)))) {
 318                 if (PIM_DEBUG_MROUTE) {
 319                         zlog_debug("%s: Failed Check send packet",
 320                                    __PRETTY_FUNCTION__);
 321                 }
 322                 return 0;
 323         }
 324
 325         /*
 326          * If we've received a register suppress
 327          */
 328         if (!up->t_rs_timer) {
 329                 if (pim_is_grp_ssm(pim_ifp->pim, sg.grp)) {
 330                         if (PIM_DEBUG_PIM_REG)
 331                                 zlog_debug(
 332                                         "%s register forward skipped as group is SSM",
 333                                         pim_str_sg_dump(&sg));
 334                         return 0;
 335                 }
 336                 pim_register_send((uint8_t *)buf + sizeof(struct ip),
 337                                   ntohs(ip_hdr->ip_len) - sizeof(struct ip),
 338                                   pim_ifp->primary_address, rpg, 0, up);
 339         }
 340         return 0;
 341 }
 342
 343 static int pim_mroute_msg_wrongvif(int fd, struct interface *ifp,
 344                                    const struct igmpmsg *msg)
 345 {
 346         struct pim_ifchannel *ch;
 347         struct pim_interface *pim_ifp;
 348         struct prefix_sg sg;
 349
 350         memset(&sg, 0, sizeof(struct prefix_sg));
 351         sg.src = msg->im_src;
 352         sg.grp = msg->im_dst;
 353
 354         /*
 355           Send Assert(S,G) on iif as response to WRONGVIF kernel upcall.
 356
 357           RFC 4601 4.8.2.  PIM-SSM-Only Routers
 358
 359           iif is the incoming interface of the packet.
 360           if (iif is in inherited_olist(S,G)) {
 361           send Assert(S,G) on iif
 362           }
 363         */
 364
 365         if (!ifp) {
 366                 if (PIM_DEBUG_MROUTE)
 367                         zlog_debug(
 368                                 "%s: WRONGVIF (S,G)=%s could not find input interface for input_vif_index=%d",
 369                                 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg),
 370                                 msg->im_vif);
 371                 return -1;
 372         }
 373
 374         pim_ifp = ifp->info;
 375         if (!pim_ifp) {
 376                 if (PIM_DEBUG_MROUTE)
 377                         zlog_debug(
 378                                 "%s: WRONGVIF (S,G)=%s multicast not enabled on interface %s",
 379                                 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg),
 380                                 ifp->name);
 381                 return -2;
 382         }
 383
 384         ch = pim_ifchannel_find(ifp, &sg);
 385         if (!ch) {
 386                 struct prefix_sg star_g = sg;
 387                 if (PIM_DEBUG_MROUTE)
 388                         zlog_debug(
 389                                 "%s: WRONGVIF (S,G)=%s could not find channel on interface %s",
 390                                 __PRETTY_FUNCTION__, pim_str_sg_dump(&sg),
 391                                 ifp->name);
 392
 393                 star_g.src.s_addr = INADDR_ANY;
 394                 ch = pim_ifchannel_find(ifp, &star_g);
 395                 if (!ch) {
 396                         if (PIM_DEBUG_MROUTE)
 397                                 zlog_debug(
 398                                         "%s: WRONGVIF (*,G)=%s could not find channel on interface %s",
 399                                         __PRETTY_FUNCTION__,
 400                                         pim_str_sg_dump(&star_g), ifp->name);
 401                         return -3;
 402                 }
 403         }
 404
 405         /*
 406           RFC 4601: 4.6.1.  (S,G) Assert Message State Machine
 407
 408           Transitions from NoInfo State
 409
 410           An (S,G) data packet arrives on interface I, AND
 411           CouldAssert(S,G,I)==TRUE An (S,G) data packet arrived on an
 412           downstream interface that is in our (S,G) outgoing interface
 413           list.  We optimistically assume that we will be the assert
 414           winner for this (S,G), and so we transition to the "I am Assert
 415           Winner" state and perform Actions A1 (below), which will
 416           initiate the assert negotiation for (S,G).
 417         */
 418
 419         if (ch->ifassert_state != PIM_IFASSERT_NOINFO) {
 420                 if (PIM_DEBUG_MROUTE) {
 421                         zlog_debug(
 422                                 "%s: WRONGVIF (S,G)=%s channel is not on Assert NoInfo state for interface %s",
 423                                 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
 424                 }
 425                 return -4;
 426         }
 427
 428         if (!PIM_IF_FLAG_TEST_COULD_ASSERT(ch->flags)) {
 429                 if (PIM_DEBUG_MROUTE) {
 430                         zlog_debug(
 431                                 "%s: WRONGVIF (S,G)=%s interface %s is not downstream for channel",
 432                                 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
 433                 }
 434                 return -5;
 435         }
 436
 437         if (assert_action_a1(ch)) {
 438                 if (PIM_DEBUG_MROUTE) {
 439                         zlog_debug(
 440                                 "%s: WRONGVIF (S,G)=%s assert_action_a1 failure on interface %s",
 441                                 __PRETTY_FUNCTION__, ch->sg_str, ifp->name);
 442                 }
 443                 return -6;
 444         }
 445
 446         return 0;
 447 }
 448
 449 static int pim_mroute_msg_wrvifwhole(int fd, struct interface *ifp,
 450                                      const char *buf)
 451 {
 452         const struct ip *ip_hdr = (const struct ip *)buf;
 453         struct pim_interface *pim_ifp;
 454         struct pim_ifchannel *ch;
 455         struct pim_upstream *up;
 456         struct prefix_sg star_g;
 457         struct prefix_sg sg;
 458         struct channel_oil *oil;
 459
 460         pim_ifp = ifp->info;
 461
 462         memset(&sg, 0, sizeof(struct prefix_sg));
 463         sg.src = ip_hdr->ip_src;
 464         sg.grp = ip_hdr->ip_dst;
 465
 466         ch = pim_ifchannel_find(ifp, &sg);
 467         if (ch) {
 468                 if (PIM_DEBUG_MROUTE)
 469                         zlog_debug(
 470                                 "WRVIFWHOLE (S,G)=%s found ifchannel on interface %s",
 471                                 ch->sg_str, ifp->name);
 472                 return -1;
 473         }
 474
 475         star_g = sg;
 476         star_g.src.s_addr = INADDR_ANY;
 477 #if 0
 478   ch = pim_ifchannel_find(ifp, &star_g);
 479   if (ch)
 480     {
 481       if (PIM_DEBUG_MROUTE)
 482         zlog_debug ("WRVIFWHOLE (*,G)=%s found ifchannel on interface %s",
 483                     pim_str_sg_dump (&star_g), ifp->name);
 484       return -1;
 485     }
 486 #endif
 487
 488         up = pim_upstream_find(pim_ifp->pim, &sg);
 489         if (up) {
 490                 struct pim_upstream *parent;
 491                 struct pim_nexthop source;
 492                 struct pim_rpf *rpf = RP(pim_ifp->pim, sg.grp);
 493                 if (!rpf || !rpf->source_nexthop.interface)
 494                         return 0;
 495
 496                 /*
 497                  * If we have received a WRVIFWHOLE and are at this
 498                  * point, we could be receiving the packet on the *,G
 499                  * tree, let's check and if so we can safely drop
 500                  * it.
 501                  */
 502                 parent = pim_upstream_find(pim_ifp->pim, &star_g);
 503                 if (parent && parent->rpf.source_nexthop.interface == ifp)
 504                         return 0;
 505
 506                 pim_ifp = rpf->source_nexthop.interface->info;
 507
 508                 memset(&source, 0, sizeof(source));
 509                 /*
 510                  * If we are the fhr that means we are getting a callback during
 511                  * the pimreg period, so I believe we can ignore this packet
 512                  */
 513                 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up->flags)) {
 514                         // No if channel, but upstream we are at the RP.
 515                         if (pim_nexthop_lookup(pim_ifp->pim, &source,
 516                                                up->upstream_register, 0)
 517                             == 0) {
 518                                 pim_register_stop_send(source.interface, &sg,
 519                                                        pim_ifp->primary_address,
 520                                                        up->upstream_register);
 521                                 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
 522                         }
 523                         if (!up->channel_oil)
 524                                 up->channel_oil = pim_channel_oil_add(
 525                                         pim_ifp->pim, &sg,
 526                                         pim_ifp->mroute_vif_index);
 527                         pim_upstream_inherited_olist(pim_ifp->pim, up);
 528                         if (!up->channel_oil->installed)
 529                                 pim_mroute_add(up->channel_oil,
 530                                                __PRETTY_FUNCTION__);
 531                 } else {
 532                         if (I_am_RP(pim_ifp->pim, up->sg.grp)) {
 533                                 if (pim_nexthop_lookup(pim_ifp->pim, &source,
 534                                                        up->upstream_register, 0)
 535                                     == 0)
 536                                         pim_register_stop_send(
 537                                                 source.interface, &sg,
 538                                                 pim_ifp->primary_address,
 539                                                 up->upstream_register);
 540                                 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
 541                         }
 542                         pim_upstream_keep_alive_timer_start(
 543                                 up, pim_ifp->pim->keep_alive_time);
 544                         pim_upstream_inherited_olist(pim_ifp->pim, up);
 545                         pim_mroute_msg_wholepkt(fd, ifp, buf);
 546                 }
 547                 return 0;
 548         }
 549
 550         pim_ifp = ifp->info;
 551         oil = pim_channel_oil_add(pim_ifp->pim, &sg, pim_ifp->mroute_vif_index);
 552         if (!oil->installed)
 553                 pim_mroute_add(oil, __PRETTY_FUNCTION__);
 554         if (pim_if_connected_to_source(ifp, sg.src)) {
 555                 up = pim_upstream_add(pim_ifp->pim, &sg, ifp,
 556                                       PIM_UPSTREAM_FLAG_MASK_FHR,
 557                                       __PRETTY_FUNCTION__, NULL);
 558                 if (!up) {
 559                         if (PIM_DEBUG_MROUTE)
 560                                 zlog_debug(
 561                                         "%s: WRONGVIF%s unable to create upstream on interface",
 562                                         pim_str_sg_dump(&sg), ifp->name);
 563                         return -2;
 564                 }
 565                 PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
 566                 pim_upstream_keep_alive_timer_start(
 567                         up, pim_ifp->pim->keep_alive_time);
 568                 up->channel_oil = oil;
 569                 up->channel_oil->cc.pktcnt++;
 570                 pim_register_join(up);
 571                 pim_upstream_inherited_olist(pim_ifp->pim, up);
 572
 573                 // Send the packet to the RP
 574                 pim_mroute_msg_wholepkt(fd, ifp, buf);
 575         }
 576
 577         return 0;
 578 }
 579
 580 static int pim_mroute_msg(struct pim_instance *pim, const char *buf,
 581                           int buf_size, ifindex_t ifindex)
 582 {
 583         struct interface *ifp;
 584         struct pim_interface *pim_ifp;
 585         const struct ip *ip_hdr;
 586         const struct igmpmsg *msg;
 587         char ip_src_str[INET_ADDRSTRLEN] = "";
 588         char ip_dst_str[INET_ADDRSTRLEN] = "";
 589         char src_str[INET_ADDRSTRLEN] = "<src?>";
 590         char grp_str[INET_ADDRSTRLEN] = "<grp?>";
 591         struct in_addr ifaddr;
 592         struct igmp_sock *igmp;
 593
 594         ip_hdr = (const struct ip *)buf;
 595
 596         if (ip_hdr->ip_p == IPPROTO_IGMP) {
 597
 598                 /* We have the IP packet but we do not know which interface this
 599                  * packet was
 600                  * received on. Find the interface that is on the same subnet as
 601                  * the source
 602                  * of the IP packet.
 603                  */
 604                 ifp = if_lookup_by_index(ifindex, pim->vrf_id);
 605
 606                 if (!ifp || !ifp->info)
 607                         return 0;
 608
 609                 pim_ifp = ifp->info;
 610                 ifaddr = pim_find_primary_addr(ifp);
 611                 igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->igmp_socket_list,
 612                                                    ifaddr);
 613
 614                 if (PIM_DEBUG_MROUTE) {
 615                         pim_inet4_dump("<src?>", ip_hdr->ip_src, ip_src_str,
 616                                        sizeof(ip_src_str));
 617                         pim_inet4_dump("<dst?>", ip_hdr->ip_dst, ip_dst_str,
 618                                        sizeof(ip_dst_str));
 619
 620                         zlog_warn(
 621                                 "%s(%s): igmp kernel upcall on %s(%p) for %s -> %s",
 622                                 __PRETTY_FUNCTION__, pim->vrf->name, ifp->name,
 623                                 igmp, ip_src_str, ip_dst_str);
 624                 }
 625                 if (igmp)
 626                         pim_igmp_packet(igmp, (char *)buf, buf_size);
 627
 628         } else if (ip_hdr->ip_p) {
 629                 if (PIM_DEBUG_MROUTE_DETAIL) {
 630                         pim_inet4_dump("<src?>", ip_hdr->ip_src, src_str,
 631                                        sizeof(src_str));
 632                         pim_inet4_dump("<grp?>", ip_hdr->ip_dst, grp_str,
 633                                        sizeof(grp_str));
 634                         zlog_debug(
 635                                 "%s: no kernel upcall proto=%d src: %s dst: %s msg_size=%d",
 636                                 __PRETTY_FUNCTION__, ip_hdr->ip_p, src_str,
 637                                 grp_str, buf_size);
 638                 }
 639
 640         } else {
 641                 msg = (const struct igmpmsg *)buf;
 642
 643                 ifp = pim_if_find_by_vif_index(pim, msg->im_vif);
 644
 645                 if (!ifp)
 646                         return 0;
 647                 if (PIM_DEBUG_MROUTE) {
 648                         pim_inet4_dump("<src?>", msg->im_src, src_str,
 649                                        sizeof(src_str));
 650                         pim_inet4_dump("<grp?>", msg->im_dst, grp_str,
 651                                        sizeof(grp_str));
 652                         zlog_warn(
 653                                 "%s: pim kernel upcall %s type=%d ip_p=%d from fd=%d for (S,G)=(%s,%s) on %s vifi=%d  size=%d",
 654                                 __PRETTY_FUNCTION__,
 655                                 igmpmsgtype2str[msg->im_msgtype],
 656                                 msg->im_msgtype, ip_hdr->ip_p,
 657                                 pim->mroute_socket, src_str, grp_str, ifp->name,
 658                                 msg->im_vif, buf_size);
 659                 }
 660
 661                 switch (msg->im_msgtype) {
 662                 case IGMPMSG_WRONGVIF:
 663                         return pim_mroute_msg_wrongvif(pim->mroute_socket, ifp,
 664                                                        msg);
 665                         break;
 666                 case IGMPMSG_NOCACHE:
 667                         return pim_mroute_msg_nocache(pim->mroute_socket, ifp,
 668                                                       msg);
 669                         break;
 670                 case IGMPMSG_WHOLEPKT:
 671                         return pim_mroute_msg_wholepkt(pim->mroute_socket, ifp,
 672                                                        (const char *)msg);
 673                         break;
 674                 case IGMPMSG_WRVIFWHOLE:
 675                         return pim_mroute_msg_wrvifwhole(
 676                                 pim->mroute_socket, ifp, (const char *)msg);
 677                         break;
 678                 default:
 679                         break;
 680                 }
 681         }
 682
 683         return 0;
 684 }
 685
 686 static int mroute_read(struct thread *t)
 687 {
 688         struct pim_instance *pim;
 689         static long long count;
 690         char buf[10000];
 691         int result = 0;
 692         int cont = 1;
 693         int rd;
 694         ifindex_t ifindex;
 695         pim = THREAD_ARG(t);
 696
 697         while (cont) {
 698                 rd = pim_socket_recvfromto(pim->mroute_socket, (uint8_t *)buf,
 699                                            sizeof(buf), NULL, NULL, NULL, NULL,
 700                                            &ifindex);
 701                 if (rd <= 0) {
 702                         if (errno == EINTR)
 703                                 continue;
 704                         if (errno == EWOULDBLOCK || errno == EAGAIN)
 705                                 break;
 706
 707                         if (PIM_DEBUG_MROUTE)
 708                                 zlog_warn(
 709                                         "%s: failure reading rd=%d: fd=%d: errno=%d: %s",
 710                                         __PRETTY_FUNCTION__, rd,
 711                                         pim->mroute_socket, errno,
 712                                         safe_strerror(errno));
 713                         goto done;
 714                 }
 715
 716                 result = pim_mroute_msg(pim, buf, rd, ifindex);
 717
 718                 count++;
 719                 if (count % router->packet_process == 0)
 720                         cont = 0;
 721         }
 722 /* Keep reading */
 723 done:
 724         mroute_read_on(pim);
 725
 726         return result;
 727 }
 728
 729 static void mroute_read_on(struct pim_instance *pim)
 730 {
 731         thread_add_read(router->master, mroute_read, pim, pim->mroute_socket,
 732                         &pim->thread);
 733 }
 734
 735 static void mroute_read_off(struct pim_instance *pim)
 736 {
 737         THREAD_OFF(pim->thread);
 738 }
 739
 740 int pim_mroute_socket_enable(struct pim_instance *pim)
 741 {
 742         int fd;
 743
 744         frr_elevate_privs(&pimd_privs) {
 745
 746                 fd = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
 747
 748                 if (fd < 0) {
 749                         zlog_warn("Could not create mroute socket: errno=%d: %s",
 750                                   errno,
 751                                   safe_strerror(errno));
 752                         return -2;
 753                 }
 754
 755 #ifdef SO_BINDTODEVICE
 756                 if (pim->vrf->vrf_id != VRF_DEFAULT
 757                     && setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
 758                                   pim->vrf->name, strlen(pim->vrf->name))) {
 759                         zlog_warn("Could not setsockopt SO_BINDTODEVICE: %s",
 760                                   safe_strerror(errno));
 761                         close(fd);
 762                         return -3;
 763                 }
 764 #endif
 765
 766         }
 767
 768         pim->mroute_socket = fd;
 769         if (pim_mroute_set(pim, 1)) {
 770                 zlog_warn(
 771                         "Could not enable mroute on socket fd=%d: errno=%d: %s",
 772                         fd, errno, safe_strerror(errno));
 773                 close(fd);
 774                 pim->mroute_socket = -1;
 775                 return -3;
 776         }
 777
 778         pim->mroute_socket_creation = pim_time_monotonic_sec();
 779
 780         mroute_read_on(pim);
 781
 782         return 0;
 783 }
 784
 785 int pim_mroute_socket_disable(struct pim_instance *pim)
 786 {
 787         if (pim_mroute_set(pim, 0)) {
 788                 zlog_warn(
 789                         "Could not disable mroute on socket fd=%d: errno=%d: %s",
 790                         pim->mroute_socket, errno, safe_strerror(errno));
 791                 return -2;
 792         }
 793
 794         if (close(pim->mroute_socket)) {
 795                 zlog_warn("Failure closing mroute socket: fd=%d errno=%d: %s",
 796                           pim->mroute_socket, errno, safe_strerror(errno));
 797                 return -3;
 798         }
 799
 800         mroute_read_off(pim);
 801         pim->mroute_socket = -1;
 802
 803         return 0;
 804 }
 805
 806 /*
 807   For each network interface (e.g., physical or a virtual tunnel) that
 808   would be used for multicast forwarding, a corresponding multicast
 809   interface must be added to the kernel.
 810  */
 811 int pim_mroute_add_vif(struct interface *ifp, struct in_addr ifaddr,
 812                        unsigned char flags)
 813 {
 814         struct pim_interface *pim_ifp = ifp->info;
 815         struct vifctl vc;
 816         int err;
 817
 818         if (PIM_DEBUG_MROUTE)
 819                 zlog_debug("%s: Add Vif %d (%s[%s])", __PRETTY_FUNCTION__,
 820                            pim_ifp->mroute_vif_index, ifp->name,
 821                            pim_ifp->pim->vrf->name);
 822
 823         memset(&vc, 0, sizeof(vc));
 824         vc.vifc_vifi = pim_ifp->mroute_vif_index;
 825 #ifdef VIFF_USE_IFINDEX
 826         vc.vifc_lcl_ifindex = ifp->ifindex;
 827 #else
 828         if (ifaddr.s_addr == INADDR_ANY) {
 829                 zlog_warn(
 830                         "%s: unnumbered interfaces are not supported on this platform",
 831                         __PRETTY_FUNCTION__);
 832                 return -1;
 833         }
 834         memcpy(&vc.vifc_lcl_addr, &ifaddr, sizeof(vc.vifc_lcl_addr));
 835 #endif
 836         vc.vifc_flags = flags;
 837         vc.vifc_threshold = PIM_MROUTE_MIN_TTL;
 838         vc.vifc_rate_limit = 0;
 839
 840 #ifdef PIM_DVMRP_TUNNEL
 841         if (vc.vifc_flags & VIFF_TUNNEL) {
 842                 memcpy(&vc.vifc_rmt_addr, &vif_remote_addr,
 843                        sizeof(vc.vifc_rmt_addr));
 844         }
 845 #endif
 846
 847         err = setsockopt(pim_ifp->pim->mroute_socket, IPPROTO_IP, MRT_ADD_VIF,
 848                          (void *)&vc, sizeof(vc));
 849         if (err) {
 850                 char ifaddr_str[INET_ADDRSTRLEN];
 851
 852                 pim_inet4_dump("<ifaddr?>", ifaddr, ifaddr_str,
 853                                sizeof(ifaddr_str));
 854
 855                 zlog_warn(
 856                         "%s: failure: setsockopt(fd=%d,IPPROTO_IP,MRT_ADD_VIF,vif_index=%d,ifaddr=%s,flag=%d): errno=%d: %s",
 857                         __PRETTY_FUNCTION__, pim_ifp->pim->mroute_socket,
 858                         ifp->ifindex, ifaddr_str, flags, errno,
 859                         safe_strerror(errno));
 860                 return -2;
 861         }
 862
 863         return 0;
 864 }
 865
 866 int pim_mroute_del_vif(struct interface *ifp)
 867 {
 868         struct pim_interface *pim_ifp = ifp->info;
 869         struct vifctl vc;
 870         int err;
 871
 872         if (PIM_DEBUG_MROUTE)
 873                 zlog_debug("%s: Del Vif %d (%s[%s])", __PRETTY_FUNCTION__,
 874                            pim_ifp->mroute_vif_index, ifp->name,
 875                            pim_ifp->pim->vrf->name);
 876
 877         memset(&vc, 0, sizeof(vc));
 878         vc.vifc_vifi = pim_ifp->mroute_vif_index;
 879
 880         err = setsockopt(pim_ifp->pim->mroute_socket, IPPROTO_IP, MRT_DEL_VIF,
 881                          (void *)&vc, sizeof(vc));
 882         if (err) {
 883                 zlog_warn(
 884                         "%s %s: failure: setsockopt(fd=%d,IPPROTO_IP,MRT_DEL_VIF,vif_index=%d): errno=%d: %s",
 885                         __FILE__, __PRETTY_FUNCTION__,
 886                         pim_ifp->pim->mroute_socket, pim_ifp->mroute_vif_index,
 887                         errno, safe_strerror(errno));
 888                 return -2;
 889         }
 890
 891         return 0;
 892 }
 893
 894 int pim_mroute_add(struct channel_oil *c_oil, const char *name)
 895 {
 896         struct pim_instance *pim = c_oil->pim;
 897         int err;
 898         int orig = 0;
 899         int orig_iif_vif = 0;
 900
 901         pim->mroute_add_last = pim_time_monotonic_sec();
 902         ++pim->mroute_add_events;
 903
 904         /* Do not install route if incoming interface is undefined. */
 905         if (c_oil->oil.mfcc_parent >= MAXVIFS) {
 906                 if (PIM_DEBUG_MROUTE) {
 907                         char buf[1000];
 908                         zlog_debug(
 909                                 "%s(%s) %s Attempting to add vifi that is invalid to mroute table",
 910                                 __PRETTY_FUNCTION__, name,
 911                                 pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
 912                 }
 913                 return -2;
 914         }
 915
 916         /* The linux kernel *expects* the incoming
 917          * vif to be part of the outgoing list
 918          * in the case of a (*,G).
 919          */
 920         if (c_oil->oil.mfcc_origin.s_addr == INADDR_ANY) {
 921                 orig = c_oil->oil.mfcc_ttls[c_oil->oil.mfcc_parent];
 922                 c_oil->oil.mfcc_ttls[c_oil->oil.mfcc_parent] = 1;
 923         }
 924
 925         /*
 926          * If we have an unresolved cache entry for the S,G
 927          * it is owned by the pimreg for the incoming IIF
 928          * So set pimreg as the IIF temporarily to cause
 929          * the packets to be forwarded.  Then set it
 930          * to the correct IIF afterwords.
 931          */
 932         if (!c_oil->installed && c_oil->oil.mfcc_origin.s_addr != INADDR_ANY
 933             && c_oil->oil.mfcc_parent != 0) {
 934                 orig_iif_vif = c_oil->oil.mfcc_parent;
 935                 c_oil->oil.mfcc_parent = 0;
 936         }
 937         err = setsockopt(pim->mroute_socket, IPPROTO_IP, MRT_ADD_MFC,
 938                          &c_oil->oil, sizeof(c_oil->oil));
 939
 940         if (!err && !c_oil->installed
 941             && c_oil->oil.mfcc_origin.s_addr != INADDR_ANY
 942             && orig_iif_vif != 0) {
 943                 c_oil->oil.mfcc_parent = orig_iif_vif;
 944                 err = setsockopt(pim->mroute_socket, IPPROTO_IP, MRT_ADD_MFC,
 945                                  &c_oil->oil, sizeof(c_oil->oil));
 946         }
 947
 948         if (c_oil->oil.mfcc_origin.s_addr == INADDR_ANY)
 949                 c_oil->oil.mfcc_ttls[c_oil->oil.mfcc_parent] = orig;
 950
 951         if (err) {
 952                 zlog_warn(
 953                         "%s %s: failure: setsockopt(fd=%d,IPPROTO_IP,MRT_ADD_MFC): errno=%d: %s",
 954                         __FILE__, __PRETTY_FUNCTION__, pim->mroute_socket,
 955                         errno, safe_strerror(errno));
 956                 return -2;
 957         }
 958
 959         if (PIM_DEBUG_MROUTE) {
 960                 char buf[1000];
 961                 zlog_debug("%s(%s), vrf %s Added Route: %s",
 962                            __PRETTY_FUNCTION__, name, pim->vrf->name,
 963                            pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
 964         }
 965
 966         c_oil->installed = 1;
 967         return 0;
 968 }
 969
 970 int pim_mroute_del(struct channel_oil *c_oil, const char *name)
 971 {
 972         struct pim_instance *pim = c_oil->pim;
 973         int err;
 974
 975         pim->mroute_del_last = pim_time_monotonic_sec();
 976         ++pim->mroute_del_events;
 977
 978         if (!c_oil->installed) {
 979                 if (PIM_DEBUG_MROUTE) {
 980                         char buf[1000];
 981                         zlog_debug(
 982                                 "%s %s: vifi %d for route is %s not installed, do not need to send del req. ",
 983                                 __FILE__, __PRETTY_FUNCTION__,
 984                                 c_oil->oil.mfcc_parent,
 985                                 pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
 986                 }
 987                 return -2;
 988         }
 989
 990         err = setsockopt(pim->mroute_socket, IPPROTO_IP, MRT_DEL_MFC,
 991                          &c_oil->oil, sizeof(c_oil->oil));
 992         if (err) {
 993                 if (PIM_DEBUG_MROUTE)
 994                         zlog_warn(
 995                                 "%s %s: failure: setsockopt(fd=%d,IPPROTO_IP,MRT_DEL_MFC): errno=%d: %s",
 996                                 __FILE__, __PRETTY_FUNCTION__,
 997                                 pim->mroute_socket, errno,
 998                                 safe_strerror(errno));
 999                 return -2;
1000         }
1001
1002         if (PIM_DEBUG_MROUTE) {
1003                 char buf[1000];
1004                 zlog_debug("%s(%s), vrf %s Deleted Route: %s",
1005                            __PRETTY_FUNCTION__, name, pim->vrf->name,
1006                            pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
1007         }
1008
1009         // Reset kernel installed flag
1010         c_oil->installed = 0;
1011
1012         return 0;
1013 }
1014
1015 void pim_mroute_update_counters(struct channel_oil *c_oil)
1016 {
1017         struct pim_instance *pim = c_oil->pim;
1018         struct sioc_sg_req sgreq;
1019
1020         c_oil->cc.oldpktcnt = c_oil->cc.pktcnt;
1021         c_oil->cc.oldbytecnt = c_oil->cc.bytecnt;
1022         c_oil->cc.oldwrong_if = c_oil->cc.wrong_if;
1023
1024         if (!c_oil->installed) {
1025                 c_oil->cc.lastused = 100 * pim->keep_alive_time;
1026                 if (PIM_DEBUG_MROUTE) {
1027                         struct prefix_sg sg;
1028
1029                         sg.src = c_oil->oil.mfcc_origin;
1030                         sg.grp = c_oil->oil.mfcc_mcastgrp;
1031                         if (PIM_DEBUG_MROUTE)
1032                                 zlog_debug(
1033                                         "Channel(%s) is not installed no need to collect data from kernel",
1034                                         pim_str_sg_dump(&sg));
1035                 }
1036                 return;
1037         }
1038
1039         memset(&sgreq, 0, sizeof(sgreq));
1040         sgreq.src = c_oil->oil.mfcc_origin;
1041         sgreq.grp = c_oil->oil.mfcc_mcastgrp;
1042
1043         pim_zlookup_sg_statistics(c_oil);
1044         if (ioctl(pim->mroute_socket, SIOCGETSGCNT, &sgreq)) {
1045                 if (PIM_DEBUG_MROUTE) {
1046                         struct prefix_sg sg;
1047
1048                         sg.src = c_oil->oil.mfcc_origin;
1049                         sg.grp = c_oil->oil.mfcc_mcastgrp;
1050
1051                         zlog_warn(
1052                                 "ioctl(SIOCGETSGCNT=%lu) failure for (S,G)=(%s): errno=%d: %s",
1053                                 (unsigned long)SIOCGETSGCNT,
1054                                 pim_str_sg_dump(&sg), errno,
1055                                 safe_strerror(errno));
1056                 }
1057                 return;
1058         }
1059
1060         c_oil->cc.pktcnt = sgreq.pktcnt;
1061         c_oil->cc.bytecnt = sgreq.bytecnt;
1062         c_oil->cc.wrong_if = sgreq.wrong_if;
1063
1064         return;
1065 }