lib/bfd.c

   1 /**
   2  * bfd.c: BFD handling routines
   3  *
   4  * @copyright Copyright (C) 2015 Cumulus Networks, Inc.
   5  *
   6  * This file is part of GNU Zebra.
   7  *
   8  * GNU Zebra is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * GNU Zebra is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "command.h"
  26 #include "memory.h"
  27 #include "prefix.h"
  28 #include "thread.h"
  29 #include "stream.h"
  30 #include "zclient.h"
  31 #include "table.h"
  32 #include "vty.h"
  33 #include "bfd.h"
  34
  35 DEFINE_MTYPE_STATIC(LIB, BFD_INFO, "BFD info")
  36
  37 static int bfd_debug = 0;
  38 static struct bfd_gbl bfd_gbl;
  39
  40 /*
  41  * bfd_gbl_init - Initialize the BFD global structure
  42  */
  43 void bfd_gbl_init(void)
  44 {
  45         memset(&bfd_gbl, 0, sizeof(struct bfd_gbl));
  46 }
  47
  48 /*
  49  * bfd_gbl_exit - Called when daemon exits
  50  */
  51 void bfd_gbl_exit(void)
  52 {
  53         SET_FLAG(bfd_gbl.flags, BFD_GBL_FLAG_IN_SHUTDOWN);
  54 }
  55
  56 /*
  57  * bfd_info_create - Allocate the BFD information
  58  */
  59 struct bfd_info *bfd_info_create(void)
  60 {
  61         struct bfd_info *bfd_info;
  62
  63         bfd_info = XCALLOC(MTYPE_BFD_INFO, sizeof(struct bfd_info));
  64         assert(bfd_info);
  65
  66         bfd_info->status = BFD_STATUS_UNKNOWN;
  67         bfd_info->type = BFD_TYPE_NOT_CONFIGURED;
  68         bfd_info->last_update = 0;
  69         return bfd_info;
  70 }
  71
  72 /*
  73  * bfd_info_free - Free the BFD information.
  74  */
  75 void bfd_info_free(struct bfd_info **bfd_info)
  76 {
  77         XFREE(MTYPE_BFD_INFO, *bfd_info);
  78 }
  79
  80 /*
  81  * bfd_validate_param - Validate the BFD paramter information.
  82  */
  83 int bfd_validate_param(struct vty *vty, const char *dm_str, const char *rx_str,
  84                        const char *tx_str, uint8_t *dm_val, uint32_t *rx_val,
  85                        uint32_t *tx_val)
  86 {
  87         *dm_val = strtoul(dm_str, NULL, 10);
  88         *rx_val = strtoul(rx_str, NULL, 10);
  89         *tx_val = strtoul(tx_str, NULL, 10);
  90         return CMD_SUCCESS;
  91 }
  92
  93 /*
  94  * bfd_set_param - Set the configured BFD paramter values
  95  */
  96 void bfd_set_param(struct bfd_info **bfd_info, uint32_t min_rx, uint32_t min_tx,
  97                    uint8_t detect_mult, const char *profile, int defaults,
  98                    int *command)
  99 {
 100         if (!*bfd_info) {
 101                 *bfd_info = bfd_info_create();
 102                 *command = ZEBRA_BFD_DEST_REGISTER;
 103         } else {
 104                 if (((*bfd_info)->required_min_rx != min_rx)
 105                     || ((*bfd_info)->desired_min_tx != min_tx)
 106                     || ((*bfd_info)->detect_mult != detect_mult)
 107                     || ((*bfd_info)->profile[0] == 0 && profile)
 108                     || ((*bfd_info)->profile[0] && profile == NULL)
 109                     || (profile && (*bfd_info)->profile[0]
 110                         && strcmp((*bfd_info)->profile, profile)))
 111                         *command = ZEBRA_BFD_DEST_UPDATE;
 112         }
 113
 114         if (*command) {
 115                 (*bfd_info)->required_min_rx = min_rx;
 116                 (*bfd_info)->desired_min_tx = min_tx;
 117                 (*bfd_info)->detect_mult = detect_mult;
 118                 if (profile)
 119                         strlcpy((*bfd_info)->profile, profile,
 120                                 BFD_PROFILE_NAME_LEN);
 121                 else
 122                         (*bfd_info)->profile[0] = '\0';
 123         }
 124
 125         if (!defaults)
 126                 SET_FLAG((*bfd_info)->flags, BFD_FLAG_PARAM_CFG);
 127         else
 128                 UNSET_FLAG((*bfd_info)->flags, BFD_FLAG_PARAM_CFG);
 129 }
 130
 131 /*
 132  * bfd_peer_sendmsg - Format and send a peer register/Unregister
 133  *                    command to Zebra to be forwarded to BFD
 134  *
 135  * DEPRECATED: use zclient_bfd_command instead
 136  */
 137 void bfd_peer_sendmsg(struct zclient *zclient, struct bfd_info *bfd_info,
 138                       int family, void *dst_ip, void *src_ip, char *if_name,
 139                       int ttl, int multihop, int cbit, int command,
 140                       int set_flag, vrf_id_t vrf_id)
 141 {
 142         struct bfd_session_arg args = {};
 143         size_t addrlen;
 144
 145         /* Individual reg/dereg messages are suppressed during shutdown. */
 146         if (CHECK_FLAG(bfd_gbl.flags, BFD_GBL_FLAG_IN_SHUTDOWN)) {
 147                 if (bfd_debug)
 148                         zlog_debug(
 149                                 "%s: Suppressing BFD peer reg/dereg messages",
 150                                 __func__);
 151                 return;
 152         }
 153
 154         /* Check socket. */
 155         if (!zclient || zclient->sock < 0) {
 156                 if (bfd_debug)
 157                         zlog_debug(
 158                                 "%s: Can't send BFD peer register, Zebra client not established",
 159                                 __func__);
 160                 return;
 161         }
 162
 163         /* Fill in all arguments. */
 164         args.ttl = ttl;
 165         args.cbit = cbit;
 166         args.family = family;
 167         args.mhop = multihop;
 168         args.vrf_id = vrf_id;
 169         args.command = command;
 170         args.set_flag = set_flag;
 171         args.bfd_info = bfd_info;
 172         if (args.bfd_info) {
 173                 args.min_rx = bfd_info->required_min_rx;
 174                 args.min_tx = bfd_info->desired_min_tx;
 175                 args.detection_multiplier = bfd_info->detect_mult;
 176                 if (bfd_info->profile[0]) {
 177                         args.profilelen = strlen(bfd_info->profile);
 178                         strlcpy(args.profile, bfd_info->profile,
 179                                 sizeof(args.profile));
 180                 }
 181         }
 182
 183         addrlen = family == AF_INET ? sizeof(struct in_addr)
 184                                     : sizeof(struct in6_addr);
 185         memcpy(&args.dst, dst_ip, addrlen);
 186         if (src_ip)
 187                 memcpy(&args.src, src_ip, addrlen);
 188
 189         if (if_name)
 190                 args.ifnamelen =
 191                         strlcpy(args.ifname, if_name, sizeof(args.ifname));
 192
 193         zclient_bfd_command(zclient, &args);
 194 }
 195
 196 /*
 197  * bfd_get_command_dbg_str - Convert command to a debug string.
 198  */
 199 const char *bfd_get_command_dbg_str(int command)
 200 {
 201         switch (command) {
 202         case ZEBRA_BFD_DEST_REGISTER:
 203                 return "Register";
 204         case ZEBRA_BFD_DEST_DEREGISTER:
 205                 return "Deregister";
 206         case ZEBRA_BFD_DEST_UPDATE:
 207                 return "Update";
 208         default:
 209                 return "Unknown";
 210         }
 211 }
 212
 213 /*
 214  * bfd_get_peer_info - Extract the Peer information for which the BFD session
 215  *                     went down from the message sent from Zebra to clients.
 216  */
 217 struct interface *bfd_get_peer_info(struct stream *s, struct prefix *dp,
 218                                     struct prefix *sp, int *status,
 219                                     int *remote_cbit,
 220                                     vrf_id_t vrf_id)
 221 {
 222         unsigned int ifindex;
 223         struct interface *ifp = NULL;
 224         int plen;
 225         int local_remote_cbit;
 226
 227         /*
 228          * If the ifindex lookup fails the
 229          * rest of the data in the stream is
 230          * not read.  All examples of this function
 231          * call immediately use the dp->family which
 232          * is not good.  Ensure we are not using
 233          * random data
 234          */
 235         memset(dp, 0, sizeof(*dp));
 236         memset(sp, 0, sizeof(*sp));
 237
 238         /* Get interface index. */
 239         ifindex = stream_getl(s);
 240
 241         /* Lookup index. */
 242         if (ifindex != 0) {
 243                 ifp = if_lookup_by_index(ifindex, vrf_id);
 244                 if (ifp == NULL) {
 245                         if (bfd_debug)
 246                                 zlog_debug(
 247                                         "zebra_interface_bfd_read: Can't find interface by ifindex: %d ",
 248                                         ifindex);
 249                         return NULL;
 250                 }
 251         }
 252
 253         /* Fetch destination address. */
 254         dp->family = stream_getc(s);
 255
 256         plen = prefix_blen(dp);
 257         stream_get(&dp->u.prefix, s, plen);
 258         dp->prefixlen = stream_getc(s);
 259
 260         /* Get BFD status. */
 261         *status = stream_getl(s);
 262
 263         sp->family = stream_getc(s);
 264
 265         plen = prefix_blen(sp);
 266         stream_get(&sp->u.prefix, s, plen);
 267         sp->prefixlen = stream_getc(s);
 268
 269         local_remote_cbit = stream_getc(s);
 270         if (remote_cbit)
 271                 *remote_cbit = local_remote_cbit;
 272         return ifp;
 273 }
 274
 275 /*
 276  * bfd_get_status_str - Convert BFD status to a display string.
 277  */
 278 const char *bfd_get_status_str(int status)
 279 {
 280         switch (status) {
 281         case BFD_STATUS_DOWN:
 282                 return "Down";
 283         case BFD_STATUS_UP:
 284                 return "Up";
 285         case BFD_STATUS_ADMIN_DOWN:
 286                 return "Admin Down";
 287         case BFD_STATUS_UNKNOWN:
 288         default:
 289                 return "Unknown";
 290         }
 291 }
 292
 293 /*
 294  * bfd_last_update - Calculate the last BFD update time and convert it
 295  *                   into a dd:hh:mm:ss display format.
 296  */
 297 static void bfd_last_update(time_t last_update, char *buf, size_t len)
 298 {
 299         time_t curr;
 300         time_t diff;
 301         struct tm tm;
 302         struct timeval tv;
 303
 304         /* If no BFD satatus update has ever been received, print `never'. */
 305         if (last_update == 0) {
 306                 snprintf(buf, len, "never");
 307                 return;
 308         }
 309
 310         /* Get current time. */
 311         monotime(&tv);
 312         curr = tv.tv_sec;
 313         diff = curr - last_update;
 314         gmtime_r(&diff, &tm);
 315
 316         snprintf(buf, len, "%d:%02d:%02d:%02d", tm.tm_yday, tm.tm_hour,
 317                  tm.tm_min, tm.tm_sec);
 318 }
 319
 320 /*
 321  * bfd_show_param - Show the BFD parameter information.
 322  */
 323 void bfd_show_param(struct vty *vty, struct bfd_info *bfd_info, int bfd_tag,
 324                     int extra_space, bool use_json, json_object *json_obj)
 325 {
 326         json_object *json_bfd = NULL;
 327
 328         if (!bfd_info)
 329                 return;
 330
 331         if (use_json) {
 332                 if (bfd_tag)
 333                         json_bfd = json_object_new_object();
 334                 else
 335                         json_bfd = json_obj;
 336
 337                 json_object_int_add(json_bfd, "detectMultiplier",
 338                                     bfd_info->detect_mult);
 339                 json_object_int_add(json_bfd, "rxMinInterval",
 340                                     bfd_info->required_min_rx);
 341                 json_object_int_add(json_bfd, "txMinInterval",
 342                                     bfd_info->desired_min_tx);
 343                 if (bfd_tag)
 344                         json_object_object_add(json_obj, "peerBfdInfo",
 345                                                json_bfd);
 346         } else {
 347                 vty_out(vty,
 348                         "  %s%sDetect Multiplier: %d, Min Rx interval: %d, Min Tx interval: %d\n",
 349                         (extra_space) ? "  " : "", (bfd_tag) ? "BFD: " : "  ",
 350                         bfd_info->detect_mult, bfd_info->required_min_rx,
 351                         bfd_info->desired_min_tx);
 352         }
 353 }
 354
 355 /*
 356  * bfd_show_status - Show the BFD status information.
 357  */
 358 static void bfd_show_status(struct vty *vty, struct bfd_info *bfd_info,
 359                             int bfd_tag, int extra_space, bool use_json,
 360                             json_object *json_bfd)
 361 {
 362         char time_buf[32];
 363
 364         if (!bfd_info)
 365                 return;
 366
 367         bfd_last_update(bfd_info->last_update, time_buf, 32);
 368         if (use_json) {
 369                 json_object_string_add(json_bfd, "status",
 370                                        bfd_get_status_str(bfd_info->status));
 371                 json_object_string_add(json_bfd, "lastUpdate", time_buf);
 372         } else {
 373                 vty_out(vty, "  %s%sStatus: %s, Last update: %s\n",
 374                         (extra_space) ? "  " : "", (bfd_tag) ? "BFD: " : "  ",
 375                         bfd_get_status_str(bfd_info->status), time_buf);
 376         }
 377 }
 378
 379 /*
 380  * bfd_show_info - Show the BFD information.
 381  */
 382 void bfd_show_info(struct vty *vty, struct bfd_info *bfd_info, int multihop,
 383                    int extra_space, bool use_json, json_object *json_obj)
 384 {
 385         json_object *json_bfd = NULL;
 386
 387         if (!bfd_info)
 388                 return;
 389
 390         if (use_json) {
 391                 json_bfd = json_object_new_object();
 392                 if (multihop)
 393                         json_object_string_add(json_bfd, "type", "multi hop");
 394                 else
 395                         json_object_string_add(json_bfd, "type", "single hop");
 396         } else {
 397                 vty_out(vty, "  %sBFD: Type: %s\n", (extra_space) ? "  " : "",
 398                         (multihop) ? "multi hop" : "single hop");
 399         }
 400
 401         bfd_show_param(vty, bfd_info, 0, extra_space, use_json, json_bfd);
 402         bfd_show_status(vty, bfd_info, 0, extra_space, use_json, json_bfd);
 403
 404         if (use_json)
 405                 json_object_object_add(json_obj, "peerBfdInfo", json_bfd);
 406         else
 407                 vty_out(vty, "\n");
 408 }
 409
 410 /*
 411  * bfd_client_sendmsg - Format and send a client register
 412  *                    command to Zebra to be forwarded to BFD
 413  */
 414 void bfd_client_sendmsg(struct zclient *zclient, int command,
 415                         vrf_id_t vrf_id)
 416 {
 417         struct stream *s;
 418         enum zclient_send_status ret;
 419
 420         /* Check socket. */
 421         if (!zclient || zclient->sock < 0) {
 422                 if (bfd_debug)
 423                         zlog_debug(
 424                                 "%s: Can't send BFD client register, Zebra client not established",
 425                                 __func__);
 426                 return;
 427         }
 428
 429         s = zclient->obuf;
 430         stream_reset(s);
 431         zclient_create_header(s, command, vrf_id);
 432
 433         stream_putl(s, getpid());
 434
 435         stream_putw_at(s, 0, stream_get_endp(s));
 436
 437         ret = zclient_send_message(zclient);
 438
 439         if (ret == ZCLIENT_SEND_FAILURE) {
 440                 if (bfd_debug)
 441                         zlog_debug(
 442                                 "bfd_client_sendmsg %ld: zclient_send_message() failed",
 443                                 (long)getpid());
 444                 return;
 445         }
 446
 447         return;
 448 }
 449
 450 int zclient_bfd_command(struct zclient *zc, struct bfd_session_arg *args)
 451 {
 452         struct stream *s;
 453         size_t addrlen;
 454
 455         /* Individual reg/dereg messages are suppressed during shutdown. */
 456         if (CHECK_FLAG(bfd_gbl.flags, BFD_GBL_FLAG_IN_SHUTDOWN)) {
 457                 if (bfd_debug)
 458                         zlog_debug(
 459                                 "%s: Suppressing BFD peer reg/dereg messages",
 460                                 __func__);
 461                 return -1;
 462         }
 463
 464         /* Check socket. */
 465         if (!zc || zc->sock < 0) {
 466                 if (bfd_debug)
 467                         zlog_debug("%s: zclient unavailable", __func__);
 468                 return -1;
 469         }
 470
 471         s = zc->obuf;
 472         stream_reset(s);
 473
 474         /* Create new message. */
 475         zclient_create_header(s, args->command, args->vrf_id);
 476         stream_putl(s, getpid());
 477
 478         /* Encode destination address. */
 479         stream_putw(s, args->family);
 480         addrlen = (args->family == AF_INET) ? sizeof(struct in_addr)
 481                                             : sizeof(struct in6_addr);
 482         stream_put(s, &args->dst, addrlen);
 483
 484         /*
 485          * For more BFD integration protocol details, see function
 486          * `_ptm_msg_read` in `bfdd/ptm_adapter.c`.
 487          */
 488 #if HAVE_BFDD > 0
 489         /* Session timers. */
 490         stream_putl(s, args->min_rx);
 491         stream_putl(s, args->min_tx);
 492         stream_putc(s, args->detection_multiplier);
 493
 494         /* Is multi hop? */
 495         stream_putc(s, args->mhop != 0);
 496
 497         /* Source address. */
 498         stream_putw(s, args->family);
 499         stream_put(s, &args->src, addrlen);
 500
 501         /* Send the expected TTL. */
 502         stream_putc(s, args->ttl);
 503
 504         /* Send interface name if any. */
 505         stream_putc(s, args->ifnamelen);
 506         if (args->ifnamelen)
 507                 stream_put(s, args->ifname, args->ifnamelen);
 508
 509         /* Send the C bit indicator. */
 510         stream_putc(s, args->cbit);
 511
 512         /* Send profile name if any. */
 513         stream_putc(s, args->profilelen);
 514         if (args->profilelen)
 515                 stream_put(s, args->profile, args->profilelen);
 516 #else /* PTM BFD */
 517         /* Encode timers if this is a registration message. */
 518         if (args->command != ZEBRA_BFD_DEST_DEREGISTER) {
 519                 stream_putl(s, args->min_rx);
 520                 stream_putl(s, args->min_tx);
 521                 stream_putc(s, args->detection_multiplier);
 522         }
 523
 524         if (args->mhop) {
 525                 /* Multi hop indicator. */
 526                 stream_putc(s, 1);
 527
 528                 /* Multi hop always sends the source address. */
 529                 stream_putw(s, args->family);
 530                 stream_put(s, &args->src, addrlen);
 531
 532                 /* Send the expected TTL. */
 533                 stream_putc(s, args->ttl);
 534         } else {
 535                 /* Multi hop indicator. */
 536                 stream_putc(s, 0);
 537
 538                 /* Single hop only sends the source address when IPv6. */
 539                 if (args->family == AF_INET6) {
 540                         stream_putw(s, args->family);
 541                         stream_put(s, &args->src, addrlen);
 542                 }
 543
 544                 /* Send interface name if any. */
 545                 stream_putc(s, args->ifnamelen);
 546                 if (args->ifnamelen)
 547                         stream_put(s, args->ifname, args->ifnamelen);
 548         }
 549 #endif /* HAVE_BFDD */
 550
 551         /* Finish the message by writing the size. */
 552         stream_putw_at(s, 0, stream_get_endp(s));
 553
 554         /* Send message to zebra. */
 555         if (zclient_send_message(zc) == ZCLIENT_SEND_FAILURE) {
 556                 if (bfd_debug)
 557                         zlog_debug("%s: zclient_send_message failed", __func__);
 558                 return -1;
 559         }
 560
 561         /* Write registration indicator into data structure. */
 562         if (args->bfd_info && args->set_flag) {
 563                 if (args->command == ZEBRA_BFD_DEST_REGISTER)
 564                         SET_FLAG(args->bfd_info->flags, BFD_FLAG_BFD_REG);
 565                 else if (args->command == ZEBRA_BFD_DEST_DEREGISTER)
 566                         UNSET_FLAG(args->bfd_info->flags, BFD_FLAG_BFD_REG);
 567         }
 568
 569         return 0;
 570 }