bfdd/bfd_packet.c

   1 /*********************************************************************
   2  * Copyright 2017 Cumulus Networks, Inc.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; either version 2 of the License, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  *
  18  * bfd_packet.c: implements the BFD protocol packet handling.
  19  *
  20  * Authors
  21  * -------
  22  * Shrijeet Mukherjee [shm@cumulusnetworks.com]
  23  * Kanna Rajagopal [kanna@cumulusnetworks.com]
  24  * Radhika Mahankali [Radhika@cumulusnetworks.com]
  25  */
  26
  27 #include <zebra.h>
  28
  29 #ifdef BFD_LINUX
  30 #include <linux/if_packet.h>
  31 #endif /* BFD_LINUX */
  32
  33 #include <netinet/if_ether.h>
  34 #include <netinet/udp.h>
  35
  36 #include "lib/sockopt.h"
  37
  38 #include "bfd.h"
  39
  40 /*
  41  * Prototypes
  42  */
  43 static int ptm_bfd_process_echo_pkt(struct bfd_vrf_global *bvrf, int s);
  44 int _ptm_bfd_send(struct bfd_session *bs, uint16_t *port, const void *data,
  45                   size_t datalen);
  46
  47 static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd);
  48 ssize_t bfd_recv_ipv4(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
  49                       ifindex_t *ifindex, struct sockaddr_any *local,
  50                       struct sockaddr_any *peer);
  51 ssize_t bfd_recv_ipv6(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
  52                       ifindex_t *ifindex, struct sockaddr_any *local,
  53                       struct sockaddr_any *peer);
  54 int bp_udp_send(int sd, uint8_t ttl, uint8_t *data, size_t datalen,
  55                 struct sockaddr *to, socklen_t tolen);
  56 int bp_bfd_echo_in(struct bfd_vrf_global *bvrf, int sd,
  57                    uint8_t *ttl, uint32_t *my_discr);
  58
  59 /* socket related prototypes */
  60 static void bp_set_ipopts(int sd);
  61 static void bp_bind_ip(int sd, uint16_t port);
  62 static void bp_set_ipv6opts(int sd);
  63 static void bp_bind_ipv6(int sd, uint16_t port);
  64
  65
  66 /*
  67  * Functions
  68  */
  69 int _ptm_bfd_send(struct bfd_session *bs, uint16_t *port, const void *data,
  70                   size_t datalen)
  71 {
  72         struct sockaddr *sa;
  73         struct sockaddr_in sin;
  74         struct sockaddr_in6 sin6;
  75         socklen_t slen;
  76         ssize_t rv;
  77         int sd = -1;
  78
  79         if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_IPV6)) {
  80                 memset(&sin6, 0, sizeof(sin6));
  81                 sin6.sin6_family = AF_INET6;
  82                 memcpy(&sin6.sin6_addr, &bs->key.peer, sizeof(sin6.sin6_addr));
  83                 if (bs->ifp && IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr))
  84                         sin6.sin6_scope_id = bs->ifp->ifindex;
  85
  86                 sin6.sin6_port =
  87                         (port) ? *port
  88                                : (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_MH))
  89                                          ? htons(BFD_DEF_MHOP_DEST_PORT)
  90                                          : htons(BFD_DEFDESTPORT);
  91
  92                 sd = bs->sock;
  93                 sa = (struct sockaddr *)&sin6;
  94                 slen = sizeof(sin6);
  95         } else {
  96                 memset(&sin, 0, sizeof(sin));
  97                 sin.sin_family = AF_INET;
  98                 memcpy(&sin.sin_addr, &bs->key.peer, sizeof(sin.sin_addr));
  99                 sin.sin_port =
 100                         (port) ? *port
 101                                : (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_MH))
 102                                          ? htons(BFD_DEF_MHOP_DEST_PORT)
 103                                          : htons(BFD_DEFDESTPORT);
 104
 105                 sd = bs->sock;
 106                 sa = (struct sockaddr *)&sin;
 107                 slen = sizeof(sin);
 108         }
 109
 110 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 111         sa->sa_len = slen;
 112 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 113         rv = sendto(sd, data, datalen, 0, sa, slen);
 114         if (rv <= 0) {
 115                 if (bglobal.debug_network)
 116                         zlog_debug("packet-send: send failure: %s",
 117                                    strerror(errno));
 118                 return -1;
 119         }
 120         if (rv < (ssize_t)datalen) {
 121                 if (bglobal.debug_network)
 122                         zlog_debug("packet-send: send partial: %s",
 123                                    strerror(errno));
 124         }
 125
 126         return 0;
 127 }
 128
 129 void ptm_bfd_echo_snd(struct bfd_session *bfd)
 130 {
 131         struct sockaddr *sa;
 132         socklen_t salen;
 133         int sd;
 134         struct bfd_echo_pkt bep;
 135         struct sockaddr_in sin;
 136         struct sockaddr_in6 sin6;
 137         struct bfd_vrf_global *bvrf = bfd_vrf_look_by_session(bfd);
 138
 139         if (!bvrf)
 140                 return;
 141         if (!CHECK_FLAG(bfd->flags, BFD_SESS_FLAG_ECHO_ACTIVE))
 142                 SET_FLAG(bfd->flags, BFD_SESS_FLAG_ECHO_ACTIVE);
 143
 144         memset(&bep, 0, sizeof(bep));
 145         bep.ver = BFD_ECHO_VERSION;
 146         bep.len = BFD_ECHO_PKT_LEN;
 147         bep.my_discr = htonl(bfd->discrs.my_discr);
 148
 149         if (CHECK_FLAG(bfd->flags, BFD_SESS_FLAG_IPV6)) {
 150                 if (bvrf->bg_echov6 == -1)
 151                         return;
 152                 sd = bvrf->bg_echov6;
 153                 memset(&sin6, 0, sizeof(sin6));
 154                 sin6.sin6_family = AF_INET6;
 155                 memcpy(&sin6.sin6_addr, &bfd->key.peer, sizeof(sin6.sin6_addr));
 156                 if (bfd->ifp && IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr))
 157                         sin6.sin6_scope_id = bfd->ifp->ifindex;
 158
 159                 sin6.sin6_port = htons(BFD_DEF_ECHO_PORT);
 160 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 161                 sin6.sin6_len = sizeof(sin6);
 162 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 163
 164                 sa = (struct sockaddr *)&sin6;
 165                 salen = sizeof(sin6);
 166         } else {
 167                 sd = bvrf->bg_echo;
 168                 memset(&sin, 0, sizeof(sin));
 169                 sin.sin_family = AF_INET;
 170                 memcpy(&sin.sin_addr, &bfd->key.peer, sizeof(sin.sin_addr));
 171                 sin.sin_port = htons(BFD_DEF_ECHO_PORT);
 172 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 173                 sin.sin_len = sizeof(sin);
 174 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 175
 176                 sa = (struct sockaddr *)&sin;
 177                 salen = sizeof(sin);
 178         }
 179         if (bp_udp_send(sd, BFD_TTL_VAL, (uint8_t *)&bep, sizeof(bep), sa,
 180                         salen)
 181             == -1)
 182                 return;
 183
 184         bfd->stats.tx_echo_pkt++;
 185 }
 186
 187 static int ptm_bfd_process_echo_pkt(struct bfd_vrf_global *bvrf, int s)
 188 {
 189         struct bfd_session *bfd;
 190         uint32_t my_discr = 0;
 191         uint8_t ttl = 0;
 192
 193         /* Receive and parse echo packet. */
 194         if (bp_bfd_echo_in(bvrf, s, &ttl, &my_discr) == -1)
 195                 return 0;
 196
 197         /* Your discriminator not zero - use it to find session */
 198         bfd = bfd_id_lookup(my_discr);
 199         if (bfd == NULL) {
 200                 if (bglobal.debug_network)
 201                         zlog_debug("echo-packet: no matching session (id:%u)",
 202                                    my_discr);
 203                 return -1;
 204         }
 205
 206         if (!CHECK_FLAG(bfd->flags, BFD_SESS_FLAG_ECHO_ACTIVE)) {
 207                 if (bglobal.debug_network)
 208                         zlog_debug("echo-packet: echo disabled [%s] (id:%u)",
 209                                    bs_to_string(bfd), my_discr);
 210                 return -1;
 211         }
 212
 213         bfd->stats.rx_echo_pkt++;
 214
 215         /* Compute detect time */
 216         bfd->echo_detect_TO = bfd->remote_detect_mult * bfd->echo_xmt_TO;
 217
 218         /* Update echo receive timeout. */
 219         if (bfd->echo_detect_TO > 0)
 220                 bfd_echo_recvtimer_update(bfd);
 221
 222         return 0;
 223 }
 224
 225 void ptm_bfd_snd(struct bfd_session *bfd, int fbit)
 226 {
 227         struct bfd_pkt cp = {};
 228
 229         /* Set fields according to section 6.5.7 */
 230         cp.diag = bfd->local_diag;
 231         BFD_SETVER(cp.diag, BFD_VERSION);
 232         cp.flags = 0;
 233         BFD_SETSTATE(cp.flags, bfd->ses_state);
 234
 235         if (CHECK_FLAG(bfd->flags, BFD_SESS_FLAG_CBIT))
 236                 BFD_SETCBIT(cp.flags, BFD_CBIT);
 237
 238         BFD_SETDEMANDBIT(cp.flags, BFD_DEF_DEMAND);
 239
 240         /*
 241          * Polling and Final can't be set at the same time.
 242          *
 243          * RFC 5880, Section 6.5.
 244          */
 245         BFD_SETFBIT(cp.flags, fbit);
 246         if (fbit == 0)
 247                 BFD_SETPBIT(cp.flags, bfd->polling);
 248
 249         cp.detect_mult = bfd->detect_mult;
 250         cp.len = BFD_PKT_LEN;
 251         cp.discrs.my_discr = htonl(bfd->discrs.my_discr);
 252         cp.discrs.remote_discr = htonl(bfd->discrs.remote_discr);
 253         if (bfd->polling) {
 254                 cp.timers.desired_min_tx =
 255                         htonl(bfd->timers.desired_min_tx);
 256                 cp.timers.required_min_rx =
 257                         htonl(bfd->timers.required_min_rx);
 258         } else {
 259                 /*
 260                  * We can only announce current setting on poll, this
 261                  * avoids timing mismatch with our peer and give it
 262                  * the oportunity to learn. See `bs_final_handler` for
 263                  * more information.
 264                  */
 265                 cp.timers.desired_min_tx =
 266                         htonl(bfd->cur_timers.desired_min_tx);
 267                 cp.timers.required_min_rx =
 268                         htonl(bfd->cur_timers.required_min_rx);
 269         }
 270         cp.timers.required_min_echo = htonl(bfd->timers.required_min_echo_rx);
 271
 272         if (_ptm_bfd_send(bfd, NULL, &cp, BFD_PKT_LEN) != 0)
 273                 return;
 274
 275         bfd->stats.tx_ctrl_pkt++;
 276 }
 277
 278 ssize_t bfd_recv_ipv4(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
 279                       ifindex_t *ifindex, struct sockaddr_any *local,
 280                       struct sockaddr_any *peer)
 281 {
 282         struct cmsghdr *cm;
 283         ssize_t mlen;
 284         struct sockaddr_in msgaddr;
 285         struct msghdr msghdr;
 286         struct iovec iov[1];
 287         uint8_t cmsgbuf[255];
 288
 289         /* Prepare the recvmsg params. */
 290         iov[0].iov_base = msgbuf;
 291         iov[0].iov_len = msgbuflen;
 292
 293         memset(&msghdr, 0, sizeof(msghdr));
 294         msghdr.msg_name = &msgaddr;
 295         msghdr.msg_namelen = sizeof(msgaddr);
 296         msghdr.msg_iov = iov;
 297         msghdr.msg_iovlen = 1;
 298         msghdr.msg_control = cmsgbuf;
 299         msghdr.msg_controllen = sizeof(cmsgbuf);
 300
 301         mlen = recvmsg(sd, &msghdr, MSG_DONTWAIT);
 302         if (mlen == -1) {
 303                 if (errno != EAGAIN)
 304                         zlog_err("ipv4-recv: recv failed: %s", strerror(errno));
 305
 306                 return -1;
 307         }
 308
 309         /* Get source address */
 310         peer->sa_sin = *((struct sockaddr_in *)(msghdr.msg_name));
 311
 312         /* Get and check TTL */
 313         for (cm = CMSG_FIRSTHDR(&msghdr); cm != NULL;
 314              cm = CMSG_NXTHDR(&msghdr, cm)) {
 315                 if (cm->cmsg_level != IPPROTO_IP)
 316                         continue;
 317
 318                 switch (cm->cmsg_type) {
 319 #ifdef BFD_LINUX
 320                 case IP_TTL: {
 321                         uint32_t ttlval;
 322
 323                         memcpy(&ttlval, CMSG_DATA(cm), sizeof(ttlval));
 324                         if (ttlval > 255) {
 325                                 if (bglobal.debug_network)
 326                                         zlog_debug("ipv4-recv: invalid TTL: %u",
 327                                                    ttlval);
 328                                 return -1;
 329                         }
 330                         *ttl = ttlval;
 331                         break;
 332                 }
 333
 334                 case IP_PKTINFO: {
 335                         struct in_pktinfo *pi =
 336                                 (struct in_pktinfo *)CMSG_DATA(cm);
 337
 338                         if (pi == NULL)
 339                                 break;
 340
 341                         local->sa_sin.sin_family = AF_INET;
 342                         local->sa_sin.sin_addr = pi->ipi_addr;
 343 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 344                         local->sa_sin.sin_len = sizeof(local->sa_sin);
 345 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 346
 347                         *ifindex = pi->ipi_ifindex;
 348                         break;
 349                 }
 350 #endif /* BFD_LINUX */
 351 #ifdef BFD_BSD
 352                 case IP_RECVTTL: {
 353                         memcpy(ttl, CMSG_DATA(cm), sizeof(*ttl));
 354                         break;
 355                 }
 356
 357                 case IP_RECVDSTADDR: {
 358                         struct in_addr ia;
 359
 360                         memcpy(&ia, CMSG_DATA(cm), sizeof(ia));
 361                         local->sa_sin.sin_family = AF_INET;
 362                         local->sa_sin.sin_addr = ia;
 363 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 364                         local->sa_sin.sin_len = sizeof(local->sa_sin);
 365 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 366                         break;
 367                 }
 368 #endif /* BFD_BSD */
 369
 370                 default:
 371                         /*
 372                          * On *BSDs we expect to land here when skipping
 373                          * the IP_RECVIF header. It will be handled by
 374                          * getsockopt_ifindex() below.
 375                          */
 376                         /* NOTHING */
 377                         break;
 378                 }
 379         }
 380
 381         /* OS agnostic way of getting interface name. */
 382         if (*ifindex == IFINDEX_INTERNAL)
 383                 *ifindex = getsockopt_ifindex(AF_INET, &msghdr);
 384
 385         return mlen;
 386 }
 387
 388 ssize_t bfd_recv_ipv6(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
 389                       ifindex_t *ifindex, struct sockaddr_any *local,
 390                       struct sockaddr_any *peer)
 391 {
 392         struct cmsghdr *cm;
 393         struct in6_pktinfo *pi6 = NULL;
 394         ssize_t mlen;
 395         uint32_t ttlval;
 396         struct sockaddr_in6 msgaddr6;
 397         struct msghdr msghdr6;
 398         struct iovec iov[1];
 399         uint8_t cmsgbuf6[255];
 400
 401         /* Prepare the recvmsg params. */
 402         iov[0].iov_base = msgbuf;
 403         iov[0].iov_len = msgbuflen;
 404
 405         memset(&msghdr6, 0, sizeof(msghdr6));
 406         msghdr6.msg_name = &msgaddr6;
 407         msghdr6.msg_namelen = sizeof(msgaddr6);
 408         msghdr6.msg_iov = iov;
 409         msghdr6.msg_iovlen = 1;
 410         msghdr6.msg_control = cmsgbuf6;
 411         msghdr6.msg_controllen = sizeof(cmsgbuf6);
 412
 413         mlen = recvmsg(sd, &msghdr6, MSG_DONTWAIT);
 414         if (mlen == -1) {
 415                 if (errno != EAGAIN)
 416                         zlog_err("ipv6-recv: recv failed: %s", strerror(errno));
 417
 418                 return -1;
 419         }
 420
 421         /* Get source address */
 422         peer->sa_sin6 = *((struct sockaddr_in6 *)(msghdr6.msg_name));
 423
 424         /* Get and check TTL */
 425         for (cm = CMSG_FIRSTHDR(&msghdr6); cm != NULL;
 426              cm = CMSG_NXTHDR(&msghdr6, cm)) {
 427                 if (cm->cmsg_level != IPPROTO_IPV6)
 428                         continue;
 429
 430                 if (cm->cmsg_type == IPV6_HOPLIMIT) {
 431                         memcpy(&ttlval, CMSG_DATA(cm), sizeof(ttlval));
 432                         if (ttlval > 255) {
 433                                 if (bglobal.debug_network)
 434                                         zlog_debug("ipv6-recv: invalid TTL: %u",
 435                                                    ttlval);
 436                                 return -1;
 437                         }
 438
 439                         *ttl = ttlval;
 440                 } else if (cm->cmsg_type == IPV6_PKTINFO) {
 441                         pi6 = (struct in6_pktinfo *)CMSG_DATA(cm);
 442                         if (pi6) {
 443                                 local->sa_sin6.sin6_family = AF_INET6;
 444                                 local->sa_sin6.sin6_addr = pi6->ipi6_addr;
 445 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 446                                 local->sa_sin6.sin6_len = sizeof(local->sa_sin6);
 447 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
 448
 449                                 *ifindex = pi6->ipi6_ifindex;
 450
 451                                 /* Set scope ID for link local addresses. */
 452                                 if (IN6_IS_ADDR_LINKLOCAL(
 453                                             &peer->sa_sin6.sin6_addr))
 454                                         peer->sa_sin6.sin6_scope_id = *ifindex;
 455                                 if (IN6_IS_ADDR_LINKLOCAL(
 456                                             &local->sa_sin6.sin6_addr))
 457                                         local->sa_sin6.sin6_scope_id = *ifindex;
 458                         }
 459                 }
 460         }
 461
 462         return mlen;
 463 }
 464
 465 static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd)
 466 {
 467         if (sd == bvrf->bg_shop) {
 468                 THREAD_OFF(bvrf->bg_ev[0]);
 469                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop,
 470                                 &bvrf->bg_ev[0]);
 471         } else if (sd == bvrf->bg_mhop) {
 472                 THREAD_OFF(bvrf->bg_ev[1]);
 473                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop,
 474                                 &bvrf->bg_ev[1]);
 475         } else if (sd == bvrf->bg_shop6) {
 476                 THREAD_OFF(bvrf->bg_ev[2]);
 477                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop6,
 478                                 &bvrf->bg_ev[2]);
 479         } else if (sd == bvrf->bg_mhop6) {
 480                 THREAD_OFF(bvrf->bg_ev[3]);
 481                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop6,
 482                                 &bvrf->bg_ev[3]);
 483         } else if (sd == bvrf->bg_echo) {
 484                 THREAD_OFF(bvrf->bg_ev[4]);
 485                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echo,
 486                                 &bvrf->bg_ev[4]);
 487         } else if (sd == bvrf->bg_echov6) {
 488                 THREAD_OFF(bvrf->bg_ev[5]);
 489                 thread_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echov6,
 490                                 &bvrf->bg_ev[5]);
 491         }
 492 }
 493
 494 static void cp_debug(bool mhop, struct sockaddr_any *peer,
 495                      struct sockaddr_any *local, ifindex_t ifindex,
 496                      vrf_id_t vrfid, const char *fmt, ...)
 497 {
 498         char buf[512], peerstr[128], localstr[128], portstr[64], vrfstr[64];
 499         va_list vl;
 500
 501         /* Don't to any processing if debug is disabled. */
 502         if (bglobal.debug_network == false)
 503                 return;
 504
 505         if (peer->sa_sin.sin_family)
 506                 snprintf(peerstr, sizeof(peerstr), " peer:%s", satostr(peer));
 507         else
 508                 peerstr[0] = 0;
 509
 510         if (local->sa_sin.sin_family)
 511                 snprintf(localstr, sizeof(localstr), " local:%s",
 512                          satostr(local));
 513         else
 514                 localstr[0] = 0;
 515
 516         if (ifindex != IFINDEX_INTERNAL)
 517                 snprintf(portstr, sizeof(portstr), " port:%u", ifindex);
 518         else
 519                 portstr[0] = 0;
 520
 521         if (vrfid != VRF_DEFAULT)
 522                 snprintf(vrfstr, sizeof(vrfstr), " vrf:%u", vrfid);
 523         else
 524                 vrfstr[0] = 0;
 525
 526         va_start(vl, fmt);
 527         vsnprintf(buf, sizeof(buf), fmt, vl);
 528         va_end(vl);
 529
 530         zlog_debug("control-packet: %s [mhop:%s%s%s%s%s]", buf,
 531                    mhop ? "yes" : "no", peerstr, localstr, portstr, vrfstr);
 532 }
 533
 534 int bfd_recv_cb(struct thread *t)
 535 {
 536         int sd = THREAD_FD(t);
 537         struct bfd_session *bfd;
 538         struct bfd_pkt *cp;
 539         bool is_mhop;
 540         ssize_t mlen = 0;
 541         uint8_t ttl = 0;
 542         vrf_id_t vrfid;
 543         ifindex_t ifindex = IFINDEX_INTERNAL;
 544         struct sockaddr_any local, peer;
 545         uint8_t msgbuf[1516];
 546         struct interface *ifp = NULL;
 547         struct bfd_vrf_global *bvrf = THREAD_ARG(t);
 548
 549         /* Schedule next read. */
 550         bfd_sd_reschedule(bvrf, sd);
 551
 552         /* Handle echo packets. */
 553         if (sd == bvrf->bg_echo || sd == bvrf->bg_echov6) {
 554                 ptm_bfd_process_echo_pkt(bvrf, sd);
 555                 return 0;
 556         }
 557
 558         /* Sanitize input/output. */
 559         memset(&local, 0, sizeof(local));
 560         memset(&peer, 0, sizeof(peer));
 561
 562         /* Handle control packets. */
 563         is_mhop = false;
 564         if (sd == bvrf->bg_shop || sd == bvrf->bg_mhop) {
 565                 is_mhop = sd == bvrf->bg_mhop;
 566                 mlen = bfd_recv_ipv4(sd, msgbuf, sizeof(msgbuf), &ttl, &ifindex,
 567                                      &local, &peer);
 568         } else if (sd == bvrf->bg_shop6 || sd == bvrf->bg_mhop6) {
 569                 is_mhop = sd == bvrf->bg_mhop6;
 570                 mlen = bfd_recv_ipv6(sd, msgbuf, sizeof(msgbuf), &ttl, &ifindex,
 571                                      &local, &peer);
 572         }
 573
 574         /*
 575          * With netns backend, we have a separate socket in each VRF. It means
 576          * that bvrf here is correct and we believe the bvrf->vrf->vrf_id.
 577          * With VRF-lite backend, we have a single socket in the default VRF.
 578          * It means that we can't believe the bvrf->vrf->vrf_id. But in
 579          * VRF-lite, the ifindex is globally unique, so we can retrieve the
 580          * correct vrf_id from the interface.
 581          */
 582         vrfid = bvrf->vrf->vrf_id;
 583         if (ifindex) {
 584                 ifp = if_lookup_by_index(ifindex, vrfid);
 585                 if (ifp)
 586                         vrfid = ifp->vrf->vrf_id;
 587         }
 588
 589         /* Implement RFC 5880 6.8.6 */
 590         if (mlen < BFD_PKT_LEN) {
 591                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 592                          "too small (%ld bytes)", mlen);
 593                 return 0;
 594         }
 595
 596         /* Validate single hop packet TTL. */
 597         if ((!is_mhop) && (ttl != BFD_TTL_VAL)) {
 598                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 599                          "invalid TTL: %d expected %d", ttl, BFD_TTL_VAL);
 600                 return 0;
 601         }
 602
 603         /*
 604          * Parse the control header for inconsistencies:
 605          * - Invalid version;
 606          * - Bad multiplier configuration;
 607          * - Short packets;
 608          * - Invalid discriminator;
 609          */
 610         cp = (struct bfd_pkt *)(msgbuf);
 611         if (BFD_GETVER(cp->diag) != BFD_VERSION) {
 612                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 613                          "bad version %d", BFD_GETVER(cp->diag));
 614                 return 0;
 615         }
 616
 617         if (cp->detect_mult == 0) {
 618                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 619                          "detect multiplier set to zero");
 620                 return 0;
 621         }
 622
 623         if ((cp->len < BFD_PKT_LEN) || (cp->len > mlen)) {
 624                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid, "too small");
 625                 return 0;
 626         }
 627
 628         if (cp->discrs.my_discr == 0) {
 629                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 630                          "'my discriminator' is zero");
 631                 return 0;
 632         }
 633
 634         /* Find the session that this packet belongs. */
 635         bfd = ptm_bfd_sess_find(cp, &peer, &local, ifp, vrfid, is_mhop);
 636         if (bfd == NULL) {
 637                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 638                          "no session found");
 639                 return 0;
 640         }
 641
 642         bfd->stats.rx_ctrl_pkt++;
 643
 644         /*
 645          * Multi hop: validate packet TTL.
 646          * Single hop: set local address that received the packet.
 647          */
 648         if (is_mhop) {
 649                 if (ttl < bfd->mh_ttl) {
 650                         cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 651                                  "exceeded max hop count (expected %d, got %d)",
 652                                  bfd->mh_ttl, ttl);
 653                         return 0;
 654                 }
 655         } else if (bfd->local_address.sa_sin.sin_family == AF_UNSPEC) {
 656                 bfd->local_address = local;
 657         }
 658
 659         /*
 660          * If no interface was detected, save the interface where the
 661          * packet came in.
 662          */
 663         if (!is_mhop && bfd->ifp == NULL)
 664                 bfd->ifp = ifp;
 665
 666         /* Log remote discriminator changes. */
 667         if ((bfd->discrs.remote_discr != 0)
 668             && (bfd->discrs.remote_discr != ntohl(cp->discrs.my_discr)))
 669                 cp_debug(is_mhop, &peer, &local, ifindex, vrfid,
 670                          "remote discriminator mismatch (expected %u, got %u)",
 671                          bfd->discrs.remote_discr, ntohl(cp->discrs.my_discr));
 672
 673         bfd->discrs.remote_discr = ntohl(cp->discrs.my_discr);
 674
 675         /* Save remote diagnostics before state switch. */
 676         bfd->remote_diag = cp->diag & BFD_DIAGMASK;
 677
 678         /* Update remote timers settings. */
 679         bfd->remote_timers.desired_min_tx = ntohl(cp->timers.desired_min_tx);
 680         bfd->remote_timers.required_min_rx = ntohl(cp->timers.required_min_rx);
 681         bfd->remote_timers.required_min_echo =
 682                 ntohl(cp->timers.required_min_echo);
 683         bfd->remote_detect_mult = cp->detect_mult;
 684
 685         if (BFD_GETCBIT(cp->flags))
 686                 bfd->remote_cbit = 1;
 687         else
 688                 bfd->remote_cbit = 0;
 689
 690         /* State switch from section 6.2. */
 691         bs_state_handler(bfd, BFD_GETSTATE(cp->flags));
 692
 693         /* RFC 5880, Section 6.5: handle POLL/FINAL negotiation sequence. */
 694         if (bfd->polling && BFD_GETFBIT(cp->flags)) {
 695                 /* Disable pooling. */
 696                 bfd->polling = 0;
 697
 698                 /* Handle poll finalization. */
 699                 bs_final_handler(bfd);
 700         } else {
 701                 /* Received a packet, lets update the receive timer. */
 702                 bfd_recvtimer_update(bfd);
 703         }
 704
 705         /* Handle echo timers changes. */
 706         bs_echo_timer_handler(bfd);
 707
 708         /*
 709          * We've received a packet with the POLL bit set, we must send
 710          * a control packet back with the FINAL bit set.
 711          *
 712          * RFC 5880, Section 6.5.
 713          */
 714         if (BFD_GETPBIT(cp->flags)) {
 715                 /* We are finalizing a poll negotiation. */
 716                 bs_final_handler(bfd);
 717
 718                 /* Send the control packet with the final bit immediately. */
 719                 ptm_bfd_snd(bfd, 1);
 720         }
 721
 722         return 0;
 723 }
 724
 725 /*
 726  * bp_bfd_echo_in: proccesses an BFD echo packet. On TTL == BFD_TTL_VAL
 727  * the packet is looped back or returns the my discriminator ID along
 728  * with the TTL.
 729  *
 730  * Returns -1 on error or loopback or 0 on success.
 731  */
 732 int bp_bfd_echo_in(struct bfd_vrf_global *bvrf, int sd,
 733                    uint8_t *ttl, uint32_t *my_discr)
 734 {
 735         struct bfd_echo_pkt *bep;
 736         ssize_t rlen;
 737         struct sockaddr_any local, peer;
 738         ifindex_t ifindex = IFINDEX_INTERNAL;
 739         vrf_id_t vrfid = VRF_DEFAULT;
 740         uint8_t msgbuf[1516];
 741
 742         if (sd == bvrf->bg_echo)
 743                 rlen = bfd_recv_ipv4(sd, msgbuf, sizeof(msgbuf), ttl, &ifindex,
 744                                      &local, &peer);
 745         else
 746                 rlen = bfd_recv_ipv6(sd, msgbuf, sizeof(msgbuf), ttl, &ifindex,
 747                                      &local, &peer);
 748
 749         /* Short packet, better not risk reading it. */
 750         if (rlen < (ssize_t)sizeof(*bep)) {
 751                 cp_debug(false, &peer, &local, ifindex, vrfid,
 752                          "small echo packet");
 753                 return -1;
 754         }
 755
 756         /* Test for loopback. */
 757         if (*ttl == BFD_TTL_VAL) {
 758                 bp_udp_send(sd, *ttl - 1, msgbuf, rlen,
 759                             (struct sockaddr *)&peer,
 760                             (sd == bvrf->bg_echo) ? sizeof(peer.sa_sin)
 761                                                     : sizeof(peer.sa_sin6));
 762                 return -1;
 763         }
 764
 765         /* Read my discriminator from BFD Echo packet. */
 766         bep = (struct bfd_echo_pkt *)msgbuf;
 767         *my_discr = ntohl(bep->my_discr);
 768         if (*my_discr == 0) {
 769                 cp_debug(false, &peer, &local, ifindex, vrfid,
 770                          "invalid echo packet discriminator (zero)");
 771                 return -1;
 772         }
 773
 774         return 0;
 775 }
 776
 777 int bp_udp_send(int sd, uint8_t ttl, uint8_t *data, size_t datalen,
 778                 struct sockaddr *to, socklen_t tolen)
 779 {
 780         struct cmsghdr *cmsg;
 781         ssize_t wlen;
 782         int ttlval = ttl;
 783         bool is_ipv6 = to->sa_family == AF_INET6;
 784         struct msghdr msg;
 785         struct iovec iov[1];
 786         uint8_t msgctl[255];
 787
 788         /* Prepare message data. */
 789         iov[0].iov_base = data;
 790         iov[0].iov_len = datalen;
 791
 792         memset(&msg, 0, sizeof(msg));
 793         memset(msgctl, 0, sizeof(msgctl));
 794         msg.msg_name = to;
 795         msg.msg_namelen = tolen;
 796         msg.msg_iov = iov;
 797         msg.msg_iovlen = 1;
 798
 799         /* Prepare the packet TTL information. */
 800         if (ttl > 0) {
 801                 /* Use ancillary data. */
 802                 msg.msg_control = msgctl;
 803                 msg.msg_controllen = CMSG_LEN(sizeof(ttlval));
 804
 805                 /* Configure the ancillary data. */
 806                 cmsg = CMSG_FIRSTHDR(&msg);
 807                 cmsg->cmsg_len = CMSG_LEN(sizeof(ttlval));
 808                 if (is_ipv6) {
 809                         cmsg->cmsg_level = IPPROTO_IPV6;
 810                         cmsg->cmsg_type = IPV6_HOPLIMIT;
 811                 } else {
 812 #ifdef BFD_LINUX
 813                         cmsg->cmsg_level = IPPROTO_IP;
 814                         cmsg->cmsg_type = IP_TTL;
 815 #else
 816                         /* FreeBSD does not support TTL in ancillary data. */
 817                         msg.msg_control = NULL;
 818                         msg.msg_controllen = 0;
 819
 820                         bp_set_ttl(sd, ttl);
 821 #endif /* BFD_BSD */
 822                 }
 823                 memcpy(CMSG_DATA(cmsg), &ttlval, sizeof(ttlval));
 824         }
 825
 826         /* Send echo back. */
 827         wlen = sendmsg(sd, &msg, 0);
 828         if (wlen <= 0) {
 829                 if (bglobal.debug_network)
 830                         zlog_debug("udp-send: loopback failure: (%d) %s", errno,
 831                                    strerror(errno));
 832                 return -1;
 833         } else if (wlen < (ssize_t)datalen) {
 834                 if (bglobal.debug_network)
 835                         zlog_debug("udp-send: partial send: %zd expected %zu",
 836                                    wlen, datalen);
 837                 return -1;
 838         }
 839
 840         return 0;
 841 }
 842
 843
 844 /*
 845  * Sockets creation.
 846  */
 847
 848
 849 /*
 850  * IPv4 sockets
 851  */
 852 int bp_set_ttl(int sd, uint8_t value)
 853 {
 854         int ttl = value;
 855
 856         if (setsockopt(sd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) == -1) {
 857                 zlog_warn("set-ttl: setsockopt(IP_TTL, %d): %s", value,
 858                           strerror(errno));
 859                 return -1;
 860         }
 861
 862         return 0;
 863 }
 864
 865 int bp_set_tos(int sd, uint8_t value)
 866 {
 867         int tos = value;
 868
 869         if (setsockopt(sd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) == -1) {
 870                 zlog_warn("set-tos: setsockopt(IP_TOS, %d): %s", value,
 871                           strerror(errno));
 872                 return -1;
 873         }
 874
 875         return 0;
 876 }
 877
 878 static void bp_set_ipopts(int sd)
 879 {
 880         int rcvttl = BFD_RCV_TTL_VAL;
 881
 882         if (bp_set_ttl(sd, BFD_TTL_VAL) != 0)
 883                 zlog_fatal("set-ipopts: TTL configuration failed");
 884
 885         if (setsockopt(sd, IPPROTO_IP, IP_RECVTTL, &rcvttl, sizeof(rcvttl))
 886             == -1)
 887                 zlog_fatal("set-ipopts: setsockopt(IP_RECVTTL, %d): %s", rcvttl,
 888                            strerror(errno));
 889
 890 #ifdef BFD_LINUX
 891         int pktinfo = BFD_PKT_INFO_VAL;
 892
 893         /* Figure out address and interface to do the peer matching. */
 894         if (setsockopt(sd, IPPROTO_IP, IP_PKTINFO, &pktinfo, sizeof(pktinfo))
 895             == -1)
 896                 zlog_fatal("set-ipopts: setsockopt(IP_PKTINFO, %d): %s",
 897                            pktinfo, strerror(errno));
 898 #endif /* BFD_LINUX */
 899 #ifdef BFD_BSD
 900         int yes = 1;
 901
 902         /* Find out our address for peer matching. */
 903         if (setsockopt(sd, IPPROTO_IP, IP_RECVDSTADDR, &yes, sizeof(yes)) == -1)
 904                 zlog_fatal("set-ipopts: setsockopt(IP_RECVDSTADDR, %d): %s",
 905                            yes, strerror(errno));
 906
 907         /* Find out interface where the packet came in. */
 908         if (setsockopt_ifindex(AF_INET, sd, yes) == -1)
 909                 zlog_fatal("set-ipopts: setsockopt_ipv4_ifindex(%d): %s", yes,
 910                            strerror(errno));
 911 #endif /* BFD_BSD */
 912 }
 913
 914 static void bp_bind_ip(int sd, uint16_t port)
 915 {
 916         struct sockaddr_in sin;
 917
 918         memset(&sin, 0, sizeof(sin));
 919         sin.sin_family = AF_INET;
 920         sin.sin_addr.s_addr = htonl(INADDR_ANY);
 921         sin.sin_port = htons(port);
 922         if (bind(sd, (struct sockaddr *)&sin, sizeof(sin)) == -1)
 923                 zlog_fatal("bind-ip: bind: %s", strerror(errno));
 924 }
 925
 926 int bp_udp_shop(const struct vrf *vrf)
 927 {
 928         int sd;
 929
 930         frr_with_privs(&bglobal.bfdd_privs) {
 931                 sd = vrf_socket(AF_INET, SOCK_DGRAM, PF_UNSPEC, vrf->vrf_id,
 932                                 vrf->name);
 933         }
 934         if (sd == -1)
 935                 zlog_fatal("udp-shop: socket: %s", strerror(errno));
 936
 937         bp_set_ipopts(sd);
 938         bp_bind_ip(sd, BFD_DEFDESTPORT);
 939         return sd;
 940 }
 941
 942 int bp_udp_mhop(const struct vrf *vrf)
 943 {
 944         int sd;
 945
 946         frr_with_privs(&bglobal.bfdd_privs) {
 947                 sd = vrf_socket(AF_INET, SOCK_DGRAM, PF_UNSPEC, vrf->vrf_id,
 948                                 vrf->name);
 949         }
 950         if (sd == -1)
 951                 zlog_fatal("udp-mhop: socket: %s", strerror(errno));
 952
 953         bp_set_ipopts(sd);
 954         bp_bind_ip(sd, BFD_DEF_MHOP_DEST_PORT);
 955
 956         return sd;
 957 }
 958
 959 int bp_peer_socket(const struct bfd_session *bs)
 960 {
 961         int sd, pcount;
 962         struct sockaddr_in sin;
 963         static int srcPort = BFD_SRCPORTINIT;
 964         const char *device_to_bind = NULL;
 965
 966         if (bs->key.ifname[0])
 967                 device_to_bind = (const char *)bs->key.ifname;
 968         else if ((!vrf_is_backend_netns() && bs->vrf->vrf_id != VRF_DEFAULT)
 969                  || ((CHECK_FLAG(bs->flags, BFD_SESS_FLAG_MH)
 970                       && bs->key.vrfname[0])))
 971                 device_to_bind = (const char *)bs->key.vrfname;
 972
 973         frr_with_privs(&bglobal.bfdd_privs) {
 974                 sd = vrf_socket(AF_INET, SOCK_DGRAM, PF_UNSPEC,
 975                                 bs->vrf->vrf_id, device_to_bind);
 976         }
 977         if (sd == -1) {
 978                 zlog_err("ipv4-new: failed to create socket: %s",
 979                          strerror(errno));
 980                 return -1;
 981         }
 982
 983         /* Set TTL to 255 for all transmitted packets */
 984         if (bp_set_ttl(sd, BFD_TTL_VAL) != 0) {
 985                 close(sd);
 986                 return -1;
 987         }
 988
 989         /* Set TOS to CS6 for all transmitted packets */
 990         if (bp_set_tos(sd, BFD_TOS_VAL) != 0) {
 991                 close(sd);
 992                 return -1;
 993         }
 994
 995         /* Find an available source port in the proper range */
 996         memset(&sin, 0, sizeof(sin));
 997         sin.sin_family = AF_INET;
 998 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 999         sin.sin_len = sizeof(sin);
1000 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
1001         memcpy(&sin.sin_addr, &bs->key.local, sizeof(sin.sin_addr));
1002         if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_MH) == 0)
1003                 sin.sin_addr.s_addr = INADDR_ANY;
1004
1005         pcount = 0;
1006         do {
1007                 if ((++pcount) > (BFD_SRCPORTMAX - BFD_SRCPORTINIT)) {
1008                         /* Searched all ports, none available */
1009                         zlog_err("ipv4-new: failed to bind port: %s",
1010                                  strerror(errno));
1011                         close(sd);
1012                         return -1;
1013                 }
1014                 if (srcPort >= BFD_SRCPORTMAX)
1015                         srcPort = BFD_SRCPORTINIT;
1016                 sin.sin_port = htons(srcPort++);
1017         } while (bind(sd, (struct sockaddr *)&sin, sizeof(sin)) < 0);
1018
1019         return sd;
1020 }
1021
1022
1023 /*
1024  * IPv6 sockets
1025  */
1026
1027 int bp_peer_socketv6(const struct bfd_session *bs)
1028 {
1029         int sd, pcount;
1030         struct sockaddr_in6 sin6;
1031         static int srcPort = BFD_SRCPORTINIT;
1032         const char *device_to_bind = NULL;
1033
1034         if (bs->key.ifname[0])
1035                 device_to_bind = (const char *)bs->key.ifname;
1036         else if ((!vrf_is_backend_netns() && bs->vrf->vrf_id != VRF_DEFAULT)
1037                  || ((CHECK_FLAG(bs->flags, BFD_SESS_FLAG_MH)
1038                       && bs->key.vrfname[0])))
1039                 device_to_bind = (const char *)bs->key.vrfname;
1040
1041         frr_with_privs(&bglobal.bfdd_privs) {
1042                 sd = vrf_socket(AF_INET6, SOCK_DGRAM, PF_UNSPEC,
1043                                 bs->vrf->vrf_id, device_to_bind);
1044         }
1045         if (sd == -1) {
1046                 zlog_err("ipv6-new: failed to create socket: %s",
1047                          strerror(errno));
1048                 return -1;
1049         }
1050
1051         /* Set TTL to 255 for all transmitted packets */
1052         if (bp_set_ttlv6(sd, BFD_TTL_VAL) != 0) {
1053                 close(sd);
1054                 return -1;
1055         }
1056
1057         /* Set TOS to CS6 for all transmitted packets */
1058         if (bp_set_tosv6(sd, BFD_TOS_VAL) != 0) {
1059                 close(sd);
1060                 return -1;
1061         }
1062
1063         /* Find an available source port in the proper range */
1064         memset(&sin6, 0, sizeof(sin6));
1065         sin6.sin6_family = AF_INET6;
1066 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
1067         sin6.sin6_len = sizeof(sin6);
1068 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
1069         memcpy(&sin6.sin6_addr, &bs->key.local, sizeof(sin6.sin6_addr));
1070         if (bs->ifp && IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr))
1071                 sin6.sin6_scope_id = bs->ifp->ifindex;
1072
1073         pcount = 0;
1074         do {
1075                 if ((++pcount) > (BFD_SRCPORTMAX - BFD_SRCPORTINIT)) {
1076                         /* Searched all ports, none available */
1077                         zlog_err("ipv6-new: failed to bind port: %s",
1078                                  strerror(errno));
1079                         close(sd);
1080                         return -1;
1081                 }
1082                 if (srcPort >= BFD_SRCPORTMAX)
1083                         srcPort = BFD_SRCPORTINIT;
1084                 sin6.sin6_port = htons(srcPort++);
1085         } while (bind(sd, (struct sockaddr *)&sin6, sizeof(sin6)) < 0);
1086
1087         return sd;
1088 }
1089
1090 int bp_set_ttlv6(int sd, uint8_t value)
1091 {
1092         int ttl = value;
1093
1094         if (setsockopt(sd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl))
1095             == -1) {
1096                 zlog_warn("set-ttlv6: setsockopt(IPV6_UNICAST_HOPS, %d): %s",
1097                           value, strerror(errno));
1098                 return -1;
1099         }
1100
1101         return 0;
1102 }
1103
1104 int bp_set_tosv6(int sd, uint8_t value)
1105 {
1106         int tos = value;
1107
1108         if (setsockopt(sd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof(tos))
1109             == -1) {
1110                 zlog_warn("set-tosv6: setsockopt(IPV6_TCLASS, %d): %s", value,
1111                           strerror(errno));
1112                 return -1;
1113         }
1114
1115         return 0;
1116 }
1117
1118 static void bp_set_ipv6opts(int sd)
1119 {
1120         int ipv6_pktinfo = BFD_IPV6_PKT_INFO_VAL;
1121         int ipv6_only = BFD_IPV6_ONLY_VAL;
1122
1123         if (bp_set_ttlv6(sd, BFD_TTL_VAL) == -1)
1124                 zlog_fatal(
1125                         "set-ipv6opts: setsockopt(IPV6_UNICAST_HOPS, %d): %s",
1126                         BFD_TTL_VAL, strerror(errno));
1127
1128         if (setsockopt_ipv6_hoplimit(sd, BFD_RCV_TTL_VAL) == -1)
1129                 zlog_fatal("set-ipv6opts: setsockopt(IPV6_HOPLIMIT, %d): %s",
1130                            BFD_RCV_TTL_VAL, strerror(errno));
1131
1132         if (setsockopt_ipv6_pktinfo(sd, ipv6_pktinfo) == -1)
1133                 zlog_fatal("set-ipv6opts: setsockopt(IPV6_PKTINFO, %d): %s",
1134                            ipv6_pktinfo, strerror(errno));
1135
1136         if (setsockopt(sd, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6_only,
1137                        sizeof(ipv6_only))
1138             == -1)
1139                 zlog_fatal("set-ipv6opts: setsockopt(IPV6_V6ONLY, %d): %s",
1140                            ipv6_only, strerror(errno));
1141 }
1142
1143 static void bp_bind_ipv6(int sd, uint16_t port)
1144 {
1145         struct sockaddr_in6 sin6;
1146
1147         memset(&sin6, 0, sizeof(sin6));
1148         sin6.sin6_family = AF_INET6;
1149         sin6.sin6_addr = in6addr_any;
1150         sin6.sin6_port = htons(port);
1151 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
1152         sin6.sin6_len = sizeof(sin6);
1153 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
1154         if (bind(sd, (struct sockaddr *)&sin6, sizeof(sin6)) == -1)
1155                 zlog_fatal("bind-ipv6: bind: %s", strerror(errno));
1156 }
1157
1158 int bp_udp6_shop(const struct vrf *vrf)
1159 {
1160         int sd;
1161
1162         frr_with_privs(&bglobal.bfdd_privs) {
1163                 sd = vrf_socket(AF_INET6, SOCK_DGRAM, PF_UNSPEC, vrf->vrf_id,
1164                                 vrf->name);
1165         }
1166         if (sd == -1) {
1167                 if (errno != EAFNOSUPPORT)
1168                         zlog_fatal("udp6-shop: socket: %s", strerror(errno));
1169                 else
1170                         zlog_warn("udp6-shop: V6 is not supported, continuing");
1171
1172                 return -1;
1173         }
1174
1175         bp_set_ipv6opts(sd);
1176         bp_bind_ipv6(sd, BFD_DEFDESTPORT);
1177
1178         return sd;
1179 }
1180
1181 int bp_udp6_mhop(const struct vrf *vrf)
1182 {
1183         int sd;
1184
1185         frr_with_privs(&bglobal.bfdd_privs) {
1186                 sd = vrf_socket(AF_INET6, SOCK_DGRAM, PF_UNSPEC, vrf->vrf_id,
1187                                 vrf->name);
1188         }
1189         if (sd == -1) {
1190                 if (errno != EAFNOSUPPORT)
1191                         zlog_fatal("udp6-mhop: socket: %s", strerror(errno));
1192                 else
1193                         zlog_warn("udp6-mhop: V6 is not supported, continuing");
1194
1195                 return -1;
1196         }
1197
1198         bp_set_ipv6opts(sd);
1199         bp_bind_ipv6(sd, BFD_DEF_MHOP_DEST_PORT);
1200
1201         return sd;
1202 }
1203
1204 int bp_echo_socket(const struct vrf *vrf)
1205 {
1206         int s;
1207
1208         frr_with_privs(&bglobal.bfdd_privs) {
1209                 s = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf->vrf_id, vrf->name);
1210         }
1211         if (s == -1)
1212                 zlog_fatal("echo-socket: socket: %s", strerror(errno));
1213
1214         bp_set_ipopts(s);
1215         bp_bind_ip(s, BFD_DEF_ECHO_PORT);
1216
1217         return s;
1218 }
1219
1220 int bp_echov6_socket(const struct vrf *vrf)
1221 {
1222         int s;
1223
1224         frr_with_privs(&bglobal.bfdd_privs) {
1225                 s = vrf_socket(AF_INET6, SOCK_DGRAM, 0, vrf->vrf_id, vrf->name);
1226         }
1227         if (s == -1) {
1228                 if (errno != EAFNOSUPPORT)
1229                         zlog_fatal("echov6-socket: socket: %s",
1230                                    strerror(errno));
1231                 else
1232                         zlog_warn("echov6-socket: V6 is not supported, continuing");
1233
1234                 return -1;
1235         }
1236
1237         bp_set_ipv6opts(s);
1238         bp_bind_ipv6(s, BFD_DEF_ECHO_PORT);
1239
1240         return s;
1241 }