pimd/pim_oil.c

   1 /*
   2  * PIM for Quagga
   3  * Copyright (C) 2008  Everton da Silva Marques
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include "log.h"
  23 #include "memory.h"
  24 #include "linklist.h"
  25 #include "if.h"
  26 #include "hash.h"
  27 #include "jhash.h"
  28
  29 #include "pimd.h"
  30 #include "pim_oil.h"
  31 #include "pim_str.h"
  32 #include "pim_iface.h"
  33 #include "pim_time.h"
  34
  35 // struct list *pim_channel_oil_list = NULL;
  36 // struct hash *pim_channel_oil_hash = NULL;
  37
  38 char *pim_channel_oil_dump(struct channel_oil *c_oil, char *buf, size_t size)
  39 {
  40         char *out;
  41         struct prefix_sg sg;
  42         int i;
  43
  44         sg.src = c_oil->oil.mfcc_origin;
  45         sg.grp = c_oil->oil.mfcc_mcastgrp;
  46         snprintf(buf, size, "%s IIF: %d, OIFS: ", pim_str_sg_dump(&sg),
  47                  c_oil->oil.mfcc_parent);
  48
  49         out = buf + strlen(buf);
  50         for (i = 0; i < MAXVIFS; i++) {
  51                 if (c_oil->oil.mfcc_ttls[i] != 0) {
  52                         snprintf(out, buf + size - out, "%d ", i);
  53                         out += strlen(out);
  54                 }
  55         }
  56
  57         return buf;
  58 }
  59
  60 static int pim_channel_oil_compare(struct channel_oil *c1,
  61                                    struct channel_oil *c2)
  62 {
  63         if (ntohl(c1->oil.mfcc_mcastgrp.s_addr)
  64             < ntohl(c2->oil.mfcc_mcastgrp.s_addr))
  65                 return -1;
  66
  67         if (ntohl(c1->oil.mfcc_mcastgrp.s_addr)
  68             > ntohl(c2->oil.mfcc_mcastgrp.s_addr))
  69                 return 1;
  70
  71         if (ntohl(c1->oil.mfcc_origin.s_addr)
  72             < ntohl(c2->oil.mfcc_origin.s_addr))
  73                 return -1;
  74
  75         if (ntohl(c1->oil.mfcc_origin.s_addr)
  76             > ntohl(c2->oil.mfcc_origin.s_addr))
  77                 return 1;
  78
  79         return 0;
  80 }
  81
  82 static bool pim_oil_equal(const void *arg1, const void *arg2)
  83 {
  84         const struct channel_oil *c1 = (const struct channel_oil *)arg1;
  85         const struct channel_oil *c2 = (const struct channel_oil *)arg2;
  86
  87         if ((c1->oil.mfcc_mcastgrp.s_addr == c2->oil.mfcc_mcastgrp.s_addr)
  88             && (c1->oil.mfcc_origin.s_addr == c2->oil.mfcc_origin.s_addr))
  89                 return true;
  90
  91         return false;
  92 }
  93
  94 static unsigned int pim_oil_hash_key(void *arg)
  95 {
  96         struct channel_oil *oil = (struct channel_oil *)arg;
  97
  98         return jhash_2words(oil->oil.mfcc_mcastgrp.s_addr,
  99                             oil->oil.mfcc_origin.s_addr, 0);
 100 }
 101
 102 void pim_oil_init(struct pim_instance *pim)
 103 {
 104         char hash_name[64];
 105
 106         snprintf(hash_name, 64, "PIM %s Oil Hash", pim->vrf->name);
 107         pim->channel_oil_hash = hash_create_size(8192, pim_oil_hash_key,
 108                                                  pim_oil_equal, hash_name);
 109
 110         pim->channel_oil_list = list_new();
 111         pim->channel_oil_list->del = (void (*)(void *))pim_channel_oil_free;
 112         pim->channel_oil_list->cmp =
 113                 (int (*)(void *, void *))pim_channel_oil_compare;
 114 }
 115
 116 void pim_oil_terminate(struct pim_instance *pim)
 117 {
 118         if (pim->channel_oil_list)
 119                 list_delete(&pim->channel_oil_list);
 120
 121         if (pim->channel_oil_hash)
 122                 hash_free(pim->channel_oil_hash);
 123         pim->channel_oil_hash = NULL;
 124 }
 125
 126 void pim_channel_oil_free(struct channel_oil *c_oil)
 127 {
 128         XFREE(MTYPE_PIM_CHANNEL_OIL, c_oil);
 129 }
 130
 131 struct channel_oil *pim_find_channel_oil(struct pim_instance *pim,
 132                                          struct prefix_sg *sg)
 133 {
 134         struct channel_oil *c_oil = NULL;
 135         struct channel_oil lookup;
 136
 137         lookup.oil.mfcc_mcastgrp = sg->grp;
 138         lookup.oil.mfcc_origin = sg->src;
 139
 140         c_oil = hash_lookup(pim->channel_oil_hash, &lookup);
 141
 142         return c_oil;
 143 }
 144
 145 struct channel_oil *pim_channel_oil_add(struct pim_instance *pim,
 146                                         struct prefix_sg *sg,
 147                                         int input_vif_index)
 148 {
 149         struct channel_oil *c_oil;
 150         struct interface *ifp;
 151
 152         c_oil = pim_find_channel_oil(pim, sg);
 153         if (c_oil) {
 154                 if (c_oil->oil.mfcc_parent != input_vif_index) {
 155                         c_oil->oil_inherited_rescan = 1;
 156                         if (PIM_DEBUG_MROUTE)
 157                                 zlog_debug(
 158                                         "%s: Existing channel oil %s points to %d, modifying to point at %d",
 159                                         __PRETTY_FUNCTION__,
 160                                         pim_str_sg_dump(sg),
 161                                         c_oil->oil.mfcc_parent,
 162                                         input_vif_index);
 163                 }
 164                 c_oil->oil.mfcc_parent = input_vif_index;
 165                 ++c_oil->oil_ref_count;
 166                 c_oil->up = pim_upstream_find(
 167                         pim, sg); // channel might be present prior to upstream
 168                 return c_oil;
 169         }
 170
 171         if (input_vif_index != MAXVIFS) {
 172                 ifp = pim_if_find_by_vif_index(pim, input_vif_index);
 173                 if (!ifp) {
 174                         /* warning only */
 175                         zlog_warn(
 176                                 "%s: (S,G)=%s could not find input interface for input_vif_index=%d",
 177                                 __PRETTY_FUNCTION__, pim_str_sg_dump(sg),
 178                                 input_vif_index);
 179                 }
 180         }
 181
 182         c_oil = XCALLOC(MTYPE_PIM_CHANNEL_OIL, sizeof(*c_oil));
 183
 184         c_oil->oil.mfcc_mcastgrp = sg->grp;
 185         c_oil->oil.mfcc_origin = sg->src;
 186         c_oil = hash_get(pim->channel_oil_hash, c_oil, hash_alloc_intern);
 187
 188         c_oil->oil.mfcc_parent = input_vif_index;
 189         c_oil->oil_ref_count = 1;
 190         c_oil->installed = 0;
 191         c_oil->up = pim_upstream_find(pim, sg);
 192         c_oil->pim = pim;
 193
 194         listnode_add_sort(pim->channel_oil_list, c_oil);
 195
 196         return c_oil;
 197 }
 198
 199 void pim_channel_oil_del(struct channel_oil *c_oil)
 200 {
 201         --c_oil->oil_ref_count;
 202
 203         if (c_oil->oil_ref_count < 1) {
 204                 /*
 205                  * notice that listnode_delete() can't be moved
 206                  * into pim_channel_oil_free() because the later is
 207                  * called by list_delete_all_node()
 208                  */
 209                 c_oil->up = NULL;
 210                 listnode_delete(c_oil->pim->channel_oil_list, c_oil);
 211                 hash_release(c_oil->pim->channel_oil_hash, c_oil);
 212
 213                 pim_channel_oil_free(c_oil);
 214         }
 215 }
 216
 217 int pim_channel_del_oif(struct channel_oil *channel_oil, struct interface *oif,
 218                         uint32_t proto_mask)
 219 {
 220         struct pim_interface *pim_ifp;
 221
 222         zassert(channel_oil);
 223         zassert(oif);
 224
 225         pim_ifp = oif->info;
 226
 227         /*
 228          * Don't do anything if we've been asked to remove a source
 229          * that is not actually on it.
 230          */
 231         if (!(channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask)) {
 232                 if (PIM_DEBUG_MROUTE) {
 233                         char group_str[INET_ADDRSTRLEN];
 234                         char source_str[INET_ADDRSTRLEN];
 235                         pim_inet4_dump("<group?>",
 236                                        channel_oil->oil.mfcc_mcastgrp,
 237                                        group_str, sizeof(group_str));
 238                         pim_inet4_dump("<source?>",
 239                                        channel_oil->oil.mfcc_origin, source_str,
 240                                        sizeof(source_str));
 241                         zlog_debug(
 242                                 "%s %s: no existing protocol mask %u(%u) for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 243                                 __FILE__, __PRETTY_FUNCTION__, proto_mask,
 244                                 channel_oil
 245                                         ->oif_flags[pim_ifp->mroute_vif_index],
 246                                 oif->name, pim_ifp->mroute_vif_index,
 247                                 channel_oil->oil
 248                                         .mfcc_ttls[pim_ifp->mroute_vif_index],
 249                                 source_str, group_str);
 250                 }
 251                 return 0;
 252         }
 253
 254         channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~proto_mask;
 255
 256         if (channel_oil->oif_flags[pim_ifp->mroute_vif_index]) {
 257                 if (PIM_DEBUG_MROUTE) {
 258                         char group_str[INET_ADDRSTRLEN];
 259                         char source_str[INET_ADDRSTRLEN];
 260                         pim_inet4_dump("<group?>",
 261                                        channel_oil->oil.mfcc_mcastgrp,
 262                                        group_str, sizeof(group_str));
 263                         pim_inet4_dump("<source?>",
 264                                        channel_oil->oil.mfcc_origin, source_str,
 265                                        sizeof(source_str));
 266                         zlog_debug(
 267                                 "%s %s: other protocol masks remain for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 268                                 __FILE__, __PRETTY_FUNCTION__, oif->name,
 269                                 pim_ifp->mroute_vif_index,
 270                                 channel_oil->oil
 271                                         .mfcc_ttls[pim_ifp->mroute_vif_index],
 272                                 source_str, group_str);
 273                 }
 274                 return 0;
 275         }
 276
 277         channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] = 0;
 278
 279         if (pim_mroute_add(channel_oil, __PRETTY_FUNCTION__)) {
 280                 if (PIM_DEBUG_MROUTE) {
 281                         char group_str[INET_ADDRSTRLEN];
 282                         char source_str[INET_ADDRSTRLEN];
 283                         pim_inet4_dump("<group?>",
 284                                        channel_oil->oil.mfcc_mcastgrp,
 285                                        group_str, sizeof(group_str));
 286                         pim_inet4_dump("<source?>",
 287                                        channel_oil->oil.mfcc_origin, source_str,
 288                                        sizeof(source_str));
 289                         zlog_debug(
 290                                 "%s %s: could not remove output interface %s (vif_index=%d) for channel (S,G)=(%s,%s)",
 291                                 __FILE__, __PRETTY_FUNCTION__, oif->name,
 292                                 pim_ifp->mroute_vif_index, source_str,
 293                                 group_str);
 294                 }
 295                 return -1;
 296         }
 297
 298         --channel_oil->oil_size;
 299
 300         if (PIM_DEBUG_MROUTE) {
 301                 char group_str[INET_ADDRSTRLEN];
 302                 char source_str[INET_ADDRSTRLEN];
 303                 pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp,
 304                                group_str, sizeof(group_str));
 305                 pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin,
 306                                source_str, sizeof(source_str));
 307                 zlog_debug(
 308                         "%s %s: (S,G)=(%s,%s): proto_mask=%u IIF:%d OIF=%s vif_index=%d",
 309                         __FILE__, __PRETTY_FUNCTION__, source_str, group_str,
 310                         proto_mask, channel_oil->oil.mfcc_parent, oif->name,
 311                         pim_ifp->mroute_vif_index);
 312         }
 313
 314         return 0;
 315 }
 316
 317
 318 int pim_channel_add_oif(struct channel_oil *channel_oil, struct interface *oif,
 319                         uint32_t proto_mask)
 320 {
 321         struct pim_interface *pim_ifp;
 322         int old_ttl;
 323         bool allow_iif_in_oil = false;
 324
 325         /*
 326          * If we've gotten here we've gone bad, but let's
 327          * not take down pim
 328          */
 329         if (!channel_oil) {
 330                 zlog_warn("Attempt to Add OIF for non-existent channel oil");
 331                 return -1;
 332         }
 333
 334         pim_ifp = oif->info;
 335
 336 #ifdef PIM_ENFORCE_LOOPFREE_MFC
 337         /*
 338           Prevent creating MFC entry with OIF=IIF.
 339
 340           This is a protection against implementation mistakes.
 341
 342           PIM protocol implicitely ensures loopfree multicast topology.
 343
 344           IGMP must be protected against adding looped MFC entries created
 345           by both source and receiver attached to the same interface. See
 346           TODO T22.
 347         */
 348         if (channel_oil->up &&
 349                         PIM_UPSTREAM_FLAG_TEST_ALLOW_IIF_IN_OIL(
 350                                 channel_oil->up->flags)) {
 351                 allow_iif_in_oil = true;
 352         }
 353
 354         if (!allow_iif_in_oil &&
 355                 pim_ifp->mroute_vif_index == channel_oil->oil.mfcc_parent) {
 356                 channel_oil->oil_inherited_rescan = 1;
 357                 if (PIM_DEBUG_MROUTE) {
 358                         char group_str[INET_ADDRSTRLEN];
 359                         char source_str[INET_ADDRSTRLEN];
 360                         pim_inet4_dump("<group?>",
 361                                        channel_oil->oil.mfcc_mcastgrp,
 362                                        group_str, sizeof(group_str));
 363                         pim_inet4_dump("<source?>",
 364                                        channel_oil->oil.mfcc_origin, source_str,
 365                                        sizeof(source_str));
 366                         zlog_debug(
 367                                 "%s %s: refusing protocol mask %u request for IIF=OIF=%s (vif_index=%d) for channel (S,G)=(%s,%s)",
 368                                 __FILE__, __PRETTY_FUNCTION__, proto_mask,
 369                                 oif->name, pim_ifp->mroute_vif_index,
 370                                 source_str, group_str);
 371                 }
 372                 return -2;
 373         }
 374 #endif
 375
 376         /* Prevent single protocol from subscribing same interface to
 377            channel (S,G) multiple times */
 378         if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask) {
 379                 if (PIM_DEBUG_MROUTE) {
 380                         char group_str[INET_ADDRSTRLEN];
 381                         char source_str[INET_ADDRSTRLEN];
 382                         pim_inet4_dump("<group?>",
 383                                        channel_oil->oil.mfcc_mcastgrp,
 384                                        group_str, sizeof(group_str));
 385                         pim_inet4_dump("<source?>",
 386                                        channel_oil->oil.mfcc_origin, source_str,
 387                                        sizeof(source_str));
 388                         zlog_debug(
 389                                 "%s %s: existing protocol mask %u requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 390                                 __FILE__, __PRETTY_FUNCTION__, proto_mask,
 391                                 oif->name, pim_ifp->mroute_vif_index,
 392                                 channel_oil->oil
 393                                         .mfcc_ttls[pim_ifp->mroute_vif_index],
 394                                 source_str, group_str);
 395                 }
 396                 return -3;
 397         }
 398
 399         /* Allow other protocol to request subscription of same interface to
 400          * channel (S,G), we need to note this information
 401          */
 402         if (channel_oil->oif_flags[pim_ifp->mroute_vif_index]
 403             & PIM_OIF_FLAG_PROTO_ANY) {
 404
 405                 /* Updating time here is not required as this time has to
 406                  * indicate when the interface is added
 407                  */
 408
 409                 channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;
 410                 /* Check the OIF really exists before returning, and only log
 411                    warning otherwise */
 412                 if (channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] < 1) {
 413                         {
 414                                 char group_str[INET_ADDRSTRLEN];
 415                                 char source_str[INET_ADDRSTRLEN];
 416                                 pim_inet4_dump("<group?>",
 417                                                channel_oil->oil.mfcc_mcastgrp,
 418                                                group_str, sizeof(group_str));
 419                                 pim_inet4_dump("<source?>",
 420                                                channel_oil->oil.mfcc_origin,
 421                                                source_str, sizeof(source_str));
 422                                 zlog_warn(
 423                                         "%s %s: new protocol mask %u requested nonexistent OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%s,%s)",
 424                                         __FILE__, __PRETTY_FUNCTION__,
 425                                         proto_mask, oif->name,
 426                                         pim_ifp->mroute_vif_index,
 427                                         channel_oil->oil.mfcc_ttls
 428                                                 [pim_ifp->mroute_vif_index],
 429                                         source_str, group_str);
 430                         }
 431                 }
 432
 433                 return 0;
 434         }
 435
 436         old_ttl = channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index];
 437
 438         if (old_ttl > 0) {
 439                 if (PIM_DEBUG_MROUTE) {
 440                         char group_str[INET_ADDRSTRLEN];
 441                         char source_str[INET_ADDRSTRLEN];
 442                         pim_inet4_dump("<group?>",
 443                                        channel_oil->oil.mfcc_mcastgrp,
 444                                        group_str, sizeof(group_str));
 445                         pim_inet4_dump("<source?>",
 446                                        channel_oil->oil.mfcc_origin, source_str,
 447                                        sizeof(source_str));
 448                         zlog_debug(
 449                                 "%s %s: interface %s (vif_index=%d) is existing output for channel (S,G)=(%s,%s)",
 450                                 __FILE__, __PRETTY_FUNCTION__, oif->name,
 451                                 pim_ifp->mroute_vif_index, source_str,
 452                                 group_str);
 453                 }
 454                 return -4;
 455         }
 456
 457         channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index] =
 458                 PIM_MROUTE_MIN_TTL;
 459
 460         /* channel_oil->oil.mfcc_parent != MAXVIFS indicate this entry is not
 461          * valid to get installed in kernel.
 462          */
 463         if (channel_oil->oil.mfcc_parent != MAXVIFS) {
 464                 if (pim_mroute_add(channel_oil, __PRETTY_FUNCTION__)) {
 465                         if (PIM_DEBUG_MROUTE) {
 466                                 char group_str[INET_ADDRSTRLEN];
 467                                 char source_str[INET_ADDRSTRLEN];
 468                                 pim_inet4_dump("<group?>",
 469                                       channel_oil->oil.mfcc_mcastgrp,
 470                                       group_str, sizeof(group_str));
 471                                 pim_inet4_dump("<source?>",
 472                                       channel_oil->oil.mfcc_origin, source_str,
 473                                       sizeof(source_str));
 474                                 zlog_debug(
 475                                     "%s %s: could not add output interface %s (vif_index=%d) for channel (S,G)=(%s,%s)",
 476                                     __FILE__, __PRETTY_FUNCTION__, oif->name,
 477                                     pim_ifp->mroute_vif_index, source_str,
 478                                     group_str);
 479                         }
 480
 481                         channel_oil->oil.mfcc_ttls[pim_ifp->mroute_vif_index]
 482                                 = old_ttl;
 483                         return -5;
 484                 }
 485         }
 486
 487         channel_oil->oif_creation[pim_ifp->mroute_vif_index] =
 488                 pim_time_monotonic_sec();
 489         ++channel_oil->oil_size;
 490         channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;
 491
 492         if (PIM_DEBUG_MROUTE) {
 493                 char group_str[INET_ADDRSTRLEN];
 494                 char source_str[INET_ADDRSTRLEN];
 495                 pim_inet4_dump("<group?>", channel_oil->oil.mfcc_mcastgrp,
 496                                group_str, sizeof(group_str));
 497                 pim_inet4_dump("<source?>", channel_oil->oil.mfcc_origin,
 498                                source_str, sizeof(source_str));
 499                 zlog_debug(
 500                         "%s %s: (S,G)=(%s,%s): proto_mask=%u OIF=%s vif_index=%d: DONE",
 501                         __FILE__, __PRETTY_FUNCTION__, source_str, group_str,
 502                         proto_mask, oif->name, pim_ifp->mroute_vif_index);
 503         }
 504
 505         return 0;
 506 }
 507
 508 int pim_channel_oil_empty(struct channel_oil *c_oil)
 509 {
 510         static uint32_t zero[MAXVIFS];
 511         static int inited = 0;
 512
 513         if (!c_oil)
 514                 return 1;
 515         /*
 516          * Not sure that this is necessary, but I would rather ensure
 517          * that this works.
 518          */
 519         if (!inited) {
 520                 memset(&zero, 0, sizeof(uint32_t) * MAXVIFS);
 521                 inited = 1;
 522         }
 523
 524         return !memcmp(c_oil->oif_flags, zero, MAXVIFS * sizeof(uint32_t));
 525 }