pimd/pim_hello.c

   1 /*
   2   PIM for Quagga
   3   Copyright (C) 2008  Everton da Silva Marques
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful, but
  11   WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13   General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; see the file COPYING; if not, write to the
  17   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  18   MA 02110-1301 USA
  19 */
  20
  21 #include <zebra.h>
  22
  23 #include "log.h"
  24 #include "if.h"
  25
  26 #include "pimd.h"
  27 #include "pim_pim.h"
  28 #include "pim_str.h"
  29 #include "pim_tlv.h"
  30 #include "pim_util.h"
  31 #include "pim_hello.h"
  32 #include "pim_iface.h"
  33 #include "pim_neighbor.h"
  34 #include "pim_upstream.h"
  35
  36 static void on_trace(const char *label,
  37                      struct interface *ifp, struct in_addr src)
  38 {
  39   if (PIM_DEBUG_PIM_TRACE) {
  40     char src_str[100];
  41     pim_inet4_dump("<src?>", src, src_str, sizeof(src_str));
  42     zlog_debug("%s: from %s on %s",
  43                label, src_str, ifp->name);
  44   }
  45 }
  46
  47 static void tlv_trace_bool(const char *label, const char *tlv_name,
  48                            const char *ifname, struct in_addr src_addr,
  49                            int isset, int value)
  50 {
  51   if (isset) {
  52     char src_str[100];
  53     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
  54     zlog_debug("%s: PIM hello option from %s on interface %s: %s=%d",
  55                label,
  56                src_str, ifname,
  57                tlv_name, value);
  58   }
  59 }
  60
  61 static void tlv_trace_uint16(const char *label, const char *tlv_name,
  62                              const char *ifname, struct in_addr src_addr,
  63                              int isset, uint16_t value)
  64 {
  65   if (isset) {
  66     char src_str[100];
  67     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
  68     zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
  69                label,
  70                src_str, ifname,
  71                tlv_name, value);
  72   }
  73 }
  74
  75 static void tlv_trace_uint32(const char *label, const char *tlv_name,
  76                              const char *ifname, struct in_addr src_addr,
  77                              int isset, uint32_t value)
  78 {
  79   if (isset) {
  80     char src_str[100];
  81     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
  82     zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
  83                label,
  84                src_str, ifname,
  85                tlv_name, value);
  86   }
  87 }
  88
  89 static void tlv_trace_uint32_hex(const char *label, const char *tlv_name,
  90                                  const char *ifname, struct in_addr src_addr,
  91                                  int isset, uint32_t value)
  92 {
  93   if (isset) {
  94     char src_str[100];
  95     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
  96     zlog_debug("%s: PIM hello option from %s on interface %s: %s=%08x",
  97                label,
  98                src_str, ifname,
  99                tlv_name, value);
 100   }
 101 }
 102
 103 #if 0
 104 static void tlv_trace(const char *label, const char *tlv_name,
 105                       const char *ifname, struct in_addr src_addr,
 106                       int isset)
 107 {
 108   if (isset) {
 109     char src_str[100];
 110     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 111     zlog_debug("%s: PIM hello option from %s on interface %s: %s",
 112                label,
 113                src_str, ifname,
 114                tlv_name);
 115   }
 116 }
 117 #endif
 118
 119 static void tlv_trace_list(const char *label, const char *tlv_name,
 120                            const char *ifname, struct in_addr src_addr,
 121                            int isset, struct list *addr_list)
 122 {
 123   if (isset) {
 124     char src_str[100];
 125     pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 126     zlog_debug("%s: PIM hello option from %s on interface %s: %s size=%d list=%p",
 127                label,
 128                src_str, ifname,
 129                tlv_name,
 130                addr_list ? ((int) listcount(addr_list)) : -1,
 131                (void *) addr_list);
 132   }
 133 }
 134
 135 #define FREE_ADDR_LIST \
 136   if (hello_option_addr_list) { \
 137     list_delete(hello_option_addr_list); \
 138   }
 139
 140 #define FREE_ADDR_LIST_THEN_RETURN(code) \
 141 { \
 142   FREE_ADDR_LIST \
 143   return (code); \
 144 }
 145
 146 int pim_hello_recv(struct interface *ifp,
 147                    struct in_addr src_addr,
 148                    uint8_t *tlv_buf, int tlv_buf_size)
 149 {
 150   struct pim_interface *pim_ifp;
 151   struct pim_neighbor *neigh;
 152   uint8_t *tlv_curr;
 153   uint8_t *tlv_pastend;
 154   pim_hello_options hello_options = 0; /* bit array recording options found */
 155   uint16_t hello_option_holdtime = 0;
 156   uint16_t hello_option_propagation_delay = 0;
 157   uint16_t hello_option_override_interval = 0;
 158   uint32_t hello_option_dr_priority = 0;
 159   uint32_t hello_option_generation_id = 0;
 160   struct list *hello_option_addr_list = 0;
 161
 162   if (PIM_DEBUG_PIM_HELLO)
 163     on_trace(__PRETTY_FUNCTION__, ifp, src_addr);
 164
 165   pim_ifp = ifp->info;
 166   zassert(pim_ifp);
 167
 168   ++pim_ifp->pim_ifstat_hello_recv;
 169
 170   /*
 171     Parse PIM hello TLVs
 172    */
 173   zassert(tlv_buf_size >= 0);
 174   tlv_curr = tlv_buf;
 175   tlv_pastend = tlv_buf + tlv_buf_size;
 176
 177   while (tlv_curr < tlv_pastend) {
 178     uint16_t option_type;
 179     uint16_t option_len;
 180     int remain = tlv_pastend - tlv_curr;
 181
 182     if (remain < PIM_TLV_MIN_SIZE) {
 183       if (PIM_DEBUG_PIM_HELLO) {
 184         char src_str[100];
 185         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 186         zlog_debug("%s: short PIM hello TLV size=%d < min=%d from %s on interface %s",
 187                    __PRETTY_FUNCTION__,
 188                    remain, PIM_TLV_MIN_SIZE,
 189                    src_str, ifp->name);
 190       }
 191       FREE_ADDR_LIST_THEN_RETURN(-1);
 192     }
 193
 194     option_type = PIM_TLV_GET_TYPE(tlv_curr);
 195     tlv_curr += PIM_TLV_TYPE_SIZE;
 196     option_len = PIM_TLV_GET_LENGTH(tlv_curr);
 197     tlv_curr += PIM_TLV_LENGTH_SIZE;
 198
 199     if ((tlv_curr + option_len) > tlv_pastend) {
 200       if (PIM_DEBUG_PIM_HELLO) {
 201         char src_str[100];
 202         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 203         zlog_debug("%s: long PIM hello TLV type=%d length=%d > left=%td from %s on interface %s",
 204                    __PRETTY_FUNCTION__,
 205                    option_type, option_len, tlv_pastend - tlv_curr,
 206                    src_str, ifp->name);
 207       }
 208       FREE_ADDR_LIST_THEN_RETURN(-2);
 209     }
 210
 211     if (PIM_DEBUG_PIM_HELLO) {
 212       char src_str[100];
 213       pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 214       zlog_debug("%s: parse left_size=%d: PIM hello TLV type=%d length=%d from %s on %s",
 215                  __PRETTY_FUNCTION__,
 216                  remain,
 217                  option_type, option_len,
 218                  src_str, ifp->name);
 219     }
 220
 221     switch (option_type) {
 222     case PIM_MSG_OPTION_TYPE_HOLDTIME:
 223       if (pim_tlv_parse_holdtime(ifp->name, src_addr,
 224                                  &hello_options,
 225                                  &hello_option_holdtime,
 226                                  option_len,
 227                                  tlv_curr)) {
 228         FREE_ADDR_LIST_THEN_RETURN(-3);
 229       }
 230       break;
 231     case PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY:
 232       if (pim_tlv_parse_lan_prune_delay(ifp->name, src_addr,
 233                                         &hello_options,
 234                                         &hello_option_propagation_delay,
 235                                         &hello_option_override_interval,
 236                                         option_len,
 237                                         tlv_curr)) {
 238         FREE_ADDR_LIST_THEN_RETURN(-4);
 239       }
 240       break;
 241     case PIM_MSG_OPTION_TYPE_DR_PRIORITY:
 242       if (pim_tlv_parse_dr_priority(ifp->name, src_addr,
 243                                     &hello_options,
 244                                     &hello_option_dr_priority,
 245                                     option_len,
 246                                     tlv_curr)) {
 247         FREE_ADDR_LIST_THEN_RETURN(-5);
 248       }
 249       break;
 250     case PIM_MSG_OPTION_TYPE_GENERATION_ID:
 251       if (pim_tlv_parse_generation_id(ifp->name, src_addr,
 252                                       &hello_options,
 253                                       &hello_option_generation_id,
 254                                       option_len,
 255                                       tlv_curr)) {
 256         FREE_ADDR_LIST_THEN_RETURN(-6);
 257       }
 258       break;
 259     case PIM_MSG_OPTION_TYPE_ADDRESS_LIST:
 260       if (pim_tlv_parse_addr_list(ifp->name, src_addr,
 261                                   &hello_options,
 262                                   &hello_option_addr_list,
 263                                   option_len,
 264                                   tlv_curr)) {
 265         return -7;
 266       }
 267       break;
 268     case PIM_MSG_OPTION_TYPE_DM_STATE_REFRESH:
 269       if (PIM_DEBUG_PIM_HELLO) {
 270         char src_str[100];
 271         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 272         zlog_debug("%s: ignoring PIM hello dense-mode state refresh TLV option type=%d length=%d from %s on interface %s",
 273                    __PRETTY_FUNCTION__,
 274                    option_type, option_len,
 275                    src_str, ifp->name);
 276       }
 277       break;
 278     default:
 279       if (PIM_DEBUG_PIM_HELLO) {
 280         char src_str[100];
 281         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 282         zlog_debug("%s: ignoring unknown PIM hello TLV type=%d length=%d from %s on interface %s",
 283                    __PRETTY_FUNCTION__,
 284                    option_type, option_len,
 285                    src_str, ifp->name);
 286       }
 287     }
 288
 289     tlv_curr += option_len;
 290   }
 291
 292   /*
 293     Check received PIM hello options
 294   */
 295
 296   if (PIM_DEBUG_PIM_HELLO) {
 297     tlv_trace_uint16(__PRETTY_FUNCTION__, "holdtime",
 298                      ifp->name, src_addr,
 299                      PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME),
 300                      hello_option_holdtime);
 301     tlv_trace_uint16(__PRETTY_FUNCTION__, "propagation_delay",
 302                      ifp->name, src_addr,
 303                      PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
 304                      hello_option_propagation_delay);
 305     tlv_trace_uint16(__PRETTY_FUNCTION__, "override_interval",
 306                      ifp->name, src_addr,
 307                      PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
 308                      hello_option_override_interval);
 309     tlv_trace_bool(__PRETTY_FUNCTION__, "can_disable_join_suppression",
 310                    ifp->name, src_addr,
 311                    PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
 312                    PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION));
 313     tlv_trace_uint32(__PRETTY_FUNCTION__, "dr_priority",
 314                      ifp->name, src_addr,
 315                      PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_DR_PRIORITY),
 316                      hello_option_dr_priority);
 317     tlv_trace_uint32_hex(__PRETTY_FUNCTION__, "generation_id",
 318                          ifp->name, src_addr,
 319                          PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID),
 320                          hello_option_generation_id);
 321     tlv_trace_list(__PRETTY_FUNCTION__, "address_list",
 322                    ifp->name, src_addr,
 323                    PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_ADDRESS_LIST),
 324                    hello_option_addr_list);
 325   }
 326
 327   if (!PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME)) {
 328     if (PIM_DEBUG_PIM_HELLO) {
 329       char src_str[100];
 330       pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 331       zlog_debug("%s: PIM hello missing holdtime from %s on interface %s",
 332                 __PRETTY_FUNCTION__,
 333                 src_str, ifp->name);
 334     }
 335   }
 336
 337   /*
 338     New neighbor?
 339   */
 340
 341   neigh = pim_neighbor_find(ifp, src_addr);
 342   if (!neigh) {
 343     /* Add as new neighbor */
 344
 345     neigh = pim_neighbor_add(ifp, src_addr,
 346                              hello_options,
 347                              hello_option_holdtime,
 348                              hello_option_propagation_delay,
 349                              hello_option_override_interval,
 350                              hello_option_dr_priority,
 351                              hello_option_generation_id,
 352                              hello_option_addr_list);
 353     if (!neigh) {
 354       if (PIM_DEBUG_PIM_HELLO) {
 355         char src_str[100];
 356         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 357         zlog_warn("%s: failure creating PIM neighbor %s on interface %s",
 358                   __PRETTY_FUNCTION__,
 359                   src_str, ifp->name);
 360       }
 361       FREE_ADDR_LIST_THEN_RETURN(-8);
 362     }
 363
 364     /* actual addr list has been saved under neighbor */
 365     return 0;
 366   }
 367
 368   /*
 369     Received generation ID ?
 370   */
 371
 372   if (PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID)) {
 373     /* GenID mismatch ? */
 374     if (!PIM_OPTION_IS_SET(neigh->hello_options, PIM_OPTION_MASK_GENERATION_ID) ||
 375         (hello_option_generation_id != neigh->generation_id)) {
 376
 377       /* GenID changed */
 378
 379       pim_upstream_rpf_genid_changed(neigh->source_addr);
 380
 381       /* GenID mismatch, then replace neighbor */
 382
 383       if (PIM_DEBUG_PIM_HELLO) {
 384         char src_str[100];
 385         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 386         zlog_debug("%s: GenId mismatch new=%08x old=%08x: replacing neighbor %s on %s",
 387                    __PRETTY_FUNCTION__,
 388                    hello_option_generation_id,
 389                    neigh->generation_id,
 390                    src_str, ifp->name);
 391       }
 392
 393       pim_upstream_rpf_genid_changed(neigh->source_addr);
 394
 395       pim_neighbor_delete(ifp, neigh, "GenID mismatch");
 396       neigh = pim_neighbor_add(ifp, src_addr,
 397                                hello_options,
 398                                hello_option_holdtime,
 399                                hello_option_propagation_delay,
 400                                hello_option_override_interval,
 401                                hello_option_dr_priority,
 402                                hello_option_generation_id,
 403                                hello_option_addr_list);
 404       if (!neigh) {
 405         if (PIM_DEBUG_PIM_HELLO) {
 406           char src_str[100];
 407           pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 408           zlog_debug("%s: failure re-creating PIM neighbor %s on interface %s",
 409                      __PRETTY_FUNCTION__,
 410                      src_str, ifp->name);
 411         }
 412         FREE_ADDR_LIST_THEN_RETURN(-9);
 413       }
 414       /* actual addr list is saved under neighbor */
 415       return 0;
 416
 417     } /* GenId mismatch: replace neighbor */
 418
 419   } /* GenId received */
 420
 421   /*
 422     Update existing neighbor
 423   */
 424
 425   pim_neighbor_update(neigh,
 426                       hello_options,
 427                       hello_option_holdtime,
 428                       hello_option_dr_priority,
 429                       hello_option_addr_list);
 430   /* actual addr list is saved under neighbor */
 431   return 0;
 432 }
 433
 434 int pim_hello_build_tlv(const char *ifname,
 435                         uint8_t *tlv_buf, int tlv_buf_size,
 436                         uint16_t holdtime,
 437                         uint32_t dr_priority,
 438                         uint32_t generation_id,
 439                         uint16_t propagation_delay,
 440                         uint16_t override_interval,
 441                         int can_disable_join_suppression,
 442                         struct list *ifconnected)
 443 {
 444   uint8_t *curr = tlv_buf;
 445   uint8_t *pastend = tlv_buf + tlv_buf_size;
 446   uint8_t *tmp;
 447
 448   /*
 449    * Append options
 450    */
 451
 452   /* Holdtime */
 453   curr = pim_tlv_append_uint16(curr,
 454                                pastend,
 455                                PIM_MSG_OPTION_TYPE_HOLDTIME,
 456                                holdtime);
 457   if (!curr) {
 458     if (PIM_DEBUG_PIM_HELLO) {
 459       zlog_debug("%s: could not set PIM hello Holdtime option for interface %s",
 460                  __PRETTY_FUNCTION__, ifname);
 461     }
 462     return -1;
 463   }
 464
 465   /* LAN Prune Delay */
 466   tmp = pim_tlv_append_2uint16(curr,
 467                                pastend,
 468                                PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY,
 469                                propagation_delay,
 470                                override_interval);
 471   if (!tmp) {
 472     if (PIM_DEBUG_PIM_HELLO) {
 473       zlog_debug("%s: could not set PIM LAN Prune Delay option for interface %s",
 474                  __PRETTY_FUNCTION__, ifname);
 475     }
 476     return -1;
 477   }
 478   if (can_disable_join_suppression) {
 479     *((uint8_t*)(curr) + 4) |= 0x80; /* enable T bit */
 480   }
 481   curr = tmp;
 482
 483   /* DR Priority */
 484   curr = pim_tlv_append_uint32(curr,
 485                                pastend,
 486                                PIM_MSG_OPTION_TYPE_DR_PRIORITY,
 487                                dr_priority);
 488   if (!curr) {
 489     if (PIM_DEBUG_PIM_HELLO) {
 490       zlog_debug("%s: could not set PIM hello DR Priority option for interface %s",
 491                  __PRETTY_FUNCTION__, ifname);
 492     }
 493     return -2;
 494   }
 495
 496   /* Generation ID */
 497   curr = pim_tlv_append_uint32(curr,
 498                                pastend,
 499                                PIM_MSG_OPTION_TYPE_GENERATION_ID,
 500                                generation_id);
 501   if (!curr) {
 502     if (PIM_DEBUG_PIM_HELLO) {
 503       zlog_debug("%s: could not set PIM hello Generation ID option for interface %s",
 504                  __PRETTY_FUNCTION__, ifname);
 505     }
 506     return -3;
 507   }
 508
 509   /* Secondary Address List */
 510   if (ifconnected) {
 511     curr = pim_tlv_append_addrlist_ucast(curr,
 512                                          pastend,
 513                                          ifconnected);
 514     if (!curr) {
 515       if (PIM_DEBUG_PIM_HELLO) {
 516         zlog_debug("%s: could not set PIM hello Secondary Address List option for interface %s",
 517                   __PRETTY_FUNCTION__, ifname);
 518       }
 519       return -4;
 520     }
 521   }
 522
 523   return curr - tlv_buf;
 524 }
 525
 526 /*
 527   RFC 4601: 4.3.1.  Sending Hello Messages
 528
 529   Thus, if a router needs to send a Join/Prune or Assert message on an
 530   interface on which it has not yet sent a Hello message with the
 531   currently configured IP address, then it MUST immediately send the
 532   relevant Hello message without waiting for the Hello Timer to
 533   expire, followed by the Join/Prune or Assert message.
 534 */
 535 void pim_hello_require(struct interface *ifp)
 536 {
 537   struct pim_interface *pim_ifp;
 538
 539   zassert(ifp);
 540
 541   pim_ifp = ifp->info;
 542
 543   zassert(pim_ifp);
 544
 545   if (pim_ifp->pim_ifstat_hello_sent)
 546     return;
 547
 548   pim_hello_restart_now(ifp); /* Send hello and restart timer */
 549 }