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