src/vnet/bfd/bfd_udp.c

   1 /*
   2  * Copyright (c) 2011-2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /**
  16  * @file
  17  * @brief BFD UDP transport layer implementation
  18  */
  19 #include <vppinfra/types.h>
  20 #include <vlibmemory/api.h>
  21 #include <vlib/vlib.h>
  22 #include <vlib/buffer.h>
  23 #include <vnet/ip/format.h>
  24 #include <vnet/ethernet/packet.h>
  25 #include <vnet/udp/udp_packet.h>
  26 #include <vnet/udp/udp.h>
  27 #include <vnet/ip/lookup.h>
  28 #include <vnet/ip/icmp46_packet.h>
  29 #include <vnet/ip/ip4.h>
  30 #include <vnet/ip/ip6.h>
  31 #include <vnet/ip/ip6_packet.h>
  32 #include <vnet/adj/adj.h>
  33 #include <vnet/adj/adj_nbr.h>
  34 #include <vnet/dpo/receive_dpo.h>
  35 #include <vnet/fib/fib_entry.h>
  36 #include <vnet/fib/fib_table.h>
  37 #include <vnet/bfd/bfd_debug.h>
  38 #include <vnet/bfd/bfd_udp.h>
  39 #include <vnet/bfd/bfd_main.h>
  40 #include <vnet/bfd/bfd_api.h>
  41
  42 typedef struct
  43 {
  44   bfd_main_t *bfd_main;
  45   /* hashmap - bfd session index by bfd key - used for CLI/API lookup, where
  46    * discriminator is unknown */
  47   mhash_t bfd_session_idx_by_bfd_key;
  48   /* convenience variable */
  49   vnet_main_t *vnet_main;
  50   /* flag indicating whether echo_source_sw_if_index holds a valid value */
  51   int echo_source_is_set;
  52   /* loopback interface used to get echo source ip */
  53   u32 echo_source_sw_if_index;
  54   /* node index of "ip4-arp" node */
  55   u32 ip4_arp_idx;
  56   /* node index of "ip6-discover-neighbor" node */
  57   u32 ip6_ndp_idx;
  58   /* node index of "ip4-rewrite" node */
  59   u32 ip4_rewrite_idx;
  60   /* node index of "ip6-rewrite" node */
  61   u32 ip6_rewrite_idx;
  62   /* log class */
  63   vlib_log_class_t log_class;
  64 } bfd_udp_main_t;
  65
  66 static vlib_node_registration_t bfd_udp4_input_node;
  67 static vlib_node_registration_t bfd_udp6_input_node;
  68 static vlib_node_registration_t bfd_udp_echo4_input_node;
  69 static vlib_node_registration_t bfd_udp_echo6_input_node;
  70
  71 bfd_udp_main_t bfd_udp_main;
  72
  73 vnet_api_error_t
  74 bfd_udp_set_echo_source (u32 sw_if_index)
  75 {
  76   vnet_sw_interface_t *sw_if =
  77     vnet_get_sw_interface_safe (bfd_udp_main.vnet_main, sw_if_index);
  78   if (sw_if)
  79     {
  80       bfd_udp_main.echo_source_sw_if_index = sw_if_index;
  81       bfd_udp_main.echo_source_is_set = 1;
  82       return 0;
  83     }
  84   return VNET_API_ERROR_BFD_ENOENT;
  85 }
  86
  87 vnet_api_error_t
  88 bfd_udp_del_echo_source (u32 sw_if_index)
  89 {
  90   bfd_udp_main.echo_source_sw_if_index = ~0;
  91   bfd_udp_main.echo_source_is_set = 0;
  92   return 0;
  93 }
  94
  95 int
  96 bfd_udp_is_echo_available (bfd_transport_e transport)
  97 {
  98   if (!bfd_udp_main.echo_source_is_set)
  99     {
 100       BFD_DBG ("UDP echo source not set - echo not available");
 101       return 0;
 102     }
 103   /*
 104    * for the echo to work, we need a loopback interface with at least one
 105    * address with netmask length at most 31 (ip4) or 127 (ip6) so that we can
 106    * pick an unused address from that subnet
 107    */
 108   vnet_sw_interface_t *sw_if =
 109     vnet_get_sw_interface_safe (bfd_udp_main.vnet_main,
 110                                 bfd_udp_main.echo_source_sw_if_index);
 111   if (sw_if && sw_if->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 112     {
 113       if (BFD_TRANSPORT_UDP4 == transport)
 114         {
 115           ip4_main_t *im = &ip4_main;
 116           ip_interface_address_t *ia = NULL;
 117           /* *INDENT-OFF* */
 118           foreach_ip_interface_address (&im->lookup_main, ia,
 119                                         bfd_udp_main.echo_source_sw_if_index,
 120                                         0 /* honor unnumbered */, ({
 121                                           if (ia->address_length <= 31)
 122                                             {
 123                                               return 1;
 124                                             }
 125                                         }));
 126           /* *INDENT-ON* */
 127         }
 128       else if (BFD_TRANSPORT_UDP6 == transport)
 129         {
 130           ip6_main_t *im = &ip6_main;
 131           ip_interface_address_t *ia = NULL;
 132           /* *INDENT-OFF* */
 133           foreach_ip_interface_address (&im->lookup_main, ia,
 134                                         bfd_udp_main.echo_source_sw_if_index,
 135                                         0 /* honor unnumbered */, ({
 136                                           if (ia->address_length <= 127)
 137                                             {
 138                                               return 1;
 139                                             }
 140                                         }));
 141           /* *INDENT-ON* */
 142         }
 143     }
 144   BFD_DBG ("No usable IP address for UDP echo - echo not available");
 145   return 0;
 146 }
 147
 148 static u16
 149 bfd_udp_bs_idx_to_sport (u32 bs_idx)
 150 {
 151   /* The source port MUST be in the range 49152 through 65535. The same UDP
 152    * source port number MUST be used for all BFD Control packets associated
 153    * with a particular session.  The source port number SHOULD be unique among
 154    * all BFD sessions on the system. If more than 16384 BFD sessions are
 155    * simultaneously active, UDP source port numbers MAY be reused on
 156    * multiple sessions, but the number of distinct uses of the same UDP
 157    * source port number SHOULD be minimized.
 158    */
 159   return 49152 + bs_idx % (65535 - 49152 + 1);
 160 }
 161
 162 int
 163 bfd_udp_get_echo_src_ip4 (ip4_address_t * addr)
 164 {
 165   if (!bfd_udp_main.echo_source_is_set)
 166     {
 167       BFD_ERR ("cannot find ip4 address, echo source not set");
 168       return 0;
 169     }
 170   ip_interface_address_t *ia = NULL;
 171   ip4_main_t *im = &ip4_main;
 172
 173   /* *INDENT-OFF* */
 174   foreach_ip_interface_address (
 175       &im->lookup_main, ia, bfd_udp_main.echo_source_sw_if_index,
 176       0 /* honor unnumbered */, ({
 177         ip4_address_t *x =
 178             ip_interface_address_get_address (&im->lookup_main, ia);
 179         if (ia->address_length <= 31)
 180           {
 181             addr->as_u32 = clib_host_to_net_u32 (x->as_u32);
 182             /*
 183              * flip the last bit to get a different address, might be network,
 184              * we don't care ...
 185              */
 186             addr->as_u32 ^= 1;
 187             addr->as_u32 = clib_net_to_host_u32 (addr->as_u32);
 188             return 1;
 189           }
 190       }));
 191   /* *INDENT-ON* */
 192   BFD_ERR ("cannot find ip4 address, no usable address found");
 193   return 0;
 194 }
 195
 196 int
 197 bfd_udp_get_echo_src_ip6 (ip6_address_t * addr)
 198 {
 199   if (!bfd_udp_main.echo_source_is_set)
 200     {
 201       BFD_ERR ("cannot find ip6 address, echo source not set");
 202       return 0;
 203     }
 204   ip_interface_address_t *ia = NULL;
 205   ip6_main_t *im = &ip6_main;
 206
 207   /* *INDENT-OFF* */
 208   foreach_ip_interface_address (
 209       &im->lookup_main, ia, bfd_udp_main.echo_source_sw_if_index,
 210       0 /* honor unnumbered */, ({
 211         ip6_address_t *x =
 212             ip_interface_address_get_address (&im->lookup_main, ia);
 213         if (ia->address_length <= 127)
 214           {
 215             *addr = *x;
 216             addr->as_u8[15] ^= 1; /* flip the last bit of the address */
 217             return 1;
 218           }
 219       }));
 220   /* *INDENT-ON* */
 221   BFD_ERR ("cannot find ip6 address, no usable address found");
 222   return 0;
 223 }
 224
 225 void
 226 bfd_udp_get_echo_source (int *is_set, u32 * sw_if_index,
 227                          int *have_usable_ip4, ip4_address_t * ip4,
 228                          int *have_usable_ip6, ip6_address_t * ip6)
 229 {
 230   if (bfd_udp_main.echo_source_is_set)
 231     {
 232       *is_set = 1;
 233       *sw_if_index = bfd_udp_main.echo_source_sw_if_index;
 234       *have_usable_ip4 = bfd_udp_get_echo_src_ip4 (ip4);
 235       *have_usable_ip6 = bfd_udp_get_echo_src_ip6 (ip6);
 236     }
 237   else
 238     {
 239       *is_set = 0;
 240     }
 241 }
 242
 243 int
 244 bfd_add_udp4_transport (vlib_main_t * vm, u32 bi, const bfd_session_t * bs,
 245                         int is_echo)
 246 {
 247   const bfd_udp_session_t *bus = &bs->udp;
 248   const bfd_udp_key_t *key = &bus->key;
 249   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 250
 251   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 252   vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
 253   vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
 254   vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
 255   vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0;
 256   typedef struct
 257   {
 258     ip4_header_t ip4;
 259     udp_header_t udp;
 260   } ip4_udp_headers;
 261   ip4_udp_headers *headers = NULL;
 262   vlib_buffer_advance (b, -sizeof (*headers));
 263   headers = vlib_buffer_get_current (b);
 264   memset (headers, 0, sizeof (*headers));
 265   headers->ip4.ip_version_and_header_length = 0x45;
 266   headers->ip4.ttl = 255;
 267   headers->ip4.protocol = IP_PROTOCOL_UDP;
 268   headers->udp.src_port =
 269     clib_host_to_net_u16 (bfd_udp_bs_idx_to_sport (bs->bs_idx));
 270   if (is_echo)
 271     {
 272       int rv;
 273       if (!(rv = bfd_udp_get_echo_src_ip4 (&headers->ip4.src_address)))
 274         {
 275           return rv;
 276         }
 277       headers->ip4.dst_address.as_u32 = key->local_addr.ip4.as_u32;
 278       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd_echo4);
 279     }
 280   else
 281     {
 282       headers->ip4.src_address.as_u32 = key->local_addr.ip4.as_u32;
 283       headers->ip4.dst_address.as_u32 = key->peer_addr.ip4.as_u32;
 284       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd4);
 285     }
 286
 287   /* fix ip length, checksum and udp length */
 288   const u16 ip_length = vlib_buffer_length_in_chain (vm, b);
 289
 290   headers->ip4.length = clib_host_to_net_u16 (ip_length);
 291   headers->ip4.checksum = ip4_header_checksum (&headers->ip4);
 292
 293   const u16 udp_length = ip_length - (sizeof (headers->ip4));
 294   headers->udp.length = clib_host_to_net_u16 (udp_length);
 295   return 1;
 296 }
 297
 298 int
 299 bfd_add_udp6_transport (vlib_main_t * vm, u32 bi, const bfd_session_t * bs,
 300                         int is_echo)
 301 {
 302   const bfd_udp_session_t *bus = &bs->udp;
 303   const bfd_udp_key_t *key = &bus->key;
 304   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 305
 306   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 307   vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
 308   vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
 309   vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
 310   vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
 311   typedef struct
 312   {
 313     ip6_header_t ip6;
 314     udp_header_t udp;
 315   } ip6_udp_headers;
 316   ip6_udp_headers *headers = NULL;
 317   vlib_buffer_advance (b, -sizeof (*headers));
 318   headers = vlib_buffer_get_current (b);
 319   memset (headers, 0, sizeof (*headers));
 320   headers->ip6.ip_version_traffic_class_and_flow_label =
 321     clib_host_to_net_u32 (0x6 << 28);
 322   headers->ip6.hop_limit = 255;
 323   headers->ip6.protocol = IP_PROTOCOL_UDP;
 324   headers->udp.src_port =
 325     clib_host_to_net_u16 (bfd_udp_bs_idx_to_sport (bs->bs_idx));
 326   if (is_echo)
 327     {
 328       int rv;
 329       if (!(rv = bfd_udp_get_echo_src_ip6 (&headers->ip6.src_address)))
 330         {
 331           return rv;
 332         }
 333       clib_memcpy (&headers->ip6.dst_address, &key->local_addr.ip6,
 334                    sizeof (headers->ip6.dst_address));
 335
 336       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd_echo6);
 337     }
 338   else
 339     {
 340       clib_memcpy (&headers->ip6.src_address, &key->local_addr.ip6,
 341                    sizeof (headers->ip6.src_address));
 342       clib_memcpy (&headers->ip6.dst_address, &key->peer_addr.ip6,
 343                    sizeof (headers->ip6.dst_address));
 344       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd6);
 345     }
 346
 347   /* fix ip payload length and udp length */
 348   const u16 udp_length =
 349     vlib_buffer_length_in_chain (vm, b) - (sizeof (headers->ip6));
 350   headers->udp.length = clib_host_to_net_u16 (udp_length);
 351   headers->ip6.payload_length = headers->udp.length;
 352
 353   /* IPv6 UDP checksum is mandatory */
 354   int bogus = 0;
 355   headers->udp.checksum =
 356     ip6_tcp_udp_icmp_compute_checksum (vm, b, &headers->ip6, &bogus);
 357   ASSERT (bogus == 0);
 358   if (headers->udp.checksum == 0)
 359     {
 360       headers->udp.checksum = 0xffff;
 361     }
 362   return 1;
 363 }
 364
 365 static void
 366 bfd_create_frame_to_next_node (vlib_main_t * vm, u32 bi, u32 next_node)
 367 {
 368   vlib_frame_t *f = vlib_get_frame_to_node (vm, next_node);
 369   u32 *to_next = vlib_frame_vector_args (f);
 370   to_next[0] = bi;
 371   f->n_vectors = 1;
 372   vlib_put_frame_to_node (vm, next_node, f);
 373 }
 374
 375 int
 376 bfd_udp_calc_next_node (const struct bfd_session_s *bs, u32 * next_node)
 377 {
 378   const bfd_udp_session_t *bus = &bs->udp;
 379   ip_adjacency_t *adj = adj_get (bus->adj_index);
 380   switch (adj->lookup_next_index)
 381     {
 382     case IP_LOOKUP_NEXT_ARP:
 383       switch (bs->transport)
 384         {
 385         case BFD_TRANSPORT_UDP4:
 386           *next_node = bfd_udp_main.ip4_arp_idx;
 387           return 1;
 388         case BFD_TRANSPORT_UDP6:
 389           *next_node = bfd_udp_main.ip6_ndp_idx;
 390           return 1;
 391         }
 392       break;
 393     case IP_LOOKUP_NEXT_REWRITE:
 394       switch (bs->transport)
 395         {
 396         case BFD_TRANSPORT_UDP4:
 397           *next_node = bfd_udp_main.ip4_rewrite_idx;
 398           return 1;
 399         case BFD_TRANSPORT_UDP6:
 400           *next_node = bfd_udp_main.ip6_rewrite_idx;
 401           return 1;
 402         }
 403       break;
 404     default:
 405       /* drop */
 406       break;
 407     }
 408   return 0;
 409 }
 410
 411 int
 412 bfd_transport_udp4 (vlib_main_t * vm, u32 bi, const struct bfd_session_s *bs)
 413 {
 414   u32 next_node;
 415   int rv = bfd_udp_calc_next_node (bs, &next_node);
 416   if (rv)
 417     {
 418       bfd_create_frame_to_next_node (vm, bi, next_node);
 419     }
 420   return rv;
 421 }
 422
 423 int
 424 bfd_transport_udp6 (vlib_main_t * vm, u32 bi, const struct bfd_session_s *bs)
 425 {
 426   u32 next_node;
 427   int rv = bfd_udp_calc_next_node (bs, &next_node);
 428   if (rv)
 429     {
 430       bfd_create_frame_to_next_node (vm, bi, next_node);
 431     }
 432   return 1;
 433 }
 434
 435 static bfd_session_t *
 436 bfd_lookup_session (bfd_udp_main_t * bum, const bfd_udp_key_t * key)
 437 {
 438   uword *p = mhash_get (&bum->bfd_session_idx_by_bfd_key, key);
 439   if (p)
 440     {
 441       return bfd_find_session_by_idx (bum->bfd_main, *p);
 442     }
 443   return 0;
 444 }
 445
 446 static void
 447 bfd_udp_key_init (bfd_udp_key_t * key, u32 sw_if_index,
 448                   const ip46_address_t * local_addr,
 449                   const ip46_address_t * peer_addr)
 450 {
 451   memset (key, 0, sizeof (*key));
 452   key->sw_if_index = sw_if_index;
 453   key->local_addr.as_u64[0] = local_addr->as_u64[0];
 454   key->local_addr.as_u64[1] = local_addr->as_u64[1];
 455   key->peer_addr.as_u64[0] = peer_addr->as_u64[0];
 456   key->peer_addr.as_u64[1] = peer_addr->as_u64[1];
 457 }
 458
 459 static vnet_api_error_t
 460 bfd_udp_add_session_internal (bfd_udp_main_t * bum, u32 sw_if_index,
 461                               u32 desired_min_tx_usec,
 462                               u32 required_min_rx_usec, u8 detect_mult,
 463                               const ip46_address_t * local_addr,
 464                               const ip46_address_t * peer_addr,
 465                               bfd_session_t ** bs_out)
 466 {
 467   /* get a pool entry and if we end up not needing it, give it back */
 468   bfd_transport_e t = BFD_TRANSPORT_UDP4;
 469   if (!ip46_address_is_ip4 (local_addr))
 470     {
 471       t = BFD_TRANSPORT_UDP6;
 472     }
 473   bfd_session_t *bs = bfd_get_session (bum->bfd_main, t);
 474   if (!bs)
 475     {
 476       return VNET_API_ERROR_BFD_EAGAIN;
 477     }
 478   bfd_udp_session_t *bus = &bs->udp;
 479   memset (bus, 0, sizeof (*bus));
 480   bfd_udp_key_t *key = &bus->key;
 481   bfd_udp_key_init (key, sw_if_index, local_addr, peer_addr);
 482   const bfd_session_t *tmp = bfd_lookup_session (bum, key);
 483   if (tmp)
 484     {
 485       vlib_log_err (bum->log_class,
 486                     "duplicate bfd-udp session, existing bs_idx=%d",
 487                     tmp->bs_idx);
 488       bfd_put_session (bum->bfd_main, bs);
 489       return VNET_API_ERROR_BFD_EEXIST;
 490     }
 491   mhash_set (&bum->bfd_session_idx_by_bfd_key, key, bs->bs_idx, NULL);
 492   BFD_DBG ("session created, bs_idx=%u, sw_if_index=%d, local=%U, peer=%U",
 493            bs->bs_idx, key->sw_if_index, format_ip46_address,
 494            &key->local_addr, IP46_TYPE_ANY, format_ip46_address,
 495            &key->peer_addr, IP46_TYPE_ANY);
 496   vlib_log_info (bum->log_class, "create BFD session: %U",
 497                  format_bfd_session, bs);
 498   if (BFD_TRANSPORT_UDP4 == t)
 499     {
 500       bus->adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4, VNET_LINK_IP4,
 501                                             &key->peer_addr,
 502                                             key->sw_if_index);
 503       BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, VNET_LINK_IP4, %U, %d) "
 504                "returns %d", format_ip46_address, &key->peer_addr,
 505                IP46_TYPE_ANY, key->sw_if_index, bus->adj_index);
 506     }
 507   else
 508     {
 509       bus->adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP6, VNET_LINK_IP6,
 510                                             &key->peer_addr,
 511                                             key->sw_if_index);
 512       BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP6, VNET_LINK_IP6, %U, %d) "
 513                "returns %d", format_ip46_address, &key->peer_addr,
 514                IP46_TYPE_ANY, key->sw_if_index, bus->adj_index);
 515     }
 516   *bs_out = bs;
 517   return bfd_session_set_params (bum->bfd_main, bs, desired_min_tx_usec,
 518                                  required_min_rx_usec, detect_mult);
 519 }
 520
 521 static vnet_api_error_t
 522 bfd_udp_validate_api_input (u32 sw_if_index,
 523                             const ip46_address_t * local_addr,
 524                             const ip46_address_t * peer_addr)
 525 {
 526   bfd_udp_main_t *bum = &bfd_udp_main;
 527   vnet_sw_interface_t *sw_if =
 528     vnet_get_sw_interface_safe (bfd_udp_main.vnet_main, sw_if_index);
 529   u8 local_ip_valid = 0;
 530   ip_interface_address_t *ia = NULL;
 531   if (!sw_if)
 532     {
 533       vlib_log_err (bum->log_class,
 534                     "got NULL sw_if when getting interface by index %u",
 535                     sw_if_index);
 536       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 537     }
 538   if (ip46_address_is_ip4 (local_addr))
 539     {
 540       if (!ip46_address_is_ip4 (peer_addr))
 541         {
 542           vlib_log_err (bum->log_class,
 543                         "IP family mismatch (local is ipv4, peer is ipv6)");
 544           return VNET_API_ERROR_INVALID_ARGUMENT;
 545         }
 546       ip4_main_t *im = &ip4_main;
 547
 548       /* *INDENT-OFF* */
 549       foreach_ip_interface_address (
 550           &im->lookup_main, ia, sw_if_index, 0 /* honor unnumbered */, ({
 551             ip4_address_t *x =
 552                 ip_interface_address_get_address (&im->lookup_main, ia);
 553             if (x->as_u32 == local_addr->ip4.as_u32)
 554               {
 555                 /* valid address for this interface */
 556                 local_ip_valid = 1;
 557                 break;
 558               }
 559           }));
 560       /* *INDENT-ON* */
 561     }
 562   else
 563     {
 564       if (ip46_address_is_ip4 (peer_addr))
 565         {
 566           vlib_log_err (bum->log_class,
 567                         "IP family mismatch (local is ipv6, peer is ipv4)");
 568           return VNET_API_ERROR_INVALID_ARGUMENT;
 569         }
 570       ip6_main_t *im = &ip6_main;
 571       /* *INDENT-OFF* */
 572       foreach_ip_interface_address (
 573           &im->lookup_main, ia, sw_if_index, 0 /* honor unnumbered */, ({
 574             ip6_address_t *x =
 575                 ip_interface_address_get_address (&im->lookup_main, ia);
 576             if (local_addr->ip6.as_u64[0] == x->as_u64[0] &&
 577                 local_addr->ip6.as_u64[1] == x->as_u64[1])
 578               {
 579                 /* valid address for this interface */
 580                 local_ip_valid = 1;
 581                 break;
 582               }
 583           }));
 584       /* *INDENT-ON* */
 585     }
 586
 587   if (!local_ip_valid)
 588     {
 589       vlib_log_err (bum->log_class,
 590                     "local address %U not found on interface with index %u",
 591                     format_ip46_address, local_addr, IP46_TYPE_ANY,
 592                     sw_if_index);
 593       return VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
 594     }
 595
 596   return 0;
 597 }
 598
 599 static vnet_api_error_t
 600 bfd_udp_find_session_by_api_input (u32 sw_if_index,
 601                                    const ip46_address_t * local_addr,
 602                                    const ip46_address_t * peer_addr,
 603                                    bfd_session_t ** bs_out)
 604 {
 605   vnet_api_error_t rv =
 606     bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr);
 607   if (!rv)
 608     {
 609       bfd_udp_main_t *bum = &bfd_udp_main;
 610       bfd_udp_key_t key;
 611       bfd_udp_key_init (&key, sw_if_index, local_addr, peer_addr);
 612       bfd_session_t *bs = bfd_lookup_session (bum, &key);
 613       if (bs)
 614         {
 615           *bs_out = bs;
 616         }
 617       else
 618         {
 619           vlib_log_err (bum->log_class,
 620                         "BFD session not found, sw_if_index=%u, local=%U, peer=%U",
 621                         sw_if_index, format_ip46_address, local_addr,
 622                         IP46_TYPE_ANY, format_ip46_address, peer_addr,
 623                         IP46_TYPE_ANY);
 624           return VNET_API_ERROR_BFD_ENOENT;
 625         }
 626     }
 627   return rv;
 628 }
 629
 630 static vnet_api_error_t
 631 bfd_api_verify_common (u32 sw_if_index, u32 desired_min_tx_usec,
 632                        u32 required_min_rx_usec, u8 detect_mult,
 633                        const ip46_address_t * local_addr,
 634                        const ip46_address_t * peer_addr)
 635 {
 636   bfd_udp_main_t *bum = &bfd_udp_main;
 637   vnet_api_error_t rv =
 638     bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr);
 639   if (rv)
 640     {
 641       return rv;
 642     }
 643   if (detect_mult < 1)
 644     {
 645       vlib_log_err (bum->log_class, "detect_mult < 1");
 646       return VNET_API_ERROR_INVALID_ARGUMENT;
 647     }
 648   if (desired_min_tx_usec < 1)
 649     {
 650       vlib_log_err (bum->log_class, "desired_min_tx_usec < 1");
 651       return VNET_API_ERROR_INVALID_ARGUMENT;
 652     }
 653   return 0;
 654 }
 655
 656 static void
 657 bfd_udp_del_session_internal (bfd_session_t * bs)
 658 {
 659   bfd_udp_main_t *bum = &bfd_udp_main;
 660   BFD_DBG ("free bfd-udp session, bs_idx=%d", bs->bs_idx);
 661   mhash_unset (&bum->bfd_session_idx_by_bfd_key, &bs->udp.key, NULL);
 662   adj_unlock (bs->udp.adj_index);
 663   bfd_put_session (bum->bfd_main, bs);
 664 }
 665
 666 vnet_api_error_t
 667 bfd_udp_add_session (u32 sw_if_index, const ip46_address_t * local_addr,
 668                      const ip46_address_t * peer_addr,
 669                      u32 desired_min_tx_usec, u32 required_min_rx_usec,
 670                      u8 detect_mult, u8 is_authenticated, u32 conf_key_id,
 671                      u8 bfd_key_id)
 672 {
 673   bfd_main_t *bm = &bfd_main;
 674   bfd_lock (bm);
 675
 676   vnet_api_error_t rv =
 677     bfd_api_verify_common (sw_if_index, desired_min_tx_usec,
 678                            required_min_rx_usec, detect_mult,
 679                            local_addr, peer_addr);
 680   bfd_session_t *bs = NULL;
 681   if (!rv)
 682     {
 683       rv =
 684         bfd_udp_add_session_internal (&bfd_udp_main, sw_if_index,
 685                                       desired_min_tx_usec,
 686                                       required_min_rx_usec, detect_mult,
 687                                       local_addr, peer_addr, &bs);
 688     }
 689   if (!rv && is_authenticated)
 690     {
 691 #if WITH_LIBSSL > 0
 692       rv = bfd_auth_activate (bs, conf_key_id, bfd_key_id,
 693                               0 /* is not delayed */ );
 694 #else
 695       vlib_log_err (bfd_udp_main.log_class,
 696                     "SSL missing, cannot add authenticated BFD session");
 697       rv = VNET_API_ERROR_BFD_NOTSUPP;
 698 #endif
 699       if (rv)
 700         {
 701           bfd_udp_del_session_internal (bs);
 702         }
 703     }
 704   if (!rv)
 705     {
 706       bfd_session_start (bfd_udp_main.bfd_main, bs);
 707     }
 708
 709   bfd_unlock (bm);
 710   return rv;
 711 }
 712
 713 vnet_api_error_t
 714 bfd_udp_mod_session (u32 sw_if_index,
 715                      const ip46_address_t * local_addr,
 716                      const ip46_address_t * peer_addr,
 717                      u32 desired_min_tx_usec,
 718                      u32 required_min_rx_usec, u8 detect_mult)
 719 {
 720   bfd_session_t *bs = NULL;
 721   bfd_main_t *bm = &bfd_main;
 722   vnet_api_error_t error;
 723   bfd_lock (bm);
 724   vnet_api_error_t rv =
 725     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
 726                                        &bs);
 727   if (rv)
 728     {
 729       bfd_unlock (bm);
 730       return rv;
 731     }
 732
 733   error = bfd_session_set_params (bfd_udp_main.bfd_main, bs,
 734                                   desired_min_tx_usec, required_min_rx_usec,
 735                                   detect_mult);
 736   bfd_unlock (bm);
 737   return error;
 738 }
 739
 740 vnet_api_error_t
 741 bfd_udp_del_session (u32 sw_if_index,
 742                      const ip46_address_t * local_addr,
 743                      const ip46_address_t * peer_addr)
 744 {
 745   bfd_session_t *bs = NULL;
 746   bfd_main_t *bm = &bfd_main;
 747   bfd_lock (bm);
 748   vnet_api_error_t rv =
 749     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
 750                                        &bs);
 751   if (rv)
 752     {
 753       bfd_unlock (bm);
 754       return rv;
 755     }
 756   bfd_udp_del_session_internal (bs);
 757   bfd_unlock (bm);
 758   return 0;
 759 }
 760
 761 vnet_api_error_t
 762 bfd_udp_session_set_flags (u32 sw_if_index,
 763                            const ip46_address_t * local_addr,
 764                            const ip46_address_t * peer_addr, u8 admin_up_down)
 765 {
 766   bfd_session_t *bs = NULL;
 767   bfd_main_t *bm = &bfd_main;
 768   bfd_lock (bm);
 769   vnet_api_error_t rv =
 770     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
 771                                        &bs);
 772   if (rv)
 773     {
 774       bfd_unlock (bm);
 775       return rv;
 776     }
 777   bfd_session_set_flags (bs, admin_up_down);
 778   bfd_unlock (bm);
 779   return 0;
 780 }
 781
 782 vnet_api_error_t
 783 bfd_udp_auth_activate (u32 sw_if_index,
 784                        const ip46_address_t * local_addr,
 785                        const ip46_address_t * peer_addr,
 786                        u32 conf_key_id, u8 key_id, u8 is_delayed)
 787 {
 788   bfd_main_t *bm = &bfd_main;
 789   bfd_lock (bm);
 790   vnet_api_error_t error;
 791
 792 #if WITH_LIBSSL > 0
 793   bfd_session_t *bs = NULL;
 794   vnet_api_error_t rv =
 795     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
 796                                        &bs);
 797   if (rv)
 798     {
 799       bfd_unlock (bm);
 800       return rv;
 801     }
 802   error = bfd_auth_activate (bs, conf_key_id, key_id, is_delayed);
 803   bfd_unlock (bm);
 804   return error;
 805 #else
 806   vlib_log_err (bfd_udp_main->log_class,
 807                 "SSL missing, cannot activate BFD authentication");
 808   bfd_unlock (bm);
 809   return VNET_API_ERROR_BFD_NOTSUPP;
 810 #endif
 811 }
 812
 813 vnet_api_error_t
 814 bfd_udp_auth_deactivate (u32 sw_if_index,
 815                          const ip46_address_t * local_addr,
 816                          const ip46_address_t * peer_addr, u8 is_delayed)
 817 {
 818   bfd_main_t *bm = &bfd_main;
 819   vnet_api_error_t error;
 820   bfd_lock (bm);
 821   bfd_session_t *bs = NULL;
 822   vnet_api_error_t rv =
 823     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
 824                                        &bs);
 825   if (rv)
 826     {
 827       bfd_unlock (bm);
 828       return rv;
 829     }
 830   error = bfd_auth_deactivate (bs, is_delayed);
 831   bfd_unlock (bm);
 832   return error;
 833 }
 834
 835 typedef enum
 836 {
 837   BFD_UDP_INPUT_NEXT_NORMAL,
 838   BFD_UDP_INPUT_NEXT_REPLY_ARP,
 839   BFD_UDP_INPUT_NEXT_REPLY_REWRITE,
 840   BFD_UDP_INPUT_N_NEXT,
 841 } bfd_udp_input_next_t;
 842
 843 /* Packet counters - BFD control frames */
 844 #define foreach_bfd_udp_error(F)           \
 845   F (NONE, "good bfd packets (processed)") \
 846   F (BAD, "invalid bfd packets")
 847
 848 #define F(sym, string) static char BFD_UDP_ERR_##sym##_STR[] = string;
 849 foreach_bfd_udp_error (F);
 850 #undef F
 851
 852 static char *bfd_udp_error_strings[] = {
 853 #define F(sym, string) BFD_UDP_ERR_##sym##_STR,
 854   foreach_bfd_udp_error (F)
 855 #undef F
 856 };
 857
 858 typedef enum
 859 {
 860 #define F(sym, str) BFD_UDP_ERROR_##sym,
 861   foreach_bfd_udp_error (F)
 862 #undef F
 863     BFD_UDP_N_ERROR,
 864 } bfd_udp_error_t;
 865
 866 /* Packet counters - BFD ECHO packets */
 867 #define foreach_bfd_udp_echo_error(F)           \
 868   F (NONE, "good bfd echo packets (processed)") \
 869   F (BAD, "invalid bfd echo packets")
 870
 871 #define F(sym, string) static char BFD_UDP_ECHO_ERR_##sym##_STR[] = string;
 872 foreach_bfd_udp_echo_error (F);
 873 #undef F
 874
 875 static char *bfd_udp_echo_error_strings[] = {
 876 #define F(sym, string) BFD_UDP_ECHO_ERR_##sym##_STR,
 877   foreach_bfd_udp_echo_error (F)
 878 #undef F
 879 };
 880
 881 typedef enum
 882 {
 883 #define F(sym, str) BFD_UDP_ECHO_ERROR_##sym,
 884   foreach_bfd_udp_echo_error (F)
 885 #undef F
 886     BFD_UDP_ECHO_N_ERROR,
 887 } bfd_udp_echo_error_t;
 888
 889 static void
 890 bfd_udp4_find_headers (vlib_buffer_t * b, ip4_header_t ** ip4,
 891                        udp_header_t ** udp)
 892 {
 893   /* sanity check first */
 894   const i32 start = vnet_buffer (b)->l3_hdr_offset;
 895   if (start < 0 && start < sizeof (b->pre_data))
 896     {
 897       BFD_ERR ("Start of ip header is before pre_data, ignoring");
 898       *ip4 = NULL;
 899       *udp = NULL;
 900       return;
 901     }
 902   *ip4 = (ip4_header_t *) (b->data + start);
 903   if ((u8 *) * ip4 > (u8 *) vlib_buffer_get_current (b))
 904     {
 905       BFD_ERR ("Start of ip header is beyond current data, ignoring");
 906       *ip4 = NULL;
 907       *udp = NULL;
 908       return;
 909     }
 910   *udp = (udp_header_t *) ((*ip4) + 1);
 911 }
 912
 913 static bfd_udp_error_t
 914 bfd_udp4_verify_transport (const ip4_header_t * ip4,
 915                            const udp_header_t * udp, const bfd_session_t * bs)
 916 {
 917   const bfd_udp_session_t *bus = &bs->udp;
 918   const bfd_udp_key_t *key = &bus->key;
 919   if (ip4->src_address.as_u32 != key->peer_addr.ip4.as_u32)
 920     {
 921       BFD_ERR ("IPv4 src addr mismatch, got %U, expected %U",
 922                format_ip4_address, ip4->src_address.as_u8, format_ip4_address,
 923                key->peer_addr.ip4.as_u8);
 924       return BFD_UDP_ERROR_BAD;
 925     }
 926   if (ip4->dst_address.as_u32 != key->local_addr.ip4.as_u32)
 927     {
 928       BFD_ERR ("IPv4 dst addr mismatch, got %U, expected %U",
 929                format_ip4_address, ip4->dst_address.as_u8, format_ip4_address,
 930                key->local_addr.ip4.as_u8);
 931       return BFD_UDP_ERROR_BAD;
 932     }
 933   const u8 expected_ttl = 255;
 934   if (ip4->ttl != expected_ttl)
 935     {
 936       BFD_ERR ("IPv4 unexpected TTL value %u, expected %u", ip4->ttl,
 937                expected_ttl);
 938       return BFD_UDP_ERROR_BAD;
 939     }
 940   if (clib_net_to_host_u16 (udp->src_port) < 49152)
 941     {
 942       BFD_ERR ("Invalid UDP src port %u, out of range <49152,65535>",
 943                udp->src_port);
 944     }
 945   return BFD_UDP_ERROR_NONE;
 946 }
 947
 948 typedef struct
 949 {
 950   u32 bs_idx;
 951   bfd_pkt_t pkt;
 952 } bfd_rpc_update_t;
 953
 954 static void
 955 bfd_rpc_update_session (u32 bs_idx, const bfd_pkt_t * pkt)
 956 {
 957   bfd_main_t *bm = &bfd_main;
 958   bfd_lock (bm);
 959   bfd_consume_pkt (bm, pkt, bs_idx);
 960   bfd_unlock (bm);
 961 }
 962
 963 static bfd_udp_error_t
 964 bfd_udp4_scan (vlib_main_t * vm, vlib_node_runtime_t * rt,
 965                vlib_buffer_t * b, bfd_session_t ** bs_out)
 966 {
 967   const bfd_pkt_t *pkt = vlib_buffer_get_current (b);
 968   if (sizeof (*pkt) > b->current_length)
 969     {
 970       BFD_ERR
 971         ("Payload size %d too small to hold bfd packet of minimum size %d",
 972          b->current_length, sizeof (*pkt));
 973       return BFD_UDP_ERROR_BAD;
 974     }
 975   ip4_header_t *ip4;
 976   udp_header_t *udp;
 977   bfd_udp4_find_headers (b, &ip4, &udp);
 978   if (!ip4 || !udp)
 979     {
 980       BFD_ERR ("Couldn't find ip4 or udp header");
 981       return BFD_UDP_ERROR_BAD;
 982     }
 983   const u32 udp_payload_length = udp->length - sizeof (*udp);
 984   if (pkt->head.length > udp_payload_length)
 985     {
 986       BFD_ERR
 987         ("BFD packet length is larger than udp payload length (%u > %u)",
 988          pkt->head.length, udp_payload_length);
 989       return BFD_UDP_ERROR_BAD;
 990     }
 991   if (!bfd_verify_pkt_common (pkt))
 992     {
 993       return BFD_UDP_ERROR_BAD;
 994     }
 995   bfd_session_t *bs = NULL;
 996   if (pkt->your_disc)
 997     {
 998       BFD_DBG ("Looking up BFD session using discriminator %u",
 999                pkt->your_disc);
1000       bs = bfd_find_session_by_disc (bfd_udp_main.bfd_main, pkt->your_disc);
1001     }
1002   else
1003     {
1004       bfd_udp_key_t key;
1005       memset (&key, 0, sizeof (key));
1006       key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
1007       key.local_addr.ip4.as_u32 = ip4->dst_address.as_u32;
1008       key.peer_addr.ip4.as_u32 = ip4->src_address.as_u32;
1009       BFD_DBG ("Looking up BFD session using key (sw_if_index=%u, local=%U, "
1010                "peer=%U)",
1011                key.sw_if_index, format_ip4_address, key.local_addr.ip4.as_u8,
1012                format_ip4_address, key.peer_addr.ip4.as_u8);
1013       bs = bfd_lookup_session (&bfd_udp_main, &key);
1014     }
1015   if (!bs)
1016     {
1017       BFD_ERR ("BFD session lookup failed - no session matches BFD pkt");
1018       return BFD_UDP_ERROR_BAD;
1019     }
1020   BFD_DBG ("BFD session found, bs_idx=%u", bs->bs_idx);
1021   if (!bfd_verify_pkt_auth (pkt, b->current_length, bs))
1022     {
1023       BFD_ERR ("Packet verification failed, dropping packet");
1024       return BFD_UDP_ERROR_BAD;
1025     }
1026   bfd_udp_error_t err;
1027   if (BFD_UDP_ERROR_NONE != (err = bfd_udp4_verify_transport (ip4, udp, bs)))
1028     {
1029       return err;
1030     }
1031   bfd_rpc_update_session (bs->bs_idx, pkt);
1032   *bs_out = bs;
1033   return BFD_UDP_ERROR_NONE;
1034 }
1035
1036 static void
1037 bfd_udp6_find_headers (vlib_buffer_t * b, ip6_header_t ** ip6,
1038                        udp_header_t ** udp)
1039 {
1040   /* sanity check first */
1041   const i32 start = vnet_buffer (b)->l3_hdr_offset;
1042   if (start < 0 && start < sizeof (b->pre_data))
1043     {
1044       BFD_ERR ("Start of ip header is before pre_data, ignoring");
1045       *ip6 = NULL;
1046       *udp = NULL;
1047       return;
1048     }
1049   *ip6 = (ip6_header_t *) (b->data + start);
1050   if ((u8 *) * ip6 > (u8 *) vlib_buffer_get_current (b))
1051     {
1052       BFD_ERR ("Start of ip header is beyond current data, ignoring");
1053       *ip6 = NULL;
1054       *udp = NULL;
1055       return;
1056     }
1057   if ((*ip6)->protocol != IP_PROTOCOL_UDP)
1058     {
1059       BFD_ERR ("Unexpected protocol in IPv6 header '%u', expected '%u' (== "
1060                "IP_PROTOCOL_UDP)", (*ip6)->protocol, IP_PROTOCOL_UDP);
1061       *ip6 = NULL;
1062       *udp = NULL;
1063       return;
1064     }
1065   *udp = (udp_header_t *) ((*ip6) + 1);
1066 }
1067
1068 static bfd_udp_error_t
1069 bfd_udp6_verify_transport (const ip6_header_t * ip6,
1070                            const udp_header_t * udp, const bfd_session_t * bs)
1071 {
1072   const bfd_udp_session_t *bus = &bs->udp;
1073   const bfd_udp_key_t *key = &bus->key;
1074   if (ip6->src_address.as_u64[0] != key->peer_addr.ip6.as_u64[0] &&
1075       ip6->src_address.as_u64[1] != key->peer_addr.ip6.as_u64[1])
1076     {
1077       BFD_ERR ("IP src addr mismatch, got %U, expected %U",
1078                format_ip6_address, ip6, format_ip6_address,
1079                &key->peer_addr.ip6);
1080       return BFD_UDP_ERROR_BAD;
1081     }
1082   if (ip6->dst_address.as_u64[0] != key->local_addr.ip6.as_u64[0] &&
1083       ip6->dst_address.as_u64[1] != key->local_addr.ip6.as_u64[1])
1084     {
1085       BFD_ERR ("IP dst addr mismatch, got %U, expected %U",
1086                format_ip6_address, ip6, format_ip6_address,
1087                &key->local_addr.ip6);
1088       return BFD_UDP_ERROR_BAD;
1089     }
1090   const u8 expected_hop_limit = 255;
1091   if (ip6->hop_limit != expected_hop_limit)
1092     {
1093       BFD_ERR ("IPv6 unexpected hop-limit value %u, expected %u",
1094                ip6->hop_limit, expected_hop_limit);
1095       return BFD_UDP_ERROR_BAD;
1096     }
1097   if (clib_net_to_host_u16 (udp->src_port) < 49152)
1098     {
1099       BFD_ERR ("Invalid UDP src port %u, out of range <49152,65535>",
1100                udp->src_port);
1101     }
1102   return BFD_UDP_ERROR_NONE;
1103 }
1104
1105 static bfd_udp_error_t
1106 bfd_udp6_scan (vlib_main_t * vm, vlib_node_runtime_t * rt,
1107                vlib_buffer_t * b, bfd_session_t ** bs_out)
1108 {
1109   const bfd_pkt_t *pkt = vlib_buffer_get_current (b);
1110   if (sizeof (*pkt) > b->current_length)
1111     {
1112       BFD_ERR
1113         ("Payload size %d too small to hold bfd packet of minimum size %d",
1114          b->current_length, sizeof (*pkt));
1115       return BFD_UDP_ERROR_BAD;
1116     }
1117   ip6_header_t *ip6;
1118   udp_header_t *udp;
1119   bfd_udp6_find_headers (b, &ip6, &udp);
1120   if (!ip6 || !udp)
1121     {
1122       BFD_ERR ("Couldn't find ip6 or udp header");
1123       return BFD_UDP_ERROR_BAD;
1124     }
1125   const u32 udp_payload_length = udp->length - sizeof (*udp);
1126   if (pkt->head.length > udp_payload_length)
1127     {
1128       BFD_ERR
1129         ("BFD packet length is larger than udp payload length (%u > %u)",
1130          pkt->head.length, udp_payload_length);
1131       return BFD_UDP_ERROR_BAD;
1132     }
1133   if (!bfd_verify_pkt_common (pkt))
1134     {
1135       return BFD_UDP_ERROR_BAD;
1136     }
1137   bfd_session_t *bs = NULL;
1138   if (pkt->your_disc)
1139     {
1140       BFD_DBG ("Looking up BFD session using discriminator %u",
1141                pkt->your_disc);
1142       bs = bfd_find_session_by_disc (bfd_udp_main.bfd_main, pkt->your_disc);
1143     }
1144   else
1145     {
1146       bfd_udp_key_t key;
1147       memset (&key, 0, sizeof (key));
1148       key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
1149       key.local_addr.ip6.as_u64[0] = ip6->dst_address.as_u64[0];
1150       key.local_addr.ip6.as_u64[1] = ip6->dst_address.as_u64[1];
1151       key.peer_addr.ip6.as_u64[0] = ip6->src_address.as_u64[0];
1152       key.peer_addr.ip6.as_u64[1] = ip6->src_address.as_u64[1];
1153       BFD_DBG ("Looking up BFD session using key (sw_if_index=%u, local=%U, "
1154                "peer=%U)",
1155                key.sw_if_index, format_ip6_address, &key.local_addr,
1156                format_ip6_address, &key.peer_addr);
1157       bs = bfd_lookup_session (&bfd_udp_main, &key);
1158     }
1159   if (!bs)
1160     {
1161       BFD_ERR ("BFD session lookup failed - no session matches BFD pkt");
1162       return BFD_UDP_ERROR_BAD;
1163     }
1164   BFD_DBG ("BFD session found, bs_idx=%u", bs->bs_idx);
1165   if (!bfd_verify_pkt_auth (pkt, b->current_length, bs))
1166     {
1167       BFD_ERR ("Packet verification failed, dropping packet");
1168       return BFD_UDP_ERROR_BAD;
1169     }
1170   bfd_udp_error_t err;
1171   if (BFD_UDP_ERROR_NONE != (err = bfd_udp6_verify_transport (ip6, udp, bs)))
1172     {
1173       return err;
1174     }
1175   bfd_rpc_update_session (bs->bs_idx, pkt);
1176   *bs_out = bs;
1177   return BFD_UDP_ERROR_NONE;
1178 }
1179
1180 /*
1181  * Process a frame of bfd packets
1182  * Expect 1 packet / frame
1183  */
1184 static uword
1185 bfd_udp_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
1186                vlib_frame_t * f, int is_ipv6)
1187 {
1188   u32 n_left_from, *from;
1189   bfd_input_trace_t *t0;
1190   bfd_main_t *bm = &bfd_main;
1191
1192   from = vlib_frame_vector_args (f);    /* array of buffer indices */
1193   n_left_from = f->n_vectors;   /* number of buffer indices */
1194
1195   while (n_left_from > 0)
1196     {
1197       u32 bi0;
1198       vlib_buffer_t *b0;
1199       u32 next0, error0;
1200
1201       bi0 = from[0];
1202       b0 = vlib_get_buffer (vm, bi0);
1203
1204       bfd_session_t *bs = NULL;
1205
1206       /* If this pkt is traced, snapshot the data */
1207       if (b0->flags & VLIB_BUFFER_IS_TRACED)
1208         {
1209           int len;
1210           t0 = vlib_add_trace (vm, rt, b0, sizeof (*t0));
1211           len = (b0->current_length < sizeof (t0->data)) ? b0->current_length
1212             : sizeof (t0->data);
1213           t0->len = len;
1214           clib_memcpy (t0->data, vlib_buffer_get_current (b0), len);
1215         }
1216
1217       /* scan this bfd pkt. error0 is the counter index to bmp */
1218       bfd_lock (bm);
1219       if (is_ipv6)
1220         {
1221           error0 = bfd_udp6_scan (vm, rt, b0, &bs);
1222         }
1223       else
1224         {
1225           error0 = bfd_udp4_scan (vm, rt, b0, &bs);
1226         }
1227       b0->error = rt->errors[error0];
1228
1229       next0 = BFD_UDP_INPUT_NEXT_NORMAL;
1230       if (BFD_UDP_ERROR_NONE == error0)
1231         {
1232           /*
1233            *  if everything went fine, check for poll bit, if present, re-use
1234            *  the buffer and based on (now updated) session parameters, send
1235            *  the final packet back
1236            */
1237           const bfd_pkt_t *pkt = vlib_buffer_get_current (b0);
1238           if (bfd_pkt_get_poll (pkt))
1239             {
1240               b0->current_data = 0;
1241               b0->current_length = 0;
1242               memset (vnet_buffer (b0), 0, sizeof (*vnet_buffer (b0)));
1243               bfd_init_final_control_frame (vm, b0, bfd_udp_main.bfd_main, bs,
1244                                             0);
1245               if (is_ipv6)
1246                 {
1247                   vlib_node_increment_counter (vm, bfd_udp6_input_node.index,
1248                                                b0->error, 1);
1249                 }
1250               else
1251                 {
1252                   vlib_node_increment_counter (vm, bfd_udp4_input_node.index,
1253                                                b0->error, 1);
1254                 }
1255               const bfd_udp_session_t *bus = &bs->udp;
1256               ip_adjacency_t *adj = adj_get (bus->adj_index);
1257               switch (adj->lookup_next_index)
1258                 {
1259                 case IP_LOOKUP_NEXT_ARP:
1260                   next0 = BFD_UDP_INPUT_NEXT_REPLY_ARP;
1261                   break;
1262                 case IP_LOOKUP_NEXT_REWRITE:
1263                   next0 = BFD_UDP_INPUT_NEXT_REPLY_REWRITE;
1264                   break;
1265                 default:
1266                   /* drop */
1267                   break;
1268                 }
1269             }
1270         }
1271       bfd_unlock (bm);
1272       vlib_set_next_frame_buffer (vm, rt, next0, bi0);
1273
1274       from += 1;
1275       n_left_from -= 1;
1276     }
1277
1278   return f->n_vectors;
1279 }
1280
1281 static uword
1282 bfd_udp4_input (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
1283 {
1284   return bfd_udp_input (vm, rt, f, 0);
1285 }
1286
1287 /*
1288  * bfd input graph node declaration
1289  */
1290 /* *INDENT-OFF* */
1291 VLIB_REGISTER_NODE (bfd_udp4_input_node, static) = {
1292   .function = bfd_udp4_input,
1293   .name = "bfd-udp4-input",
1294   .vector_size = sizeof (u32),
1295   .type = VLIB_NODE_TYPE_INTERNAL,
1296
1297   .n_errors = BFD_UDP_N_ERROR,
1298   .error_strings = bfd_udp_error_strings,
1299
1300   .format_trace = bfd_input_format_trace,
1301
1302   .n_next_nodes = BFD_UDP_INPUT_N_NEXT,
1303   .next_nodes =
1304       {
1305               [BFD_UDP_INPUT_NEXT_NORMAL] = "error-drop",
1306               [BFD_UDP_INPUT_NEXT_REPLY_ARP] = "ip4-arp",
1307               [BFD_UDP_INPUT_NEXT_REPLY_REWRITE] = "ip4-lookup",
1308       },
1309 };
1310 /* *INDENT-ON* */
1311
1312 static uword
1313 bfd_udp6_input (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
1314 {
1315   return bfd_udp_input (vm, rt, f, 1);
1316 }
1317
1318 /* *INDENT-OFF* */
1319 VLIB_REGISTER_NODE (bfd_udp6_input_node, static) = {
1320   .function = bfd_udp6_input,
1321   .name = "bfd-udp6-input",
1322   .vector_size = sizeof (u32),
1323   .type = VLIB_NODE_TYPE_INTERNAL,
1324
1325   .n_errors = BFD_UDP_N_ERROR,
1326   .error_strings = bfd_udp_error_strings,
1327
1328   .format_trace = bfd_input_format_trace,
1329
1330   .n_next_nodes = BFD_UDP_INPUT_N_NEXT,
1331   .next_nodes =
1332       {
1333               [BFD_UDP_INPUT_NEXT_NORMAL] = "error-drop",
1334               [BFD_UDP_INPUT_NEXT_REPLY_ARP] = "ip6-discover-neighbor",
1335               [BFD_UDP_INPUT_NEXT_REPLY_REWRITE] = "ip6-lookup",
1336       },
1337 };
1338 /* *INDENT-ON* */
1339
1340 /*
1341  * Process a frame of bfd echo packets
1342  * Expect 1 packet / frame
1343  */
1344 static uword
1345 bfd_udp_echo_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
1346                     vlib_frame_t * f, int is_ipv6)
1347 {
1348   u32 n_left_from, *from;
1349   bfd_input_trace_t *t0;
1350   bfd_main_t *bm = &bfd_main;
1351
1352   from = vlib_frame_vector_args (f);    /* array of buffer indices */
1353   n_left_from = f->n_vectors;   /* number of buffer indices */
1354
1355   while (n_left_from > 0)
1356     {
1357       u32 bi0;
1358       vlib_buffer_t *b0;
1359       u32 next0;
1360
1361       bi0 = from[0];
1362       b0 = vlib_get_buffer (vm, bi0);
1363
1364       /* If this pkt is traced, snapshot the data */
1365       if (b0->flags & VLIB_BUFFER_IS_TRACED)
1366         {
1367           int len;
1368           t0 = vlib_add_trace (vm, rt, b0, sizeof (*t0));
1369           len = (b0->current_length < sizeof (t0->data)) ? b0->current_length
1370             : sizeof (t0->data);
1371           t0->len = len;
1372           clib_memcpy (t0->data, vlib_buffer_get_current (b0), len);
1373         }
1374
1375       bfd_lock (bm);
1376       if (bfd_consume_echo_pkt (bfd_udp_main.bfd_main, b0))
1377         {
1378           b0->error = rt->errors[BFD_UDP_ERROR_NONE];
1379           next0 = BFD_UDP_INPUT_NEXT_NORMAL;
1380         }
1381       else
1382         {
1383           /* loop back the packet */
1384           b0->error = rt->errors[BFD_UDP_ERROR_NONE];
1385           if (is_ipv6)
1386             {
1387               vlib_node_increment_counter (vm, bfd_udp_echo6_input_node.index,
1388                                            b0->error, 1);
1389             }
1390           else
1391             {
1392               vlib_node_increment_counter (vm, bfd_udp_echo4_input_node.index,
1393                                            b0->error, 1);
1394             }
1395           next0 = BFD_UDP_INPUT_NEXT_REPLY_REWRITE;
1396         }
1397
1398       bfd_unlock (bm);
1399       vlib_set_next_frame_buffer (vm, rt, next0, bi0);
1400
1401       from += 1;
1402       n_left_from -= 1;
1403     }
1404
1405   return f->n_vectors;
1406 }
1407
1408 static uword
1409 bfd_udp_echo4_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
1410                      vlib_frame_t * f)
1411 {
1412   return bfd_udp_echo_input (vm, rt, f, 0);
1413 }
1414
1415 u8 *
1416 bfd_echo_input_format_trace (u8 * s, va_list * args)
1417 {
1418   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1419   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1420   const bfd_udp_echo_input_trace_t *t =
1421     va_arg (*args, bfd_udp_echo_input_trace_t *);
1422   if (t->len > STRUCT_SIZE_OF (bfd_pkt_t, head))
1423     {
1424       s = format (s, "BFD ECHO:\n");
1425       s = format (s, "    data: %U", format_hexdump, t->data, t->len);
1426     }
1427
1428   return s;
1429 }
1430
1431 /*
1432  * bfd input graph node declaration
1433  */
1434 /* *INDENT-OFF* */
1435 VLIB_REGISTER_NODE (bfd_udp_echo4_input_node, static) = {
1436   .function = bfd_udp_echo4_input,
1437   .name = "bfd-udp-echo4-input",
1438   .vector_size = sizeof (u32),
1439   .type = VLIB_NODE_TYPE_INTERNAL,
1440
1441   .n_errors = BFD_UDP_ECHO_N_ERROR,
1442   .error_strings = bfd_udp_error_strings,
1443
1444   .format_trace = bfd_echo_input_format_trace,
1445
1446   .n_next_nodes = BFD_UDP_INPUT_N_NEXT,
1447   .next_nodes =
1448       {
1449               [BFD_UDP_INPUT_NEXT_NORMAL] = "error-drop",
1450               [BFD_UDP_INPUT_NEXT_REPLY_ARP] = "ip4-arp",
1451               [BFD_UDP_INPUT_NEXT_REPLY_REWRITE] = "ip4-lookup",
1452       },
1453 };
1454 /* *INDENT-ON* */
1455
1456 static uword
1457 bfd_udp_echo6_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
1458                      vlib_frame_t * f)
1459 {
1460   return bfd_udp_echo_input (vm, rt, f, 1);
1461 }
1462
1463 /* *INDENT-OFF* */
1464 VLIB_REGISTER_NODE (bfd_udp_echo6_input_node, static) = {
1465   .function = bfd_udp_echo6_input,
1466   .name = "bfd-udp-echo6-input",
1467   .vector_size = sizeof (u32),
1468   .type = VLIB_NODE_TYPE_INTERNAL,
1469
1470   .n_errors = BFD_UDP_ECHO_N_ERROR,
1471   .error_strings = bfd_udp_echo_error_strings,
1472
1473   .format_trace = bfd_echo_input_format_trace,
1474
1475   .n_next_nodes = BFD_UDP_INPUT_N_NEXT,
1476   .next_nodes =
1477       {
1478               [BFD_UDP_INPUT_NEXT_NORMAL] = "error-drop",
1479               [BFD_UDP_INPUT_NEXT_REPLY_ARP] = "ip6-discover-neighbor",
1480               [BFD_UDP_INPUT_NEXT_REPLY_REWRITE] = "ip6-lookup",
1481       },
1482 };
1483
1484 /* *INDENT-ON* */
1485
1486 static clib_error_t *
1487 bfd_udp_sw_if_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_create)
1488 {
1489   bfd_session_t **to_be_freed = NULL;
1490   bfd_udp_main_t *bum = &bfd_udp_main;
1491   BFD_DBG ("sw_if_add_del called, sw_if_index=%u, is_create=%u", sw_if_index,
1492            is_create);
1493   if (!is_create)
1494     {
1495       bfd_session_t *bs;
1496       pool_foreach (bs, bfd_udp_main.bfd_main->sessions,
1497                     {
1498                     if (bs->transport != BFD_TRANSPORT_UDP4 &&
1499                         bs->transport != BFD_TRANSPORT_UDP6)
1500                     {
1501                     continue;}
1502                     if (bs->udp.key.sw_if_index != sw_if_index)
1503                     {
1504                     continue;}
1505                     vec_add1 (to_be_freed, bs);}
1506       );
1507     }
1508   bfd_session_t **bs;
1509   vec_foreach (bs, to_be_freed)
1510   {
1511     vlib_log_notice (bum->log_class,
1512                      "removal of sw_if_index=%u forces removal of bfd session "
1513                      "with bs_idx=%u", sw_if_index, (*bs)->bs_idx);
1514     bfd_session_set_flags (*bs, 0);
1515     bfd_udp_del_session_internal (*bs);
1516   }
1517   return 0;
1518 }
1519
1520 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (bfd_udp_sw_if_add_del);
1521
1522 /*
1523  * setup function
1524  */
1525 static clib_error_t *
1526 bfd_udp_init (vlib_main_t * vm)
1527 {
1528   mhash_init (&bfd_udp_main.bfd_session_idx_by_bfd_key, sizeof (uword),
1529               sizeof (bfd_udp_key_t));
1530   bfd_udp_main.bfd_main = &bfd_main;
1531   bfd_udp_main.vnet_main = vnet_get_main ();
1532   udp_register_dst_port (vm, UDP_DST_PORT_bfd4, bfd_udp4_input_node.index, 1);
1533   udp_register_dst_port (vm, UDP_DST_PORT_bfd6, bfd_udp6_input_node.index, 0);
1534   udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo4,
1535                          bfd_udp_echo4_input_node.index, 1);
1536   udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo6,
1537                          bfd_udp_echo6_input_node.index, 0);
1538   vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "ip4-arp");
1539   ASSERT (node);
1540   bfd_udp_main.ip4_arp_idx = node->index;
1541   node = vlib_get_node_by_name (vm, (u8 *) "ip6-discover-neighbor");
1542   ASSERT (node);
1543   bfd_udp_main.ip6_ndp_idx = node->index;
1544   node = vlib_get_node_by_name (vm, (u8 *) "ip4-rewrite");
1545   ASSERT (node);
1546   bfd_udp_main.ip4_rewrite_idx = node->index;
1547   node = vlib_get_node_by_name (vm, (u8 *) "ip6-rewrite");
1548   ASSERT (node);
1549   bfd_udp_main.ip6_rewrite_idx = node->index;
1550
1551   bfd_udp_main.log_class = vlib_log_register_class ("bfd", "udp");
1552   vlib_log_debug (bfd_udp_main.log_class, "initialized");
1553   return 0;
1554 }
1555
1556 VLIB_INIT_FUNCTION (bfd_udp_init);
1557
1558 /*
1559  * fd.io coding-style-patch-verification: ON
1560  *
1561  * Local Variables:
1562  * eval: (c-set-style "gnu")
1563  * End:
1564  */