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