bfdd/ptm_adapter.c

   1 /*
   2  * BFD PTM adapter code
   3  * Copyright (C) 2018 Network Device Education Foundation, Inc. ("NetDEF")
   4  *
   5  * FRR is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2, or (at your option) any
   8  * later version.
   9  *
  10  * FRR 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 FRR; see the file COPYING.  If not, write to the Free
  17  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "lib/libfrr.h"
  24 #include "lib/queue.h"
  25 #include "lib/stream.h"
  26 #include "lib/zclient.h"
  27 #include "lib/printfrr.h"
  28
  29 #include "lib/bfd.h"
  30
  31 #include "bfd.h"
  32
  33 /*
  34  * Data structures
  35  */
  36 struct ptm_client_notification {
  37         struct bfd_session *pcn_bs;
  38         struct ptm_client *pcn_pc;
  39
  40         TAILQ_ENTRY(ptm_client_notification) pcn_entry;
  41 };
  42 TAILQ_HEAD(pcnqueue, ptm_client_notification);
  43
  44 struct ptm_client {
  45         uint32_t pc_pid;
  46         struct pcnqueue pc_pcnqueue;
  47
  48         TAILQ_ENTRY(ptm_client) pc_entry;
  49 };
  50 TAILQ_HEAD(pcqueue, ptm_client);
  51
  52 static struct pcqueue pcqueue;
  53 static struct zclient *zclient;
  54
  55
  56 /*
  57  * Prototypes
  58  */
  59 static int _ptm_msg_address(struct stream *msg, int family, const void *addr);
  60
  61 static void _ptm_msg_read_address(struct stream *msg, struct sockaddr_any *sa);
  62 static int _ptm_msg_read(struct stream *msg, int command, vrf_id_t vrf_id,
  63                          struct bfd_peer_cfg *bpc, struct ptm_client **pc);
  64
  65 static struct ptm_client *pc_lookup(uint32_t pid);
  66 static struct ptm_client *pc_new(uint32_t pid);
  67 static void pc_free(struct ptm_client *pc);
  68 static void pc_free_all(void);
  69 static struct ptm_client_notification *pcn_new(struct ptm_client *pc,
  70                                                struct bfd_session *bs);
  71 static struct ptm_client_notification *pcn_lookup(struct ptm_client *pc,
  72                                                   struct bfd_session *bs);
  73 static void pcn_free(struct ptm_client_notification *pcn);
  74
  75
  76 static void bfdd_dest_register(struct stream *msg, vrf_id_t vrf_id);
  77 static void bfdd_dest_deregister(struct stream *msg, vrf_id_t vrf_id);
  78 static void bfdd_client_register(struct stream *msg);
  79 static void bfdd_client_deregister(struct stream *msg);
  80
  81 /*
  82  * Functions
  83  */
  84 static void debug_printbpc(const struct bfd_peer_cfg *bpc, const char *fmt, ...)
  85 {
  86         char timers[3][128] = {};
  87         char minttl_str[32] = {};
  88         char addr[3][128] = {};
  89         char profile[128] = {};
  90         char cbit_str[32];
  91         char msgbuf[512];
  92         va_list vl;
  93
  94         /* Avoid debug calculations if it's disabled. */
  95         if (bglobal.debug_zebra == false)
  96                 return;
  97
  98         snprintf(addr[0], sizeof(addr[0]), "peer:%s", satostr(&bpc->bpc_peer));
  99         if (bpc->bpc_local.sa_sin.sin_family)
 100                 snprintf(addr[1], sizeof(addr[1]), " local:%s",
 101                          satostr(&bpc->bpc_local));
 102
 103         if (bpc->bpc_has_localif)
 104                 snprintf(addr[2], sizeof(addr[2]), " ifname:%s",
 105                          bpc->bpc_localif);
 106
 107         if (bpc->bpc_has_vrfname)
 108                 snprintf(addr[2], sizeof(addr[2]), " vrf:%s", bpc->bpc_vrfname);
 109
 110         if (bpc->bpc_has_recvinterval)
 111                 snprintfrr(timers[0], sizeof(timers[0]), " rx:%" PRIu64,
 112                            bpc->bpc_recvinterval);
 113
 114         if (bpc->bpc_has_txinterval)
 115                 snprintfrr(timers[1], sizeof(timers[1]), " tx:%" PRIu64,
 116                            bpc->bpc_recvinterval);
 117
 118         if (bpc->bpc_has_detectmultiplier)
 119                 snprintf(timers[2], sizeof(timers[2]), " detect-multiplier:%d",
 120                          bpc->bpc_detectmultiplier);
 121
 122         snprintf(cbit_str, sizeof(cbit_str), " cbit:0x%02x", bpc->bpc_cbit);
 123
 124         if (bpc->bpc_has_minimum_ttl)
 125                 snprintf(minttl_str, sizeof(minttl_str), " minimum-ttl:%d",
 126                          bpc->bpc_minimum_ttl);
 127
 128         if (bpc->bpc_has_profile)
 129                 snprintf(profile, sizeof(profile), " profile:%s",
 130                          bpc->bpc_profile);
 131
 132         va_start(vl, fmt);
 133         vsnprintf(msgbuf, sizeof(msgbuf), fmt, vl);
 134         va_end(vl);
 135
 136         zlog_debug("%s [mhop:%s %s%s%s%s%s%s%s%s%s]", msgbuf,
 137                    bpc->bpc_mhop ? "yes" : "no", addr[0], addr[1], addr[2],
 138                    timers[0], timers[1], timers[2], cbit_str, minttl_str,
 139                    profile);
 140 }
 141
 142 static void _ptm_bfd_session_del(struct bfd_session *bs, uint8_t diag)
 143 {
 144         if (bglobal.debug_peer_event)
 145                 zlog_debug("session-delete: %s", bs_to_string(bs));
 146
 147         /* Change state and notify peer. */
 148         bs->ses_state = PTM_BFD_DOWN;
 149         bs->local_diag = diag;
 150         ptm_bfd_snd(bs, 0);
 151
 152         /* Session reached refcount == 0, lets delete it. */
 153         if (bs->refcount == 0) {
 154                 /*
 155                  * Sanity check: if there is a refcount bug, we can't delete
 156                  * the session a user configured manually. Lets leave a
 157                  * message here so we can catch the bug if it exists.
 158                  */
 159                 if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG)) {
 160                         zlog_err(
 161                                 "ptm-del-session: [%s] session refcount is zero but it was configured by CLI",
 162                                 bs_to_string(bs));
 163                 } else {
 164                         control_notify_config(BCM_NOTIFY_CONFIG_DELETE, bs);
 165                         bfd_session_free(bs);
 166                 }
 167         }
 168 }
 169
 170 static int _ptm_msg_address(struct stream *msg, int family, const void *addr)
 171 {
 172         stream_putc(msg, family);
 173
 174         switch (family) {
 175         case AF_INET:
 176                 stream_put(msg, addr, sizeof(struct in_addr));
 177                 stream_putc(msg, 32);
 178                 break;
 179
 180         case AF_INET6:
 181                 stream_put(msg, addr, sizeof(struct in6_addr));
 182                 stream_putc(msg, 128);
 183                 break;
 184
 185         default:
 186                 assert(0);
 187                 break;
 188         }
 189
 190         return 0;
 191 }
 192
 193 int ptm_bfd_notify(struct bfd_session *bs, uint8_t notify_state)
 194 {
 195         struct stream *msg;
 196
 197         bs->stats.znotification++;
 198
 199         /*
 200          * Message format:
 201          * - header: command, vrf
 202          * - l: interface index
 203          * - c: family
 204          *   - AF_INET:
 205          *     - 4 bytes: ipv4
 206          *   - AF_INET6:
 207          *     - 16 bytes: ipv6
 208          *   - c: prefix length
 209          * - l: bfd status
 210          * - c: family
 211          *   - AF_INET:
 212          *     - 4 bytes: ipv4
 213          *   - AF_INET6:
 214          *     - 16 bytes: ipv6
 215          *   - c: prefix length
 216          * - c: cbit
 217          *
 218          * Commands: ZEBRA_BFD_DEST_REPLAY
 219          *
 220          * q(64), l(32), w(16), c(8)
 221          */
 222         msg = zclient->obuf;
 223         stream_reset(msg);
 224
 225         /* TODO: VRF handling */
 226         if (bs->vrf)
 227                 zclient_create_header(msg, ZEBRA_BFD_DEST_REPLAY, bs->vrf->vrf_id);
 228         else
 229                 zclient_create_header(msg, ZEBRA_BFD_DEST_REPLAY, VRF_DEFAULT);
 230
 231         /* This header will be handled by `zebra_ptm.c`. */
 232         stream_putl(msg, ZEBRA_INTERFACE_BFD_DEST_UPDATE);
 233
 234         /* NOTE: Interface is a shortcut to avoid comparing source address. */
 235         if (bs->ifp != NULL)
 236                 stream_putl(msg, bs->ifp->ifindex);
 237         else
 238                 stream_putl(msg, IFINDEX_INTERNAL);
 239
 240         /* BFD destination prefix information. */
 241         _ptm_msg_address(msg, bs->key.family, &bs->key.peer);
 242
 243         /* BFD status */
 244         switch (notify_state) {
 245         case PTM_BFD_UP:
 246                 stream_putl(msg, BFD_STATUS_UP);
 247                 break;
 248
 249         case PTM_BFD_ADM_DOWN:
 250                 stream_putl(msg, BFD_STATUS_ADMIN_DOWN);
 251                 break;
 252
 253         case PTM_BFD_DOWN:
 254         case PTM_BFD_INIT:
 255                 stream_putl(msg, BFD_STATUS_DOWN);
 256                 break;
 257
 258         default:
 259                 stream_putl(msg, BFD_STATUS_UNKNOWN);
 260                 break;
 261         }
 262
 263         /* BFD source prefix information. */
 264         _ptm_msg_address(msg, bs->key.family, &bs->key.local);
 265
 266         stream_putc(msg, bs->remote_cbit);
 267
 268         /* Write packet size. */
 269         stream_putw_at(msg, 0, stream_get_endp(msg));
 270
 271         return zclient_send_message(zclient);
 272 }
 273
 274 static void _ptm_msg_read_address(struct stream *msg, struct sockaddr_any *sa)
 275 {
 276         uint16_t family;
 277
 278         STREAM_GETW(msg, family);
 279
 280         switch (family) {
 281         case AF_INET:
 282                 sa->sa_sin.sin_family = family;
 283                 STREAM_GET(&sa->sa_sin.sin_addr, msg,
 284                            sizeof(sa->sa_sin.sin_addr));
 285 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 286                 sa->sa_sin.sin_len = sizeof(sa->sa_sin);
 287 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 288                 return;
 289
 290         case AF_INET6:
 291                 sa->sa_sin6.sin6_family = family;
 292                 STREAM_GET(&sa->sa_sin6.sin6_addr, msg,
 293                            sizeof(sa->sa_sin6.sin6_addr));
 294 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 295                 sa->sa_sin6.sin6_len = sizeof(sa->sa_sin6);
 296 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 297                 return;
 298
 299         default:
 300                 zlog_warn("ptm-read-address: invalid family: %d", family);
 301                 break;
 302         }
 303
 304 stream_failure:
 305         memset(sa, 0, sizeof(*sa));
 306 }
 307
 308 static int _ptm_msg_read(struct stream *msg, int command, vrf_id_t vrf_id,
 309                          struct bfd_peer_cfg *bpc, struct ptm_client **pc)
 310 {
 311         uint32_t pid;
 312         size_t ifnamelen;
 313
 314         /*
 315          * Register/Deregister/Update Message format:
 316          *
 317          * Old format (being used by PTM BFD).
 318          * - header: Command, VRF
 319          * - l: pid
 320          * - w: family
 321          *   - AF_INET:
 322          *     - l: destination ipv4
 323          *   - AF_INET6:
 324          *     - 16 bytes: destination IPv6
 325          * - command != ZEBRA_BFD_DEST_DEREGISTER
 326          *   - l: min_rx
 327          *   - l: min_tx
 328          *   - c: detect multiplier
 329          * - c: is_multihop?
 330          *   - multihop:
 331          *     - w: family
 332          *       - AF_INET:
 333          *         - l: source IPv4 address
 334          *       - AF_INET6:
 335          *         - 16 bytes: source IPv6 address
 336          *     - c: ttl
 337          *   - no multihop
 338          *     - AF_INET6:
 339          *       - w: family
 340          *       - 16 bytes: source IPv6 address
 341          *     - c: ifname length
 342          *     - X bytes: interface name
 343          *
 344          * New format:
 345          * - header: Command, VRF
 346          * - l: pid
 347          * - w: family
 348          *   - AF_INET:
 349          *     - l: destination IPv4 address
 350          *   - AF_INET6:
 351          *     - 16 bytes: destination IPv6 address
 352          * - l: min_rx
 353          * - l: min_tx
 354          * - c: detect multiplier
 355          * - c: is_multihop?
 356          * - w: family
 357          *   - AF_INET:
 358          *     - l: source IPv4 address
 359          *   - AF_INET6:
 360          *     - 16 bytes: source IPv6 address
 361          * - c: ttl
 362          * - c: ifname length
 363          * - X bytes: interface name
 364          * - c: bfd_cbit
 365          * - c: profile name length.
 366          * - X bytes: profile name.
 367          *
 368          * q(64), l(32), w(16), c(8)
 369          */
 370
 371         /* Initialize parameters return values. */
 372         memset(bpc, 0, sizeof(*bpc));
 373         *pc = NULL;
 374
 375         /* Find or allocate process context data. */
 376         STREAM_GETL(msg, pid);
 377
 378         *pc = pc_new(pid);
 379
 380         /* Register/update peer information. */
 381         _ptm_msg_read_address(msg, &bpc->bpc_peer);
 382
 383         /* Determine IP type from peer destination. */
 384         bpc->bpc_ipv4 = (bpc->bpc_peer.sa_sin.sin_family == AF_INET);
 385
 386         /* Get peer configuration. */
 387         STREAM_GETL(msg, bpc->bpc_recvinterval);
 388         bpc->bpc_has_recvinterval =
 389                 (bpc->bpc_recvinterval != BPC_DEF_RECEIVEINTERVAL);
 390
 391         STREAM_GETL(msg, bpc->bpc_txinterval);
 392         bpc->bpc_has_txinterval =
 393                 (bpc->bpc_txinterval != BPC_DEF_TRANSMITINTERVAL);
 394
 395         STREAM_GETC(msg, bpc->bpc_detectmultiplier);
 396         bpc->bpc_has_detectmultiplier =
 397                 (bpc->bpc_detectmultiplier != BPC_DEF_DETECTMULTIPLIER);
 398
 399         /* Read (single|multi)hop and its options. */
 400         STREAM_GETC(msg, bpc->bpc_mhop);
 401
 402         /* Read multihop source address and TTL. */
 403         _ptm_msg_read_address(msg, &bpc->bpc_local);
 404
 405         /* Read the minimum TTL (0 means unset or invalid). */
 406         STREAM_GETC(msg, bpc->bpc_minimum_ttl);
 407         if (bpc->bpc_minimum_ttl == 0) {
 408                 bpc->bpc_minimum_ttl = BFD_DEF_MHOP_TTL;
 409                 bpc->bpc_has_minimum_ttl = false;
 410         } else {
 411                 bpc->bpc_minimum_ttl = (BFD_TTL_VAL + 1) - bpc->bpc_minimum_ttl;
 412                 bpc->bpc_has_minimum_ttl = true;
 413         }
 414
 415         /*
 416          * Read interface name and make sure it fits our data
 417          * structure, otherwise fail.
 418          */
 419         STREAM_GETC(msg, ifnamelen);
 420         if (ifnamelen >= sizeof(bpc->bpc_localif)) {
 421                 zlog_err("ptm-read: interface name is too big");
 422                 return -1;
 423         }
 424
 425         bpc->bpc_has_localif = ifnamelen > 0;
 426         if (bpc->bpc_has_localif) {
 427                 STREAM_GET(bpc->bpc_localif, msg, ifnamelen);
 428                 bpc->bpc_localif[ifnamelen] = 0;
 429         }
 430
 431         if (vrf_id != VRF_DEFAULT) {
 432                 struct vrf *vrf;
 433
 434                 vrf = vrf_lookup_by_id(vrf_id);
 435                 if (vrf) {
 436                         bpc->bpc_has_vrfname = true;
 437                         strlcpy(bpc->bpc_vrfname, vrf->name, sizeof(bpc->bpc_vrfname));
 438                 } else {
 439                         zlog_err("ptm-read: vrf id %u could not be identified",
 440                                  vrf_id);
 441                         return -1;
 442                 }
 443         } else {
 444                 bpc->bpc_has_vrfname = true;
 445                 strlcpy(bpc->bpc_vrfname, VRF_DEFAULT_NAME, sizeof(bpc->bpc_vrfname));
 446         }
 447
 448         /* Read control plane independant configuration. */
 449         STREAM_GETC(msg, bpc->bpc_cbit);
 450
 451         /* Handle profile names. */
 452         STREAM_GETC(msg, ifnamelen);
 453         bpc->bpc_has_profile = ifnamelen > 0;
 454         if (bpc->bpc_has_profile) {
 455                 STREAM_GET(bpc->bpc_profile, msg, ifnamelen);
 456                 bpc->bpc_profile[ifnamelen] = 0;
 457         }
 458
 459         /* Sanity check: peer and local address must match IP types. */
 460         if (bpc->bpc_local.sa_sin.sin_family != 0
 461             && (bpc->bpc_local.sa_sin.sin_family
 462                 != bpc->bpc_peer.sa_sin.sin_family)) {
 463                 zlog_warn("ptm-read: peer family doesn't match local type");
 464                 return -1;
 465         }
 466
 467         return 0;
 468
 469 stream_failure:
 470         return -1;
 471 }
 472
 473 static void bfdd_dest_register(struct stream *msg, vrf_id_t vrf_id)
 474 {
 475         struct ptm_client *pc;
 476         struct bfd_session *bs;
 477         struct bfd_peer_cfg bpc;
 478
 479         /* Read the client context and peer data. */
 480         if (_ptm_msg_read(msg, ZEBRA_BFD_DEST_REGISTER, vrf_id, &bpc, &pc) == -1)
 481                 return;
 482
 483         debug_printbpc(&bpc, "ptm-add-dest: register peer");
 484
 485         /* Find or start new BFD session. */
 486         bs = bs_peer_find(&bpc);
 487         if (bs == NULL) {
 488                 bs = ptm_bfd_sess_new(&bpc);
 489                 if (bs == NULL) {
 490                         if (bglobal.debug_zebra)
 491                                 zlog_debug(
 492                                         "ptm-add-dest: failed to create BFD session");
 493                         return;
 494                 }
 495
 496                 /* Protocol created peers are 'no shutdown' by default. */
 497                 bs->peer_profile.admin_shutdown = false;
 498         } else {
 499                 /*
 500                  * BFD session was already created, we are just updating the
 501                  * current peer.
 502                  *
 503                  * `ptm-bfd` (or `HAVE_BFDD == 0`) is the only implementation
 504                  * that allow users to set peer specific timers via protocol.
 505                  * BFD daemon (this code) on the other hand only supports
 506                  * changing peer configuration manually (through `peer` node)
 507                  * or via profiles.
 508                  */
 509                 if (bpc.bpc_has_profile)
 510                         bfd_profile_apply(bpc.bpc_profile, bs);
 511         }
 512
 513         /* Create client peer notification register. */
 514         pcn_new(pc, bs);
 515
 516         ptm_bfd_notify(bs, bs->ses_state);
 517 }
 518
 519 static void bfdd_dest_deregister(struct stream *msg, vrf_id_t vrf_id)
 520 {
 521         struct ptm_client *pc;
 522         struct ptm_client_notification *pcn;
 523         struct bfd_session *bs;
 524         struct bfd_peer_cfg bpc;
 525
 526         /* Read the client context and peer data. */
 527         if (_ptm_msg_read(msg, ZEBRA_BFD_DEST_DEREGISTER, vrf_id, &bpc, &pc) == -1)
 528                 return;
 529
 530         debug_printbpc(&bpc, "ptm-del-dest: deregister peer");
 531
 532         /* Find or start new BFD session. */
 533         bs = bs_peer_find(&bpc);
 534         if (bs == NULL) {
 535                 if (bglobal.debug_zebra)
 536                         zlog_debug("ptm-del-dest: failed to find BFD session");
 537                 return;
 538         }
 539
 540         /* Unregister client peer notification. */
 541         pcn = pcn_lookup(pc, bs);
 542         if (pcn != NULL) {
 543                 pcn_free(pcn);
 544                 return;
 545         }
 546
 547         if (bglobal.debug_zebra)
 548                 zlog_debug("ptm-del-dest: failed to find BFD session");
 549
 550         /*
 551          * XXX: We either got a double deregistration or the daemon who
 552          * created this is no longer around. Lets try to delete it anyway
 553          * and the worst case is the refcount will detain us.
 554          */
 555         _ptm_bfd_session_del(bs, BD_NEIGHBOR_DOWN);
 556 }
 557
 558 /*
 559  * header: command, VRF
 560  * l: pid
 561  */
 562 static void bfdd_client_register(struct stream *msg)
 563 {
 564         uint32_t pid;
 565
 566         /* Find or allocate process context data. */
 567         STREAM_GETL(msg, pid);
 568
 569         pc_new(pid);
 570
 571         return;
 572
 573 stream_failure:
 574         zlog_err("ptm-add-client: failed to register client");
 575 }
 576
 577 /*
 578  * header: command, VRF
 579  * l: pid
 580  */
 581 static void bfdd_client_deregister(struct stream *msg)
 582 {
 583         struct ptm_client *pc;
 584         uint32_t pid;
 585
 586         /* Find or allocate process context data. */
 587         STREAM_GETL(msg, pid);
 588
 589         pc = pc_lookup(pid);
 590         if (pc == NULL) {
 591                 if (bglobal.debug_zebra)
 592                         zlog_debug("ptm-del-client: failed to find client: %u",
 593                                    pid);
 594                 return;
 595         }
 596
 597         if (bglobal.debug_zebra)
 598                 zlog_debug("ptm-del-client: client pid %u", pid);
 599
 600         pc_free(pc);
 601
 602         return;
 603
 604 stream_failure:
 605         zlog_err("ptm-del-client: failed to deregister client");
 606 }
 607
 608 static int bfdd_replay(ZAPI_CALLBACK_ARGS)
 609 {
 610         struct stream *msg = zclient->ibuf;
 611         uint32_t rcmd;
 612
 613         STREAM_GETL(msg, rcmd);
 614
 615         switch (rcmd) {
 616         case ZEBRA_BFD_DEST_REGISTER:
 617         case ZEBRA_BFD_DEST_UPDATE:
 618                 bfdd_dest_register(msg, vrf_id);
 619                 break;
 620         case ZEBRA_BFD_DEST_DEREGISTER:
 621                 bfdd_dest_deregister(msg, vrf_id);
 622                 break;
 623         case ZEBRA_BFD_CLIENT_REGISTER:
 624                 bfdd_client_register(msg);
 625                 break;
 626         case ZEBRA_BFD_CLIENT_DEREGISTER:
 627                 bfdd_client_deregister(msg);
 628                 break;
 629
 630         default:
 631                 if (bglobal.debug_zebra)
 632                         zlog_debug("ptm-replay: invalid message type %u", rcmd);
 633                 return -1;
 634         }
 635
 636         return 0;
 637
 638 stream_failure:
 639         zlog_err("ptm-replay: failed to find command");
 640         return -1;
 641 }
 642
 643 static void bfdd_zebra_connected(struct zclient *zc)
 644 {
 645         struct stream *msg = zc->obuf;
 646
 647         /* Clean-up and free ptm clients data memory. */
 648         pc_free_all();
 649
 650         /*
 651          * The replay is an empty message just to trigger client daemons
 652          * configuration replay.
 653          */
 654         stream_reset(msg);
 655         zclient_create_header(msg, ZEBRA_BFD_DEST_REPLAY, VRF_DEFAULT);
 656         stream_putl(msg, ZEBRA_BFD_DEST_REPLAY);
 657         stream_putw_at(msg, 0, stream_get_endp(msg));
 658
 659         /* Ask for interfaces information. */
 660         zclient_create_header(msg, ZEBRA_INTERFACE_ADD, VRF_DEFAULT);
 661
 662         /* Send requests. */
 663         zclient_send_message(zclient);
 664 }
 665
 666 static void bfdd_sessions_enable_interface(struct interface *ifp)
 667 {
 668         struct bfd_session_observer *bso;
 669         struct bfd_session *bs;
 670         struct vrf *vrf;
 671
 672         vrf = vrf_lookup_by_id(ifp->vrf_id);
 673         if (!vrf)
 674                 return;
 675
 676         TAILQ_FOREACH(bso, &bglobal.bg_obslist, bso_entry) {
 677                 bs = bso->bso_bs;
 678                 /* check vrf name */
 679                 if (bs->key.vrfname[0] &&
 680                     strcmp(vrf->name, bs->key.vrfname))
 681                         continue;
 682
 683                 /* If Interface matches vrfname, then bypass iface check */
 684                 if (vrf_is_backend_netns() || strcmp(ifp->name, vrf->name)) {
 685                         /* Interface name mismatch. */
 686                         if (strcmp(ifp->name, bs->key.ifname))
 687                                 continue;
 688                 }
 689
 690                 /* Skip enabled sessions. */
 691                 if (bs->sock != -1)
 692                         continue;
 693
 694                 /* Try to enable it. */
 695                 bfd_session_enable(bs);
 696         }
 697 }
 698
 699 static void bfdd_sessions_disable_interface(struct interface *ifp)
 700 {
 701         struct bfd_session_observer *bso;
 702         struct bfd_session *bs;
 703
 704         TAILQ_FOREACH(bso, &bglobal.bg_obslist, bso_entry) {
 705                 bs = bso->bso_bs;
 706                 if (strcmp(ifp->name, bs->key.ifname))
 707                         continue;
 708                 /* Skip disabled sessions. */
 709                 if (bs->sock == -1)
 710                         continue;
 711
 712                 bfd_session_disable(bs);
 713                 bs->ifp = NULL;
 714         }
 715 }
 716
 717 void bfdd_sessions_enable_vrf(struct vrf *vrf)
 718 {
 719         struct bfd_session_observer *bso;
 720         struct bfd_session *bs;
 721
 722         /* it may affect configs without interfaces */
 723         TAILQ_FOREACH(bso, &bglobal.bg_obslist, bso_entry) {
 724                 bs = bso->bso_bs;
 725                 /* update name */
 726                 if (bs->vrf && bs->vrf == vrf) {
 727                         if (!strmatch(bs->key.vrfname, vrf->name))
 728                                 bfd_session_update_vrf_name(bs, vrf);
 729                 }
 730                 if (bs->vrf)
 731                         continue;
 732                 if (bs->key.vrfname[0] &&
 733                     strcmp(vrf->name, bs->key.vrfname))
 734                         continue;
 735                 /* need to update the vrf information on
 736                  * bs so that callbacks are handled
 737                  */
 738                 bs->vrf = vrf;
 739                 /* Skip enabled sessions. */
 740                 if (bs->sock != -1)
 741                         continue;
 742                 /* Try to enable it. */
 743                 bfd_session_enable(bs);
 744         }
 745 }
 746
 747 void bfdd_sessions_disable_vrf(struct vrf *vrf)
 748 {
 749         struct bfd_session_observer *bso;
 750         struct bfd_session *bs;
 751
 752         TAILQ_FOREACH(bso, &bglobal.bg_obslist, bso_entry) {
 753                 bs = bso->bso_bs;
 754                 if (bs->key.vrfname[0] &&
 755                     strcmp(vrf->name, bs->key.vrfname))
 756                         continue;
 757                 /* Skip disabled sessions. */
 758                 if (bs->sock == -1)
 759                         continue;
 760
 761                 bfd_session_disable(bs);
 762                 bs->vrf = NULL;
 763         }
 764 }
 765
 766 static int bfd_ifp_destroy(struct interface *ifp)
 767 {
 768         if (bglobal.debug_zebra)
 769                 zlog_debug("zclient: delete interface %s (VRF %u)", ifp->name,
 770                            ifp->vrf_id);
 771
 772         bfdd_sessions_disable_interface(ifp);
 773
 774         return 0;
 775 }
 776
 777 static int bfdd_interface_vrf_update(ZAPI_CALLBACK_ARGS)
 778 {
 779         struct interface *ifp;
 780         vrf_id_t nvrfid;
 781
 782         ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id, &nvrfid);
 783         if (ifp == NULL)
 784                 return 0;
 785
 786         if_update_to_new_vrf(ifp, nvrfid);
 787
 788         return 0;
 789 }
 790
 791 static void bfdd_sessions_enable_address(struct connected *ifc)
 792 {
 793         struct bfd_session_observer *bso;
 794         struct bfd_session *bs;
 795         struct prefix prefix;
 796
 797         TAILQ_FOREACH(bso, &bglobal.bg_obslist, bso_entry) {
 798                 /* Skip enabled sessions. */
 799                 bs = bso->bso_bs;
 800                 if (bs->sock != -1)
 801                         continue;
 802
 803                 /* Check address. */
 804                 prefix = bso->bso_addr;
 805                 prefix.prefixlen = ifc->address->prefixlen;
 806                 if (prefix_cmp(&prefix, ifc->address))
 807                         continue;
 808
 809                 /* Try to enable it. */
 810                 bfd_session_enable(bs);
 811         }
 812 }
 813
 814 static int bfdd_interface_address_update(ZAPI_CALLBACK_ARGS)
 815 {
 816         struct connected *ifc;
 817
 818         ifc = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 819         if (ifc == NULL)
 820                 return 0;
 821
 822         if (bglobal.debug_zebra)
 823                 zlog_debug("zclient: %s local address %pFX (VRF %u)",
 824                            cmd == ZEBRA_INTERFACE_ADDRESS_ADD ? "add"
 825                                                               : "delete",
 826                            ifc->address, vrf_id);
 827
 828         if (cmd == ZEBRA_INTERFACE_ADDRESS_ADD)
 829                 bfdd_sessions_enable_address(ifc);
 830         else
 831                 connected_free(&ifc);
 832
 833         return 0;
 834 }
 835
 836 static int bfd_ifp_create(struct interface *ifp)
 837 {
 838         if (bglobal.debug_zebra)
 839                 zlog_debug("zclient: add interface %s (VRF %u)", ifp->name,
 840                            ifp->vrf_id);
 841         bfdd_sessions_enable_interface(ifp);
 842
 843         return 0;
 844 }
 845
 846 void bfdd_zclient_init(struct zebra_privs_t *bfdd_priv)
 847 {
 848         if_zapi_callbacks(bfd_ifp_create, NULL, NULL, bfd_ifp_destroy);
 849         zclient = zclient_new(master, &zclient_options_default);
 850         assert(zclient != NULL);
 851         zclient_init(zclient, ZEBRA_ROUTE_BFD, 0, bfdd_priv);
 852
 853         /*
 854          * We'll receive all messages through replay, however it will
 855          * contain a special field with the real command inside so we
 856          * avoid having to create too many handlers.
 857          */
 858         zclient->bfd_dest_replay = bfdd_replay;
 859
 860         /* Send replay request on zebra connect. */
 861         zclient->zebra_connected = bfdd_zebra_connected;
 862
 863         /* Learn about interface VRF. */
 864         zclient->interface_vrf_update = bfdd_interface_vrf_update;
 865
 866         /* Learn about new addresses being registered. */
 867         zclient->interface_address_add = bfdd_interface_address_update;
 868         zclient->interface_address_delete = bfdd_interface_address_update;
 869 }
 870
 871 void bfdd_zclient_register(vrf_id_t vrf_id)
 872 {
 873         if (!zclient || zclient->sock < 0)
 874                 return;
 875         zclient_send_reg_requests(zclient, vrf_id);
 876 }
 877
 878 void bfdd_zclient_unregister(vrf_id_t vrf_id)
 879 {
 880         if (!zclient || zclient->sock < 0)
 881                 return;
 882         zclient_send_dereg_requests(zclient, vrf_id);
 883 }
 884
 885 void bfdd_zclient_stop(void)
 886 {
 887         zclient_stop(zclient);
 888
 889         /* Clean-up and free ptm clients data memory. */
 890         pc_free_all();
 891 }
 892
 893
 894 /*
 895  * Client handling.
 896  */
 897 static struct ptm_client *pc_lookup(uint32_t pid)
 898 {
 899         struct ptm_client *pc;
 900
 901         TAILQ_FOREACH (pc, &pcqueue, pc_entry) {
 902                 if (pc->pc_pid != pid)
 903                         continue;
 904
 905                 break;
 906         }
 907
 908         return pc;
 909 }
 910
 911 static struct ptm_client *pc_new(uint32_t pid)
 912 {
 913         struct ptm_client *pc;
 914
 915         /* Look up first, if not found create the client. */
 916         pc = pc_lookup(pid);
 917         if (pc != NULL)
 918                 return pc;
 919
 920         /* Allocate the client data and save it. */
 921         pc = XCALLOC(MTYPE_BFDD_CONTROL, sizeof(*pc));
 922
 923         pc->pc_pid = pid;
 924         TAILQ_INSERT_HEAD(&pcqueue, pc, pc_entry);
 925         return pc;
 926 }
 927
 928 static void pc_free(struct ptm_client *pc)
 929 {
 930         struct ptm_client_notification *pcn;
 931
 932         TAILQ_REMOVE(&pcqueue, pc, pc_entry);
 933
 934         while (!TAILQ_EMPTY(&pc->pc_pcnqueue)) {
 935                 pcn = TAILQ_FIRST(&pc->pc_pcnqueue);
 936                 pcn_free(pcn);
 937         }
 938
 939         XFREE(MTYPE_BFDD_CONTROL, pc);
 940 }
 941
 942 static void pc_free_all(void)
 943 {
 944         struct ptm_client *pc;
 945
 946         while (!TAILQ_EMPTY(&pcqueue)) {
 947                 pc = TAILQ_FIRST(&pcqueue);
 948                 pc_free(pc);
 949         }
 950 }
 951
 952 static struct ptm_client_notification *pcn_new(struct ptm_client *pc,
 953                                                struct bfd_session *bs)
 954 {
 955         struct ptm_client_notification *pcn;
 956
 957         /* Try to find an existing pcn fist. */
 958         pcn = pcn_lookup(pc, bs);
 959         if (pcn != NULL)
 960                 return pcn;
 961
 962         /* Save the client notification data. */
 963         pcn = XCALLOC(MTYPE_BFDD_NOTIFICATION, sizeof(*pcn));
 964
 965         TAILQ_INSERT_HEAD(&pc->pc_pcnqueue, pcn, pcn_entry);
 966         pcn->pcn_pc = pc;
 967         pcn->pcn_bs = bs;
 968         bs->refcount++;
 969
 970         return pcn;
 971 }
 972
 973 static struct ptm_client_notification *pcn_lookup(struct ptm_client *pc,
 974                                                   struct bfd_session *bs)
 975 {
 976         struct ptm_client_notification *pcn;
 977
 978         TAILQ_FOREACH (pcn, &pc->pc_pcnqueue, pcn_entry) {
 979                 if (pcn->pcn_bs != bs)
 980                         continue;
 981
 982                 break;
 983         }
 984
 985         return pcn;
 986 }
 987
 988 static void pcn_free(struct ptm_client_notification *pcn)
 989 {
 990         struct ptm_client *pc;
 991         struct bfd_session *bs;
 992
 993         /* Handle session de-registration. */
 994         bs = pcn->pcn_bs;
 995         pcn->pcn_bs = NULL;
 996         bs->refcount--;
 997
 998         /* Log modification to users. */
 999         if (bglobal.debug_zebra)
1000                 zlog_debug("ptm-del-session: [%s] refcount=%" PRIu64,
1001                            bs_to_string(bs), bs->refcount);
1002
1003         /* Set session down. */
1004         _ptm_bfd_session_del(bs, BD_NEIGHBOR_DOWN);
1005
1006         /* Handle ptm_client deregistration. */
1007         pc = pcn->pcn_pc;
1008         pcn->pcn_pc = NULL;
1009         TAILQ_REMOVE(&pc->pc_pcnqueue, pcn, pcn_entry);
1010
1011         XFREE(MTYPE_BFDD_NOTIFICATION, pcn);
1012 }