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[INET_ADDRSTRLEN];
  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[INET_ADDRSTRLEN];
  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[INET_ADDRSTRLEN];
  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[INET_ADDRSTRLEN];
  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[INET_ADDRSTRLEN];
  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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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[INET_ADDRSTRLEN];
 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                              PIM_NEIGHBOR_SEND_DELAY);
 354     if (!neigh) {
 355       if (PIM_DEBUG_PIM_HELLO) {
 356         char src_str[INET_ADDRSTRLEN];
 357         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 358         zlog_warn("%s: failure creating PIM neighbor %s on interface %s",
 359                   __PRETTY_FUNCTION__,
 360                   src_str, ifp->name);
 361       }
 362       FREE_ADDR_LIST_THEN_RETURN(-8);
 363     }
 364
 365     /* actual addr list has been saved under neighbor */
 366     return 0;
 367   }
 368
 369   /*
 370     Received generation ID ?
 371   */
 372
 373   if (PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID)) {
 374     /* GenID mismatch ? */
 375     if (!PIM_OPTION_IS_SET(neigh->hello_options, PIM_OPTION_MASK_GENERATION_ID) ||
 376         (hello_option_generation_id != neigh->generation_id)) {
 377       /* GenID mismatch, then replace neighbor */
 378
 379       if (PIM_DEBUG_PIM_HELLO) {
 380         char src_str[INET_ADDRSTRLEN];
 381         pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 382         zlog_debug("%s: GenId mismatch new=%08x old=%08x: replacing neighbor %s on %s",
 383                    __PRETTY_FUNCTION__,
 384                    hello_option_generation_id,
 385                    neigh->generation_id,
 386                    src_str, ifp->name);
 387       }
 388
 389       pim_upstream_rpf_genid_changed(neigh->source_addr);
 390
 391       pim_neighbor_delete(ifp, neigh, "GenID mismatch");
 392       neigh = pim_neighbor_add(ifp, src_addr,
 393                                hello_options,
 394                                hello_option_holdtime,
 395                                hello_option_propagation_delay,
 396                                hello_option_override_interval,
 397                                hello_option_dr_priority,
 398                                hello_option_generation_id,
 399                                hello_option_addr_list,
 400                                PIM_NEIGHBOR_SEND_NOW);
 401       if (!neigh) {
 402         if (PIM_DEBUG_PIM_HELLO) {
 403           char src_str[INET_ADDRSTRLEN];
 404           pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
 405           zlog_debug("%s: failure re-creating PIM neighbor %s on interface %s",
 406                      __PRETTY_FUNCTION__,
 407                      src_str, ifp->name);
 408         }
 409         FREE_ADDR_LIST_THEN_RETURN(-9);
 410       }
 411       /* actual addr list is saved under neighbor */
 412       return 0;
 413
 414     } /* GenId mismatch: replace neighbor */
 415
 416   } /* GenId received */
 417
 418   /*
 419     Update existing neighbor
 420   */
 421
 422   pim_neighbor_update(neigh,
 423                       hello_options,
 424                       hello_option_holdtime,
 425                       hello_option_dr_priority,
 426                       hello_option_addr_list);
 427   /* actual addr list is saved under neighbor */
 428   return 0;
 429 }
 430
 431 int pim_hello_build_tlv(struct interface *ifp,
 432                         uint8_t *tlv_buf, int tlv_buf_size,
 433                         uint16_t holdtime,
 434                         uint32_t dr_priority,
 435                         uint32_t generation_id,
 436                         uint16_t propagation_delay,
 437                         uint16_t override_interval,
 438                         int can_disable_join_suppression)
 439 {
 440   uint8_t *curr = tlv_buf;
 441   uint8_t *pastend = tlv_buf + tlv_buf_size;
 442   uint8_t *tmp;
 443
 444   /*
 445    * Append options
 446    */
 447
 448   /* Holdtime */
 449   curr = pim_tlv_append_uint16(curr,
 450                                pastend,
 451                                PIM_MSG_OPTION_TYPE_HOLDTIME,
 452                                holdtime);
 453   if (!curr) {
 454     if (PIM_DEBUG_PIM_HELLO) {
 455       zlog_debug("%s: could not set PIM hello Holdtime option for interface %s",
 456                  __PRETTY_FUNCTION__, ifp->name);
 457     }
 458     return -1;
 459   }
 460
 461   /* LAN Prune Delay */
 462   tmp = pim_tlv_append_2uint16(curr,
 463                                pastend,
 464                                PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY,
 465                                propagation_delay,
 466                                override_interval);
 467   if (!tmp) {
 468     if (PIM_DEBUG_PIM_HELLO) {
 469       zlog_debug("%s: could not set PIM LAN Prune Delay option for interface %s",
 470                  __PRETTY_FUNCTION__, ifp->name);
 471     }
 472     return -1;
 473   }
 474   if (can_disable_join_suppression) {
 475     *((uint8_t*)(curr) + 4) |= 0x80; /* enable T bit */
 476   }
 477   curr = tmp;
 478
 479   /* DR Priority */
 480   curr = pim_tlv_append_uint32(curr,
 481                                pastend,
 482                                PIM_MSG_OPTION_TYPE_DR_PRIORITY,
 483                                dr_priority);
 484   if (!curr) {
 485     if (PIM_DEBUG_PIM_HELLO) {
 486       zlog_debug("%s: could not set PIM hello DR Priority option for interface %s",
 487                  __PRETTY_FUNCTION__, ifp->name);
 488     }
 489     return -2;
 490   }
 491
 492   /* Generation ID */
 493   curr = pim_tlv_append_uint32(curr,
 494                                pastend,
 495                                PIM_MSG_OPTION_TYPE_GENERATION_ID,
 496                                generation_id);
 497   if (!curr) {
 498     if (PIM_DEBUG_PIM_HELLO) {
 499       zlog_debug("%s: could not set PIM hello Generation ID option for interface %s",
 500                  __PRETTY_FUNCTION__, ifp->name);
 501     }
 502     return -3;
 503   }
 504
 505   /* Secondary Address List */
 506   if (ifp->connected->count) {
 507     curr = pim_tlv_append_addrlist_ucast(curr,
 508                                          pastend,
 509                                          ifp->connected,
 510                                          AF_INET);
 511     if (!curr) {
 512       if (PIM_DEBUG_PIM_HELLO) {
 513         zlog_debug("%s: could not set PIM hello v4 Secondary Address List option for interface %s",
 514                   __PRETTY_FUNCTION__, ifp->name);
 515       }
 516       return -4;
 517     }
 518     if (pimg->send_v6_secondary)
 519       {
 520         curr = pim_tlv_append_addrlist_ucast(curr,
 521                                              pastend,
 522                                              ifp->connected,
 523                                              AF_INET6);
 524         if (!curr) {
 525           if (PIM_DEBUG_PIM_HELLO) {
 526             zlog_debug("%s: could not sent PIM hello v6 secondary Address List option for interface %s",
 527                        __PRETTY_FUNCTION__, ifp->name);
 528           }
 529           return -4;
 530         }
 531       }
 532   }
 533
 534   return curr - tlv_buf;
 535 }
 536
 537 /*
 538   RFC 4601: 4.3.1.  Sending Hello Messages
 539
 540   Thus, if a router needs to send a Join/Prune or Assert message on an
 541   interface on which it has not yet sent a Hello message with the
 542   currently configured IP address, then it MUST immediately send the
 543   relevant Hello message without waiting for the Hello Timer to
 544   expire, followed by the Join/Prune or Assert message.
 545 */
 546 void pim_hello_require(struct interface *ifp)
 547 {
 548   struct pim_interface *pim_ifp;
 549
 550   zassert(ifp);
 551
 552   pim_ifp = ifp->info;
 553
 554   zassert(pim_ifp);
 555
 556   if (pim_ifp->pim_ifstat_hello_sent)
 557     return;
 558
 559   pim_hello_restart_now(ifp); /* Send hello and restart timer */
 560 }