bool is_delayed;
};
+/** \brief BFD UDP - enable multihop support
+ @param client_index - opaque cookie to identify the sender
+ @param context - sender context, to match reply w/ request
+*/
+autoreply define bfd_udp_enable_multihop
+{
+ u32 client_index;
+ u32 context;
+};
+
/* must be compatible with bfd_error_t */
counters bfd_udp {
none {
ip_address_decode(&mp->local_addr, &local_addr); \
ip_address_decode(&mp->peer_addr, &peer_addr);
-#define BFD_UDP_API_PARAM_FROM_MP(mp) \
- clib_net_to_host_u32 (mp->sw_if_index), &local_addr, &peer_addr
+#define BFD_UDP_API_PARAM_IS_MH(mp) \
+ bfd_main.multihop_enabled && (mp->sw_if_index == ~0)
+
+#define BFD_UDP_API_PARAM_FROM_MP(mp) \
+ BFD_UDP_API_PARAM_IS_MH (mp) ? true : false, \
+ BFD_UDP_API_PARAM_IS_MH (mp) ? ~0 : \
+ clib_net_to_host_u32 (mp->sw_if_index), \
+ &local_addr, &peer_addr
+
+#define COND_VALIDATE_SW_IF_INDEX(mp) \
+ do \
+ { \
+ if (!(bfd_main.multihop_enabled && mp->sw_if_index == ~0)) \
+ { \
+ VALIDATE_SW_IF_INDEX (mp) \
+ } \
+ } \
+ while (0);
static void
vl_api_bfd_udp_add_t_handler (vl_api_bfd_udp_add_t * mp)
vl_api_bfd_udp_add_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
vl_api_bfd_udp_upd_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
vl_api_bfd_udp_mod_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
vl_api_bfd_udp_del_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
mp->state = clib_host_to_net_u32 (bs->local_state);
bfd_udp_session_t *bus = &bs->udp;
bfd_udp_key_t *key = &bus->key;
- mp->sw_if_index = clib_host_to_net_u32 (key->sw_if_index);
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ mp->sw_if_index = ~0;
+ }
+ else
+ {
+ mp->sw_if_index = clib_host_to_net_u32 (key->sw_if_index);
+ }
if ((!bs->auth.is_delayed && bs->auth.curr_key) ||
(bs->auth.is_delayed && bs->auth.next_key))
{
mp->state = clib_host_to_net_u32 (bs->local_state);
bfd_udp_session_t *bus = &bs->udp;
bfd_udp_key_t *key = &bus->key;
- mp->sw_if_index = clib_host_to_net_u32 (key->sw_if_index);
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ mp->sw_if_index = ~0;
+ }
+ else
+ {
+ mp->sw_if_index = clib_host_to_net_u32 (key->sw_if_index);
+ }
if ((!bs->auth.is_delayed && bs->auth.curr_key) ||
(bs->auth.is_delayed && bs->auth.next_key))
{
vl_api_bfd_udp_auth_activate_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
vl_api_bfd_udp_auth_deactivate_reply_t *rmp;
int rv;
- VALIDATE_SW_IF_INDEX (mp);
+ COND_VALIDATE_SW_IF_INDEX (mp);
BFD_UDP_API_PARAM_COMMON_CODE;
}))
}
+static void
+vl_api_bfd_udp_enable_multihop_t_handler (vl_api_bfd_udp_enable_multihop_t *mp)
+{
+ vl_api_bfd_udp_enable_multihop_reply_t *rmp;
+ int rv = 0;
+
+ bfd_main.multihop_enabled = true;
+
+ REPLY_MACRO (VL_API_BFD_UDP_ENABLE_MULTIHOP_REPLY);
+}
+
#include <vnet/bfd/bfd.api.c>
static clib_error_t *
bfd_api_hookup (vlib_main_t * vm)
/**
* @brief create a new bfd session
*/
-vnet_api_error_t
-bfd_udp_add_session (u32 sw_if_index, const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- u32 desired_min_tx_usec, u32 required_min_rx_usec,
- u8 detect_mult, u8 is_authenticated, u32 conf_key_id,
- u8 bfd_key_id);
+vnet_api_error_t bfd_udp_add_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
+ u32 desired_min_tx_usec,
+ u32 required_min_rx_usec, u8 detect_mult,
+ u8 is_authenticated, u32 conf_key_id,
+ u8 bfd_key_id);
/**
- * @brief create a new or modify and existing bfd session
+ * @brief create a new or modify an existing bfd session
*/
-vnet_api_error_t
-bfd_udp_upd_session (u32 sw_if_index, const ip46_address_t *local_addr,
- const ip46_address_t *peer_addr, u32 desired_min_tx_usec,
- u32 required_min_rx_usec, u8 detect_mult,
- u8 is_authenticated, u32 conf_key_id, u8 bfd_key_id);
+vnet_api_error_t bfd_udp_upd_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
+ u32 desired_min_tx_usec,
+ u32 required_min_rx_usec, u8 detect_mult,
+ u8 is_authenticated, u32 conf_key_id,
+ u8 bfd_key_id);
/**
* @brief modify existing session
*/
-vnet_api_error_t
-bfd_udp_mod_session (u32 sw_if_index, const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- u32 desired_min_tx_usec, u32 required_min_rx_usec,
- u8 detect_mult);
+vnet_api_error_t bfd_udp_mod_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
+ u32 desired_min_tx_usec,
+ u32 required_min_rx_usec,
+ u8 detect_mult);
/**
* @brief delete existing session
*/
-vnet_api_error_t bfd_udp_del_session (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr);
+vnet_api_error_t bfd_udp_del_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr);
/**
* @brief set session admin down/up
*/
-vnet_api_error_t bfd_udp_session_set_flags (vlib_main_t * vm, u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
+vnet_api_error_t bfd_udp_session_set_flags (vlib_main_t *vm, bool multihop,
+ u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
u8 admin_up_down);
/**
/**
* @brief activate authentication for existing session
*/
-vnet_api_error_t bfd_udp_auth_activate (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
+vnet_api_error_t bfd_udp_auth_activate (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
u32 conf_key_id, u8 bfd_key_id,
u8 is_delayed);
/**
* @brief deactivate authentication for existing session
*/
-vnet_api_error_t bfd_udp_auth_deactivate (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
+vnet_api_error_t bfd_udp_auth_deactivate (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
u8 is_delayed);
/**
#include <vnet/bfd/bfd_api.h>
#include <vnet/bfd/bfd_main.h>
+#define BFD_MULTIHOP_CLI_CHECK \
+ do \
+ { \
+ multihop = have_multihop; \
+ if (multihop) \
+ { \
+ sw_if_index = ~0; \
+ } \
+ if (multihop && have_sw_if_index) \
+ { \
+ ret = clib_error_return ( \
+ 0, "Incompatible parameter combination, " \
+ "interface cannot be specified when multihop is enabled"); \
+ goto out; \
+ } \
+ if (!multihop && !have_sw_if_index) \
+ { \
+ ret = \
+ clib_error_return (0, "Incompatible parameter combination, " \
+ "interface must be set if not multihop"); \
+ goto out; \
+ } \
+ } \
+ while (0);
+
static u8 *
format_bfd_session_cli (u8 * s, va_list * args)
{
vlib_main_t *vm = va_arg (*args, vlib_main_t *);
bfd_session_t *bs = va_arg (*args, bfd_session_t *);
+ s = format (s, "%10s %-32s %20s\n", "", "Hop Type",
+ bfd_hop_type_string (bs->hop_type));
+
switch (bs->transport)
{
case BFD_TRANSPORT_UDP4:
bfd_diag_code_string (bs->remote_diag));
s = format (s, "%10s %-32s %20u %20u\n", "", "Detect multiplier",
bs->local_detect_mult, bs->remote_detect_mult);
+ s = format (s, "%10s %-32s %20llu\n", "", "Detection Time (usec)",
+ bfd_nsec_to_usec (bs->detection_time_nsec));
s = format (s, "%10s %-32s %20u %20llu\n", "",
"Required Min Rx Interval (usec)",
bs->config_required_min_rx_usec, bs->remote_min_rx_usec);
#define DETECT_MULT_STR "detect-mult"
#define ADMIN_STR "admin"
#define DELAYED_STR "delayed"
+#define MULTIHOP_STR "multihop"
static const unsigned mandatory = 1;
static const unsigned optional = 0;
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_add_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_add_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
if (1 == have_conf_key_id + have_bfd_key_id)
{
goto out;
}
- vnet_api_error_t rv =
- bfd_udp_add_session (sw_if_index, &local_addr, &peer_addr, desired_min_tx,
- required_min_rx,
- detect_mult, have_conf_key_id, conf_key_id,
- bfd_key_id);
+ vnet_api_error_t rv = bfd_udp_add_session (
+ multihop, sw_if_index, &local_addr, &peer_addr, desired_min_tx,
+ required_min_rx, detect_mult, have_conf_key_id, conf_key_id, bfd_key_id);
if (rv)
{
ret =
VLIB_CLI_COMMAND (bfd_cli_udp_session_add_command, static) = {
.path = "bfd udp session add",
.short_help = "bfd udp session add"
- " interface <interface>"
- " local-addr <local-address>"
-
" peer-addr <peer-address>"
- " desired-min-tx <desired min tx interval>"
- " required-min-rx <required min rx interval>"
- " detect-mult <detect multiplier> "
- "["
- " conf-key-id <config key ID>"
- " bfd-key-id <BFD key ID>"
- "]",
+ " <multihop | interface <interface>>"
+ " local-addr <local-address>"
+ " peer-addr <peer-address>"
+ " desired-min-tx <desired min tx interval>"
+ " required-min-rx <required min rx interval>"
+ " detect-mult <detect multiplier> "
+ "["
+ " conf-key-id <config key ID>"
+ " bfd-key-id <BFD key ID>"
+ "]",
.function = bfd_cli_udp_session_add,
};
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_mod_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_mod_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
if (detect_mult > 255)
{
}
vnet_api_error_t rv =
- bfd_udp_mod_session (sw_if_index, &local_addr, &peer_addr,
+ bfd_udp_mod_session (multihop, sw_if_index, &local_addr, &peer_addr,
desired_min_tx, required_min_rx, detect_mult);
if (rv)
{
VLIB_CLI_COMMAND (bfd_cli_udp_session_mod_command, static) = {
.path = "bfd udp session mod",
- .short_help = "bfd udp session mod interface"
- " <interface> local-addr"
- " <local-address> peer-addr"
-
" <peer-address> desired-min-tx"
- " <desired min tx interval> required-min-rx"
- " <required min rx interval> detect-mult"
- " <detect multiplier> ",
+ .short_help = "bfd udp session mod "
+ " <multihop | interface <interface>>"
+ " <local-address> peer-addr"
+ " <peer-address> desired-min-tx"
+ " <desired min tx interval> required-min-rx"
+ " <required min rx interval> detect-mult"
+ " <detect multiplier> ",
.function = bfd_cli_udp_session_mod,
};
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_del_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_del_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
vnet_api_error_t rv =
- bfd_udp_del_session (sw_if_index, &local_addr, &peer_addr);
+ bfd_udp_del_session (multihop, sw_if_index, &local_addr, &peer_addr);
if (rv)
{
ret =
VLIB_CLI_COMMAND (bfd_cli_udp_session_del_command, static) = {
.path = "bfd udp session del",
- .short_help = "bfd udp session del interface"
- " <interface> local-addr"
- " <local-address> peer-addr"
+ .short_help = "bfd udp session del <multihop |"
+ " interface <interface>> local-addr"
+ " <local-address> peer-addr"
+ "<peer-address> ",
.function = bfd_cli_udp_session_del,
};
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_set_flags_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_set_flags_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
u8 admin_up_down;
static const char up[] = "up";
ADMIN_STR, admin_up_down_token);
goto out;
}
- vnet_api_error_t rv =
- bfd_udp_session_set_flags (vm, sw_if_index, &local_addr,
- &peer_addr, admin_up_down);
+ vnet_api_error_t rv = bfd_udp_session_set_flags (
+ vm, multihop, sw_if_index, &local_addr, &peer_addr, admin_up_down);
if (rv)
{
ret =
VLIB_CLI_COMMAND (bfd_cli_udp_session_set_flags_command, static) = {
.path = "bfd udp session set-flags",
.short_help = "bfd udp session set-flags"
- " interface <interface>"
- " local-addr <local-address>"
-
" peer-addr <peer-address>"
- " admin <up|down>",
+ " <multihop | interface <interface>>"
+ " local-addr <local-address>"
+ " peer-addr <peer-address>"
+ " admin <up|down>",
.function = bfd_cli_udp_session_set_flags,
};
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_auth_activate_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_auth_activate_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
u8 is_delayed = 0;
if (have_delayed_token)
}
vnet_api_error_t rv =
- bfd_udp_auth_activate (sw_if_index, &local_addr, &peer_addr, conf_key_id,
- bfd_key_id, is_delayed);
+ bfd_udp_auth_activate (multihop, sw_if_index, &local_addr, &peer_addr,
+ conf_key_id, bfd_key_id, is_delayed);
if (rv)
{
ret =
VLIB_CLI_COMMAND (bfd_cli_udp_session_auth_activate_command, static) = {
.path = "bfd udp session auth activate",
.short_help = "bfd udp session auth activate"
- " interface <interface>"
- " local-addr <local-address>"
-
" peer-addr <peer-address>"
- " conf-key-id <config key ID>"
- " bfd-key-id <BFD key ID>"
- " [ delayed <yes|no> ]",
+ " <multihop | interface <interface>>"
+ " local-addr <local-address>"
+ " peer-addr <peer-address>"
+ " conf-key-id <config key ID>"
+ " bfd-key-id <BFD key ID>"
+ " [ delayed <yes|no> ]",
.function = bfd_cli_udp_session_auth_activate,
};
clib_error_t *ret = NULL;
unformat_input_t _line_input, *line_input = &_line_input;
#define foreach_bfd_cli_udp_session_auth_deactivate_cli_param(F) \
- F (u32, sw_if_index, INTERFACE_STR, mandatory, "%U", \
+ F (bool, multihop, MULTIHOP_STR, optional, "%_") \
+ F (u32, sw_if_index, INTERFACE_STR, optional, "%U", \
unformat_vnet_sw_interface, &vnet_main) \
F (ip46_address_t, local_addr, LOCAL_ADDR_STR, mandatory, "%U", \
bfd_cli_unformat_ip46_address) \
}
foreach_bfd_cli_udp_session_auth_deactivate_cli_param (CHECK_MANDATORY);
+ BFD_MULTIHOP_CLI_CHECK
u8 is_delayed = 0;
if (have_delayed_token)
}
}
- vnet_api_error_t rv = bfd_udp_auth_deactivate (sw_if_index, &local_addr,
- &peer_addr, is_delayed);
+ vnet_api_error_t rv = bfd_udp_auth_deactivate (
+ multihop, sw_if_index, &local_addr, &peer_addr, is_delayed);
if (rv)
{
ret = clib_error_return (
VLIB_CLI_COMMAND (bfd_cli_udp_session_auth_deactivate_command, static) = {
.path = "bfd udp session auth deactivate",
.short_help = "bfd udp session auth deactivate"
- " interface <interface>"
- " local-addr <local-address>"
-
" peer-addr <peer-address>"
- "[ delayed <yes|no> ]",
+ " <multihop | interface <interface>>"
+ " local-addr <local-address>"
+ " peer-addr <peer-address>"
+ "[ delayed <yes|no> ]",
.function = bfd_cli_udp_session_auth_deactivate,
};
#include <vlib/log.h>
#include <vnet/crypto/crypto.h>
+const char *
+bfd_hop_type_string (bfd_hop_type_e hoptype)
+{
+ switch (hoptype)
+ {
+#define F(x) \
+ case BFD_HOP_TYPE_##x: \
+ return "BFD_HOP_TYPE_" #x;
+ foreach_bfd_hop (F)
+#undef F
+ }
+ return "UNKNOWN";
+}
+
static void
bfd_validate_counters (bfd_main_t *bm)
{
[BFD_TX_IP6_REWRITE] = "ip6-rewrite",
[BFD_TX_IP4_MIDCHAIN] = "ip4-midchain",
[BFD_TX_IP6_MIDCHAIN] = "ip6-midchain",
+ [BFD_TX_IP4_LOOKUP] = "ip4-lookup",
+ [BFD_TX_IP6_LOOKUP] = "ip6-lookup",
}
};
// clang-format on
format_bfd_session (u8 * s, va_list * args)
{
const bfd_session_t *bs = va_arg (*args, bfd_session_t *);
- s = format (s, "bs_idx=%u local-state=%s remote-state=%s\n"
- "local-discriminator=%u remote-discriminator=%u\n"
- "local-diag=%s echo-active=%s\n"
- "desired-min-tx=%u required-min-rx=%u\n"
- "required-min-echo-rx=%u detect-mult=%u\n"
- "remote-min-rx=%u remote-min-echo-rx=%u\n"
- "remote-demand=%s poll-state=%s\n"
- "auth: local-seq-num=%u remote-seq-num=%u\n"
- " is-delayed=%s\n"
- " curr-key=%U\n"
- " next-key=%U",
- bs->bs_idx, bfd_state_string (bs->local_state),
- bfd_state_string (bs->remote_state), bs->local_discr,
- bs->remote_discr, bfd_diag_code_string (bs->local_diag),
- (bs->echo ? "yes" : "no"), bs->config_desired_min_tx_usec,
- bs->config_required_min_rx_usec, 1, bs->local_detect_mult,
- bs->remote_min_rx_usec, bs->remote_min_echo_rx_usec,
- (bs->remote_demand ? "yes" : "no"),
- bfd_poll_state_string (bs->poll_state),
- bs->auth.local_seq_number, bs->auth.remote_seq_number,
- (bs->auth.is_delayed ? "yes" : "no"),
- format_bfd_auth_key, bs->auth.curr_key, format_bfd_auth_key,
- bs->auth.next_key);
+ s = format (
+ s,
+ "bs_idx=%u hop-type=%s local-state=%s remote-state=%s\n"
+ "local-discriminator=%u remote-discriminator=%u\n"
+ "local-diag=%s echo-active=%s\n"
+ "desired-min-tx=%u required-min-rx=%u\n"
+ "required-min-echo-rx=%u detect-mult=%u\n"
+ "remote-min-rx=%u remote-min-echo-rx=%u\n"
+ "remote-demand=%s poll-state=%s\n"
+ "auth: local-seq-num=%u remote-seq-num=%u\n"
+ " is-delayed=%s\n"
+ " curr-key=%U\n"
+ " next-key=%U",
+ bs->bs_idx, bfd_hop_type_string (bs->hop_type),
+ bfd_state_string (bs->local_state), bfd_state_string (bs->remote_state),
+ bs->local_discr, bs->remote_discr, bfd_diag_code_string (bs->local_diag),
+ (bs->echo ? "yes" : "no"), bs->config_desired_min_tx_usec,
+ bs->config_required_min_rx_usec, 1, bs->local_detect_mult,
+ bs->remote_min_rx_usec, bs->remote_min_echo_rx_usec,
+ (bs->remote_demand ? "yes" : "no"), bfd_poll_state_string (bs->poll_state),
+ bs->auth.local_seq_number, bs->auth.remote_seq_number,
+ (bs->auth.is_delayed ? "yes" : "no"), format_bfd_auth_key,
+ bs->auth.curr_key, format_bfd_auth_key, bs->auth.next_key);
return s;
}
/**
* hop types
*/
-#define foreach_bfd_hop(F) \
- F (SINGLE, "single") \
- F (MULTI, "multi") \
+#define foreach_bfd_hop(F) \
+ F (SINGLE) \
+ F (MULTI)
typedef enum
{
-#define F(sym, str) BFD_HOP_TYPE_##sym,
+#define F(sym) BFD_HOP_TYPE_##sym,
foreach_bfd_hop (F)
#undef F
} bfd_hop_type_e;
/** vector of callback notification functions */
bfd_notify_fn_t *listeners;
+ /**
+ * true if multihop support is enabled so sw_if_index of ~0
+ * represents a multihop session
+ */
+ bool multihop_enabled;
+
/** log class */
vlib_log_class_t log_class;
u32 bfd_nsec_to_usec (u64 nsec);
const char *bfd_poll_state_string (bfd_poll_state_e state);
+const char *bfd_hop_type_string (bfd_hop_type_e state);
#define USEC_PER_MS (1000LL)
#define MSEC_PER_SEC (1000LL)
BFD_TX_IP6_REWRITE,
BFD_TX_IP4_MIDCHAIN,
BFD_TX_IP6_MIDCHAIN,
+ BFD_TX_IP4_LOOKUP,
+ BFD_TX_IP6_LOOKUP,
BFD_TX_N_NEXT,
} bfd_tx_next_t;
u32 echo_source_sw_if_index;
/* log class */
vlib_log_class_t log_class;
- /* number of active udp4 sessions */
- u32 udp4_sessions_count;
- u32 udp4_sessions_count_stat_seg_entry;
- /* number of active udp6 sessions */
- u32 udp6_sessions_count;
- u32 udp6_sessions_count_stat_seg_entry;
+ /* number of active udp4 single-hop sessions */
+ u32 udp4_sh_sessions_count;
+ u32 udp4_sh_sessions_count_stat_seg_entry;
+ /* number of active udp6 single-hop sessions */
+ u32 udp6_sh_sessions_count;
+ u32 udp6_sh_sessions_count_stat_seg_entry;
+ /* number of active udp4 multi-hop sessions */
+ u32 udp4_mh_sessions_count;
+ u32 udp4_mh_sessions_count_stat_seg_entry;
+ /* number of active udp6 multi-hop sessions */
+ u32 udp6_mh_sessions_count;
+ u32 udp6_mh_sessions_count_stat_seg_entry;
} bfd_udp_main_t;
static vlib_node_registration_t bfd_udp4_input_node;
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
- vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
- vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
+ if (bs->hop_type == BFD_HOP_TYPE_SINGLE)
+ {
+ vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
+ vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
+ }
vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0;
typedef struct
{
headers->ip4.src_address.as_u32 = key->local_addr.ip4.as_u32;
headers->ip4.dst_address.as_u32 = key->peer_addr.ip4.as_u32;
- headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd4);
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd4_mh);
+ }
+ else
+ {
+ headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd4);
+ }
}
/* fix ip length, checksum and udp length */
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
- vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
- vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
+ if (bs->hop_type == BFD_HOP_TYPE_SINGLE)
+ {
+ vnet_buffer (b)->ip.adj_index[VLIB_RX] = bus->adj_index;
+ vnet_buffer (b)->ip.adj_index[VLIB_TX] = bus->adj_index;
+ }
vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
typedef struct
sizeof (headers->ip6.src_address));
clib_memcpy_fast (&headers->ip6.dst_address, &key->peer_addr.ip6,
sizeof (headers->ip6.dst_address));
- headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd6);
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd6_mh);
+ }
+ else
+ {
+ headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd6);
+ }
}
/* fix ip payload length and udp length */
{
vnet_main_t *vnm = vnet_get_main ();
const bfd_udp_session_t *bus = &bs->udp;
- ip_adjacency_t *adj = adj_get (bus->adj_index);
- /* don't try to send the buffer if the interface is not up */
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ switch (bs->transport)
+ {
+ case BFD_TRANSPORT_UDP4:
+ *next_node = BFD_TX_IP4_LOOKUP;
+ return 1;
+ case BFD_TRANSPORT_UDP6:
+ *next_node = BFD_TX_IP6_LOOKUP;
+ return 1;
+ default:
+ /* drop */
+ return 0;
+ }
+ }
+
+ ip_adjacency_t *adj = adj_get (bus->adj_index);
+ /* For single-hop, don't try to send the buffer if the interface is not up */
if (!vnet_sw_interface_is_up (vnm, bus->key.sw_if_index))
return 0;
const ip46_address_t * peer_addr)
{
clib_memset (key, 0, sizeof (*key));
- key->sw_if_index = sw_if_index;
+ key->sw_if_index = sw_if_index & 0xFFFF;
key->local_addr.as_u64[0] = local_addr->as_u64[0];
key->local_addr.as_u64[1] = local_addr->as_u64[1];
key->peer_addr.as_u64[0] = peer_addr->as_u64[0];
}
static vnet_api_error_t
-bfd_udp_add_session_internal (vlib_main_t * vm, bfd_udp_main_t * bum,
- u32 sw_if_index, u32 desired_min_tx_usec,
+bfd_udp_add_session_internal (vlib_main_t *vm, bfd_udp_main_t *bum,
+ bool multihop, u32 sw_if_index,
+ u32 desired_min_tx_usec,
u32 required_min_rx_usec, u8 detect_mult,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- bfd_session_t ** bs_out)
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
+ bfd_session_t **bs_out)
{
/* get a pool entry and if we end up not needing it, give it back */
bfd_transport_e t = BFD_TRANSPORT_UDP4;
return VNET_API_ERROR_BFD_EEXIST;
}
mhash_set (&bum->bfd_session_idx_by_bfd_key, key, bs->bs_idx, NULL);
- BFD_DBG ("session created, bs_idx=%u, sw_if_index=%d, local=%U, peer=%U",
- bs->bs_idx, key->sw_if_index, format_ip46_address,
+ BFD_DBG ("session created, bs_idx=%u, multihop=%u, sw_if_index=%d, "
+ "local=%U, peer=%U",
+ bs->bs_idx, multihop, key->sw_if_index, format_ip46_address,
&key->local_addr, IP46_TYPE_ANY, format_ip46_address,
&key->peer_addr, IP46_TYPE_ANY);
vlib_log_info (bum->log_class, "create BFD session: %U",
&key->peer_addr);
if (BFD_TRANSPORT_UDP4 == t)
{
- bus->adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4, VNET_LINK_IP4,
- peer, key->sw_if_index);
- BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, VNET_LINK_IP4, %U, %d) "
- "returns %d",
- format_ip46_address, peer, IP46_TYPE_ANY, key->sw_if_index,
- bus->adj_index);
- ++bum->udp4_sessions_count;
- bfd_udp_update_stat_segment_entry (
- bum->udp4_sessions_count_stat_seg_entry, bum->udp4_sessions_count);
- if (1 == bum->udp4_sessions_count)
+ if (multihop)
{
- udp_register_dst_port (vm, UDP_DST_PORT_bfd4,
- bfd_udp4_input_node.index, 1);
- udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo4,
- bfd_udp_echo4_input_node.index, 1);
+ ++bum->udp4_mh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp4_mh_sessions_count_stat_seg_entry,
+ bum->udp4_mh_sessions_count);
+ if (1 == bum->udp4_mh_sessions_count)
+ {
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd4_mh,
+ bfd_udp4_input_node.index, 1);
+ }
+ }
+ else
+ {
+ bus->adj_index = adj_nbr_add_or_lock (
+ FIB_PROTOCOL_IP4, VNET_LINK_IP4, peer, key->sw_if_index);
+ BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, VNET_LINK_IP4, "
+ " %U, %d) returns %d",
+ format_ip46_address, peer, IP46_TYPE_ANY, key->sw_if_index,
+ bus->adj_index);
+ ++bum->udp4_sh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp4_sh_sessions_count_stat_seg_entry,
+ bum->udp4_sh_sessions_count);
+ if (1 == bum->udp4_sh_sessions_count)
+ {
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd4,
+ bfd_udp4_input_node.index, 1);
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo4,
+ bfd_udp_echo4_input_node.index, 1);
+ }
}
}
else
{
- bus->adj_index = adj_nbr_add_or_lock (FIB_PROTOCOL_IP6, VNET_LINK_IP6,
- peer, key->sw_if_index);
- BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP6, VNET_LINK_IP6, %U, %d) "
- "returns %d",
- format_ip46_address, peer, IP46_TYPE_ANY, key->sw_if_index,
- bus->adj_index);
- ++bum->udp6_sessions_count;
- bfd_udp_update_stat_segment_entry (
- bum->udp6_sessions_count_stat_seg_entry, bum->udp6_sessions_count);
- if (1 == bum->udp6_sessions_count)
+ if (multihop)
{
- udp_register_dst_port (vm, UDP_DST_PORT_bfd6,
- bfd_udp6_input_node.index, 0);
- udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo6,
- bfd_udp_echo6_input_node.index, 0);
+ ++bum->udp6_mh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp6_mh_sessions_count_stat_seg_entry,
+ bum->udp6_mh_sessions_count);
+ if (1 == bum->udp6_mh_sessions_count)
+ {
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd6_mh,
+ bfd_udp6_input_node.index, 0);
+ }
}
+ else
+ {
+ bus->adj_index = adj_nbr_add_or_lock (
+ FIB_PROTOCOL_IP6, VNET_LINK_IP6, peer, key->sw_if_index);
+ BFD_DBG ("adj_nbr_add_or_lock(FIB_PROTOCOL_IP6, VNET_LINK_IP6, "
+ "%U, %d) returns %d",
+ format_ip46_address, peer, IP46_TYPE_ANY, key->sw_if_index,
+ bus->adj_index);
+ ++bum->udp6_sh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp6_sh_sessions_count_stat_seg_entry,
+ bum->udp6_sh_sessions_count);
+ if (1 == bum->udp6_sh_sessions_count)
+ {
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd6,
+ bfd_udp6_input_node.index, 0);
+ udp_register_dst_port (vm, UDP_DST_PORT_bfd_echo6,
+ bfd_udp_echo6_input_node.index, 0);
+ }
+ }
+ }
+
+ if (multihop)
+ {
+ bs->hop_type = BFD_HOP_TYPE_MULTI;
+ }
+ else
+ {
+ bs->hop_type = BFD_HOP_TYPE_SINGLE;
}
*bs_out = bs;
return bfd_session_set_params (bum->bfd_main, bs, desired_min_tx_usec,
}
static vnet_api_error_t
-bfd_udp_validate_api_input (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr)
+bfd_udp_validate_api_input (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr)
{
bfd_udp_main_t *bum = &bfd_udp_main;
- vnet_sw_interface_t *sw_if =
- vnet_get_sw_interface_or_null (bfd_udp_main.vnet_main, sw_if_index);
- if (!sw_if)
+ if (!multihop)
{
- vlib_log_err (bum->log_class,
- "got NULL sw_if when getting interface by index %u",
- sw_if_index);
- return VNET_API_ERROR_INVALID_SW_IF_INDEX;
+ vnet_sw_interface_t *sw_if =
+ vnet_get_sw_interface_or_null (bfd_udp_main.vnet_main, sw_if_index);
+ if (!sw_if)
+ {
+ vlib_log_err (bum->log_class,
+ "got NULL sw_if when getting interface by index %u",
+ sw_if_index);
+ return VNET_API_ERROR_INVALID_SW_IF_INDEX;
+ }
}
+
if (ip46_address_is_ip4 (local_addr))
{
if (!ip46_address_is_ip4 (peer_addr))
}
static vnet_api_error_t
-bfd_udp_find_session_by_api_input (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- bfd_session_t ** bs_out)
+bfd_udp_find_session_by_api_input (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr,
+ bfd_session_t **bs_out)
{
vnet_api_error_t rv =
- bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr);
+ bfd_udp_validate_api_input (multihop, sw_if_index, local_addr, peer_addr);
if (!rv)
{
bfd_udp_main_t *bum = &bfd_udp_main;
else
{
vlib_log_err (bum->log_class,
- "BFD session not found, sw_if_index=%u, local=%U, peer=%U",
- sw_if_index, format_ip46_address, local_addr,
+ "BFD session not found, multihop=%d, sw_if_index=%u, "
+ "local=%U, peer=%U",
+ multihop, sw_if_index, format_ip46_address, local_addr,
IP46_TYPE_ANY, format_ip46_address, peer_addr,
IP46_TYPE_ANY);
return VNET_API_ERROR_BFD_ENOENT;
}
static vnet_api_error_t
-bfd_api_verify_common (u32 sw_if_index, u32 desired_min_tx_usec,
+bfd_api_verify_common (bool multihop, u32 sw_if_index, u32 desired_min_tx_usec,
u8 detect_mult, const ip46_address_t *local_addr,
const ip46_address_t *peer_addr)
{
bfd_udp_main_t *bum = &bfd_udp_main;
vnet_api_error_t rv =
- bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr);
+ bfd_udp_validate_api_input (multihop, sw_if_index, local_addr, peer_addr);
if (rv)
{
return rv;
switch (bs->transport)
{
case BFD_TRANSPORT_UDP4:
- --bum->udp4_sessions_count;
- bfd_udp_update_stat_segment_entry (
- bum->udp4_sessions_count_stat_seg_entry, bum->udp4_sessions_count);
- if (!bum->udp4_sessions_count)
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
{
- udp_unregister_dst_port (vm, UDP_DST_PORT_bfd4, 1);
- udp_unregister_dst_port (vm, UDP_DST_PORT_bfd_echo4, 1);
+ --bum->udp4_mh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp4_mh_sessions_count_stat_seg_entry,
+ bum->udp4_mh_sessions_count);
+ if (!bum->udp4_mh_sessions_count)
+ {
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd4_mh, 1);
+ }
+ }
+ else
+ {
+ --bum->udp4_sh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp4_sh_sessions_count_stat_seg_entry,
+ bum->udp4_sh_sessions_count);
+ if (!bum->udp4_sh_sessions_count)
+ {
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd4, 1);
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd_echo4, 1);
+ }
}
break;
case BFD_TRANSPORT_UDP6:
- --bum->udp6_sessions_count;
- bfd_udp_update_stat_segment_entry (
- bum->udp6_sessions_count_stat_seg_entry, bum->udp6_sessions_count);
- if (!bum->udp6_sessions_count)
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ --bum->udp6_mh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp6_mh_sessions_count_stat_seg_entry,
+ bum->udp6_mh_sessions_count);
+ if (!bum->udp6_mh_sessions_count)
+ {
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd6_mh, 0);
+ }
+ }
+ else
{
- udp_unregister_dst_port (vm, UDP_DST_PORT_bfd6, 0);
- udp_unregister_dst_port (vm, UDP_DST_PORT_bfd_echo6, 0);
+ --bum->udp6_sh_sessions_count;
+ bfd_udp_update_stat_segment_entry (
+ bum->udp6_sh_sessions_count_stat_seg_entry,
+ bum->udp6_sh_sessions_count);
+ if (!bum->udp6_sh_sessions_count)
+ {
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd6, 0);
+ udp_unregister_dst_port (vm, UDP_DST_PORT_bfd_echo6, 0);
+ }
}
+
break;
}
bfd_put_session (bum->bfd_main, bs);
}
static vnet_api_error_t
-bfd_udp_add_and_start_session (u32 sw_if_index,
+bfd_udp_add_and_start_session (bool multihop, u32 sw_if_index,
const ip46_address_t *local_addr,
const ip46_address_t *peer_addr,
u32 desired_min_tx_usec,
bfd_session_t *bs = NULL;
vnet_api_error_t rv;
- rv = bfd_udp_add_session_internal (
- vlib_get_main (), &bfd_udp_main, sw_if_index, desired_min_tx_usec,
- required_min_rx_usec, detect_mult, local_addr, peer_addr, &bs);
+ rv = bfd_udp_add_session_internal (vlib_get_main (), &bfd_udp_main, multihop,
+ sw_if_index, desired_min_tx_usec,
+ required_min_rx_usec, detect_mult,
+ local_addr, peer_addr, &bs);
if (!rv && is_authenticated)
{
}
vnet_api_error_t
-bfd_udp_add_session (u32 sw_if_index, const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- u32 desired_min_tx_usec, u32 required_min_rx_usec,
- u8 detect_mult, u8 is_authenticated, u32 conf_key_id,
- u8 bfd_key_id)
+bfd_udp_add_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr, u32 desired_min_tx_usec,
+ u32 required_min_rx_usec, u8 detect_mult,
+ u8 is_authenticated, u32 conf_key_id, u8 bfd_key_id)
{
bfd_main_t *bm = &bfd_main;
bfd_lock (bm);
- vnet_api_error_t rv = bfd_api_verify_common (
- sw_if_index, desired_min_tx_usec, detect_mult, local_addr, peer_addr);
+ vnet_api_error_t rv =
+ bfd_api_verify_common (multihop, sw_if_index, desired_min_tx_usec,
+ detect_mult, local_addr, peer_addr);
if (!rv)
rv = bfd_udp_add_and_start_session (
- sw_if_index, local_addr, peer_addr, desired_min_tx_usec,
+ multihop, sw_if_index, local_addr, peer_addr, desired_min_tx_usec,
required_min_rx_usec, detect_mult, is_authenticated, conf_key_id,
bfd_key_id);
}
vnet_api_error_t
-bfd_udp_upd_session (u32 sw_if_index, const ip46_address_t *local_addr,
+bfd_udp_upd_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
const ip46_address_t *peer_addr, u32 desired_min_tx_usec,
u32 required_min_rx_usec, u8 detect_mult,
u8 is_authenticated, u32 conf_key_id, u8 bfd_key_id)
bfd_main_t *bm = &bfd_main;
bfd_lock (bm);
- vnet_api_error_t rv = bfd_api_verify_common (
- sw_if_index, desired_min_tx_usec, detect_mult, local_addr, peer_addr);
+ vnet_api_error_t rv =
+ bfd_api_verify_common (multihop, sw_if_index, desired_min_tx_usec,
+ detect_mult, local_addr, peer_addr);
if (!rv)
{
bfd_session_t *bs = NULL;
- rv = bfd_udp_find_session_by_api_input (sw_if_index, local_addr,
- peer_addr, &bs);
+ rv = bfd_udp_find_session_by_api_input (multihop, sw_if_index,
+ local_addr, peer_addr, &bs);
if (VNET_API_ERROR_BFD_ENOENT == rv)
rv = bfd_udp_add_and_start_session (
- sw_if_index, local_addr, peer_addr, desired_min_tx_usec,
+ multihop, sw_if_index, local_addr, peer_addr, desired_min_tx_usec,
required_min_rx_usec, detect_mult, is_authenticated, conf_key_id,
bfd_key_id);
else
}
vnet_api_error_t
-bfd_udp_mod_session (u32 sw_if_index, const ip46_address_t *local_addr,
+bfd_udp_mod_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
const ip46_address_t *peer_addr, u32 desired_min_tx_usec,
u32 required_min_rx_usec, u8 detect_mult)
{
bfd_main_t *bm = &bfd_main;
vnet_api_error_t error;
bfd_lock (bm);
- vnet_api_error_t rv =
- bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
- &bs);
+ vnet_api_error_t rv = bfd_udp_find_session_by_api_input (
+ multihop, sw_if_index, local_addr, peer_addr, &bs);
if (rv)
{
bfd_unlock (bm);
}
vnet_api_error_t
-bfd_udp_del_session (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr)
+bfd_udp_del_session (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr)
{
bfd_session_t *bs = NULL;
bfd_main_t *bm = &bfd_main;
bfd_lock (bm);
- vnet_api_error_t rv =
- bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
- &bs);
+ vnet_api_error_t rv = bfd_udp_find_session_by_api_input (
+ multihop, sw_if_index, local_addr, peer_addr, &bs);
if (rv)
{
bfd_unlock (bm);
}
vnet_api_error_t
-bfd_udp_session_set_flags (vlib_main_t * vm, u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr, u8 admin_up_down)
+bfd_udp_session_set_flags (vlib_main_t *vm, bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr, u8 admin_up_down)
{
bfd_session_t *bs = NULL;
bfd_main_t *bm = &bfd_main;
bfd_lock (bm);
- vnet_api_error_t rv =
- bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
- &bs);
+ vnet_api_error_t rv = bfd_udp_find_session_by_api_input (
+ multihop, sw_if_index, local_addr, peer_addr, &bs);
if (rv)
{
bfd_unlock (bm);
}
vnet_api_error_t
-bfd_udp_auth_activate (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr,
- u32 conf_key_id, u8 key_id, u8 is_delayed)
+bfd_udp_auth_activate (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr, u32 conf_key_id,
+ u8 key_id, u8 is_delayed)
{
bfd_main_t *bm = &bfd_main;
bfd_lock (bm);
vnet_api_error_t error;
bfd_session_t *bs = NULL;
- vnet_api_error_t rv =
- bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
- &bs);
+ vnet_api_error_t rv = bfd_udp_find_session_by_api_input (
+ multihop, sw_if_index, local_addr, peer_addr, &bs);
if (rv)
{
bfd_unlock (bm);
}
vnet_api_error_t
-bfd_udp_auth_deactivate (u32 sw_if_index,
- const ip46_address_t * local_addr,
- const ip46_address_t * peer_addr, u8 is_delayed)
+bfd_udp_auth_deactivate (bool multihop, u32 sw_if_index,
+ const ip46_address_t *local_addr,
+ const ip46_address_t *peer_addr, u8 is_delayed)
{
bfd_main_t *bm = &bfd_main;
vnet_api_error_t error;
bfd_lock (bm);
bfd_session_t *bs = NULL;
- vnet_api_error_t rv =
- bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
- &bs);
+ vnet_api_error_t rv = bfd_udp_find_session_by_api_input (
+ multihop, sw_if_index, local_addr, peer_addr, &bs);
if (rv)
{
bfd_unlock (bm);
key->local_addr.ip4.as_u8);
return BFD_UDP_ERROR_DST_MISMATCH;
}
- const u8 expected_ttl = 255;
- if (ip4->ttl != expected_ttl)
+
+ // For single-hop, TTL must be 255
+ if (bs->hop_type == BFD_HOP_TYPE_SINGLE)
{
- BFD_ERR ("IPv4 unexpected TTL value %u, expected %u", ip4->ttl,
- expected_ttl);
- return BFD_UDP_ERROR_TTL;
+ const u8 expected_ttl = 255;
+ if (ip4->ttl != expected_ttl)
+ {
+ BFD_ERR ("IPv4 unexpected TTL value %u, expected %u", ip4->ttl,
+ expected_ttl);
+ return BFD_UDP_ERROR_TTL;
+ }
}
+
if (clib_net_to_host_u16 (udp->src_port) < 49152)
{
BFD_ERR ("Invalid UDP src port %u, out of range <49152,65535>",
{
bfd_udp_key_t key;
clib_memset (&key, 0, sizeof (key));
- key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+ if (udp->dst_port == clib_host_to_net_u16 (UDP_DST_PORT_bfd4_mh))
+ {
+ key.sw_if_index = ~0;
+ }
+ else
+ {
+ key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+ }
key.local_addr.ip4.as_u32 = ip4->dst_address.as_u32;
key.peer_addr.ip4.as_u32 = ip4->src_address.as_u32;
BFD_DBG ("Looking up BFD session using key (sw_if_index=%u, local=%U, "
&key->local_addr.ip6);
return BFD_UDP_ERROR_DST_MISMATCH;
}
- const u8 expected_hop_limit = 255;
- if (ip6->hop_limit != expected_hop_limit)
+
+ // For single-hop, hop-limit must be 255
+ if (bs->hop_type == BFD_HOP_TYPE_SINGLE)
{
- BFD_ERR ("IPv6 unexpected hop-limit value %u, expected %u",
- ip6->hop_limit, expected_hop_limit);
- return BFD_UDP_ERROR_TTL;
+ const u8 expected_hop_limit = 255;
+ if (ip6->hop_limit != expected_hop_limit)
+ {
+ BFD_ERR ("IPv6 unexpected hop-limit value %u, expected %u",
+ ip6->hop_limit, expected_hop_limit);
+ return BFD_UDP_ERROR_TTL;
+ }
}
+
if (clib_net_to_host_u16 (udp->src_port) < 49152)
{
BFD_ERR ("Invalid UDP src port %u, out of range <49152,65535>",
{
bfd_udp_key_t key;
clib_memset (&key, 0, sizeof (key));
- key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+ if (udp->dst_port == clib_host_to_net_u16 (UDP_DST_PORT_bfd6_mh))
+ {
+ key.sw_if_index = ~0;
+ }
+ else
+ {
+ key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+ }
key.local_addr.ip6.as_u64[0] = ip6->dst_address.as_u64[0];
key.local_addr.ip6.as_u64[1] = ip6->dst_address.as_u64[1];
key.peer_addr.ip6.as_u64[0] = ip6->src_address.as_u64[0];
key.peer_addr.ip6.as_u64[1] = ip6->src_address.as_u64[1];
- BFD_DBG ("Looking up BFD session using key (sw_if_index=%u, local=%U, "
- "peer=%U)",
- key.sw_if_index, format_ip6_address, &key.local_addr,
- format_ip6_address, &key.peer_addr);
+ BFD_DBG ("Looking up BFD session using discriminator %u",
+ pkt->your_disc);
+ bs = bfd_find_session_by_disc (bfd_udp_main.bfd_main, pkt->your_disc);
+
bs = bfd_lookup_session (&bfd_udp_main, &key);
}
if (!bs)
{
u64 len;
t0 = vlib_add_trace (vm, rt, b0, sizeof (*t0));
- len = (b0->current_length < sizeof (t0->data)) ? b0->current_length
- : sizeof (t0->data);
+ len = (b0->current_length < sizeof (t0->data)) ? b0->current_length :
+ sizeof (t0->data);
t0->len = len;
clib_memcpy_fast (t0->data, vlib_buffer_get_current (b0), len);
}
vlib_node_increment_counter (vm, bfd_udp4_input_node.index,
error0, 1);
}
+
const bfd_udp_session_t *bus = &bs->udp;
- ip_adjacency_t *adj = adj_get (bus->adj_index);
- switch (adj->lookup_next_index)
+
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
{
- case IP_LOOKUP_NEXT_ARP:
- next0 = BFD_UDP_INPUT_NEXT_REPLY_ARP;
- break;
- case IP_LOOKUP_NEXT_REWRITE:
next0 = BFD_UDP_INPUT_NEXT_REPLY_REWRITE;
- break;
- case IP_LOOKUP_NEXT_MIDCHAIN:
- next0 = BFD_UDP_INPUT_NEXT_REPLY_MIDCHAIN;
- break;
- default:
- /* drop */
- break;
+ }
+ else
+ {
+ ip_adjacency_t *adj = adj_get (bus->adj_index);
+ switch (adj->lookup_next_index)
+ {
+ case IP_LOOKUP_NEXT_ARP:
+ next0 = BFD_UDP_INPUT_NEXT_REPLY_ARP;
+ break;
+ case IP_LOOKUP_NEXT_REWRITE:
+ next0 = BFD_UDP_INPUT_NEXT_REPLY_REWRITE;
+ break;
+ case IP_LOOKUP_NEXT_MIDCHAIN:
+ next0 = BFD_UDP_INPUT_NEXT_REPLY_MIDCHAIN;
+ break;
+ default:
+ /* drop */
+ break;
+ }
}
}
}
+
bfd_unlock (bm);
vlib_set_next_frame_buffer (vm, rt, next0, bi0);
{
continue;
}
+ if (bs->hop_type == BFD_HOP_TYPE_MULTI)
+ {
+ continue;
+ }
if (bs->udp.key.sw_if_index != sw_if_index)
{
continue;
bfd_udp_stats_init (bfd_udp_main_t *bum)
{
const char *name4 = "/bfd/udp4/sessions";
- bum->udp4_sessions_count_stat_seg_entry = vlib_stats_add_gauge ("%s", name4);
+ bum->udp4_sh_sessions_count_stat_seg_entry =
+ vlib_stats_add_gauge ("%s", name4);
- vlib_stats_set_gauge (bum->udp4_sessions_count_stat_seg_entry, 0);
- if (~0 == bum->udp4_sessions_count_stat_seg_entry)
+ vlib_stats_set_gauge (bum->udp4_sh_sessions_count_stat_seg_entry, 0);
+ if (~0 == bum->udp4_sh_sessions_count_stat_seg_entry)
{
return clib_error_return (
0, "Could not create stat segment entry for %s", name4);
}
const char *name6 = "/bfd/udp6/sessions";
- bum->udp6_sessions_count_stat_seg_entry = vlib_stats_add_gauge ("%s", name6);
+ bum->udp6_sh_sessions_count_stat_seg_entry =
+ vlib_stats_add_gauge ("%s", name6);
- vlib_stats_set_gauge (bum->udp6_sessions_count_stat_seg_entry, 0);
- if (~0 == bum->udp6_sessions_count_stat_seg_entry)
+ vlib_stats_set_gauge (bum->udp6_sh_sessions_count_stat_seg_entry, 0);
+ if (~0 == bum->udp6_sh_sessions_count_stat_seg_entry)
{
return clib_error_return (
0, "Could not create stat segment entry for %s", name6);
}
+ const char *name4_mh = "/bfd/udp4/sessions_mh";
+ bum->udp4_mh_sessions_count_stat_seg_entry =
+ vlib_stats_add_gauge ("%s", name4_mh);
+
+ vlib_stats_set_gauge (bum->udp4_mh_sessions_count_stat_seg_entry, 0);
+ if (~0 == bum->udp4_mh_sessions_count_stat_seg_entry)
+ {
+ return clib_error_return (
+ 0, "Could not create stat segment entry for %s", name4_mh);
+ }
+ const char *name6_mh = "/bfd/udp6/sessions_mh";
+ bum->udp6_mh_sessions_count_stat_seg_entry =
+ vlib_stats_add_gauge ("%s", name6_mh);
+
+ vlib_stats_set_gauge (bum->udp6_mh_sessions_count_stat_seg_entry, 0);
+ if (~0 == bum->udp6_mh_sessions_count_stat_seg_entry)
+ {
+ return clib_error_return (
+ 0, "Could not create stat segment entry for %s", name6_mh);
+ }
+
return 0;
}
static clib_error_t *
bfd_udp_init (vlib_main_t * vm)
{
- bfd_udp_main.udp4_sessions_count = 0;
- bfd_udp_main.udp6_sessions_count = 0;
+ bfd_udp_main.udp4_sh_sessions_count = 0;
+ bfd_udp_main.udp6_sh_sessions_count = 0;
+ bfd_udp_main.udp4_mh_sessions_count = 0;
+ bfd_udp_main.udp6_mh_sessions_count = 0;
mhash_init (&bfd_udp_main.bfd_session_idx_by_bfd_key, sizeof (uword),
sizeof (bfd_udp_key_t));
bfd_udp_main.bfd_main = &bfd_main;
/** identifier of BFD session based on UDP transport only */
typedef CLIB_PACKED (struct {
- union {
- /** interface to which the session is tied - single-hop */
- u32 sw_if_index;
- /** the FIB index the peer is in - multi-hop*/
- u32 fib_index;
- };
+ /** interface to which the session is tied - single-hop */
+ u16 sw_if_index;
+ /** the FIB index the peer is in - multi-hop*/
+ u16 fib_index;
/** local address */
ip46_address_t local_addr;
/** peer address */
#include <vnet/vnet.h>
-#define foreach_udp4_dst_port \
-_ (53, dns) \
-_ (67, dhcp_to_server) \
-_ (68, dhcp_to_client) \
-_ (500, ikev2) \
-_ (2152, GTPU) \
-_ (3784, bfd4) \
-_ (3785, bfd_echo4) \
-_ (4341, lisp_gpe) \
-_ (4342, lisp_cp) \
-_ (4500, ipsec) \
-_ (4739, ipfix) \
-_ (4789, vxlan) \
-_ (4789, vxlan6) \
-_ (48879, vxlan_gbp) \
-_ (4790, VXLAN_GPE) \
-_ (6633, vpath_3) \
-_ (6081, geneve) \
-_ (53053, dns_reply)
+#define foreach_udp4_dst_port \
+ _ (53, dns) \
+ _ (67, dhcp_to_server) \
+ _ (68, dhcp_to_client) \
+ _ (500, ikev2) \
+ _ (2152, GTPU) \
+ _ (3784, bfd4) \
+ _ (3785, bfd_echo4) \
+ _ (4341, lisp_gpe) \
+ _ (4342, lisp_cp) \
+ _ (4500, ipsec) \
+ _ (4739, ipfix) \
+ _ (4784, bfd4_mh) \
+ _ (4789, vxlan) \
+ _ (4789, vxlan6) \
+ _ (48879, vxlan_gbp) \
+ _ (4790, VXLAN_GPE) \
+ _ (6633, vpath_3) \
+ _ (6081, geneve) \
+ _ (53053, dns_reply)
-
-#define foreach_udp6_dst_port \
-_ (53, dns6) \
-_ (547, dhcpv6_to_server) \
-_ (546, dhcpv6_to_client) \
-_ (2152, GTPU6) \
-_ (3784, bfd6) \
-_ (3785, bfd_echo6) \
-_ (4341, lisp_gpe6) \
-_ (4342, lisp_cp6) \
-_ (48879, vxlan6_gbp) \
-_ (4790, VXLAN6_GPE) \
-_ (6633, vpath6_3) \
-_ (6081, geneve6) \
-_ (8138, BIER) \
-_ (53053, dns_reply6)
+#define foreach_udp6_dst_port \
+ _ (53, dns6) \
+ _ (547, dhcpv6_to_server) \
+ _ (546, dhcpv6_to_client) \
+ _ (2152, GTPU6) \
+ _ (3784, bfd6) \
+ _ (3785, bfd_echo6) \
+ _ (4341, lisp_gpe6) \
+ _ (4342, lisp_cp6) \
+ _ (48879, vxlan6_gbp) \
+ _ (4784, bfd6_mh) \
+ _ (4790, VXLAN6_GPE) \
+ _ (6633, vpath6_3) \
+ _ (6081, geneve6) \
+ _ (8138, BIER) \
+ _ (53053, dns_reply6)
typedef enum
{
from util import NumericConstant
from vpp_papi import VppEnum
+BFD_UDP_SH_PORT = 3784
+BFD_UDP_MH_PORT = 4784
+
class BFDDiagCode(NumericConstant):
"""BFD Diagnostic Code"""
# glue the BFD packet class to scapy parser
-bind_layers(UDP, BFD, dport=BFD.udp_dport)
+bind_layers(UDP, BFD, dport=BFD_UDP_SH_PORT)
+bind_layers(UDP, BFD, dport=BFD_UDP_MH_PORT)
class BFD_vpp_echo(Packet):
test,
interface,
peer_addr,
+ multihop=False,
local_addr=None,
af=AF_INET,
desired_min_tx=300000,
is_tunnel=False,
):
self._test = test
+ self._multihop = multihop
self._interface = interface
self._af = af
+
+ if multihop:
+ self._sw_if_index = 0xFFFFFFFF
+ self.test.vapi.bfd_udp_enable_multihop()
+ else:
+ self._sw_if_index = self._interface.sw_if_index
+
if local_addr:
self._local_addr = local_addr
else:
- self._local_addr = None
+ if self.af == AF_INET:
+ self._local_addr = self.interface.local_ip4
+ else:
+ self._local_addr = self.interface.local_ip6
+
self._peer_addr = peer_addr
self._desired_min_tx = desired_min_tx
self._required_min_rx = required_min_rx
result = self.test.vapi.bfd_udp_session_dump()
for s in result:
self.test.logger.debug("session entry: %s" % str(s))
- if s.sw_if_index == self.interface.sw_if_index:
- if (
- self.af == AF_INET
- and self.interface.local_ip4 == str(s.local_addr)
- and self.interface.remote_ip4 == str(s.peer_addr)
- ):
- return s
- if (
- self.af == AF_INET6
- and self.interface.local_ip6 == str(s.local_addr)
- and self.interface.remote_ip6 == str(s.peer_addr)
+ multihop = s.sw_if_index == ~0
+ if multihop or s.sw_if_index == self._sw_if_index:
+ if self._local_addr == str(s.local_addr) and self._peer_addr == str(
+ s.peer_addr
):
return s
return None
conf_key_id = self._sha1_key.conf_key_id
is_delayed = 1 if delayed else 0
self.test.vapi.bfd_udp_auth_activate(
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
local_addr=self.local_addr,
peer_addr=self.peer_addr,
bfd_key_id=self._bfd_key_id,
self._sha1_key = None
is_delayed = 1 if delayed else 0
self.test.vapi.bfd_udp_auth_deactivate(
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
local_addr=self.local_addr,
peer_addr=self.peer_addr,
is_delayed=is_delayed,
if required_min_rx:
self._required_min_rx = required_min_rx
self.test.vapi.bfd_udp_mod(
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
desired_min_tx=self.desired_min_tx,
required_min_rx=self.required_min_rx,
detect_mult=self.detect_mult,
conf_key_id = self._sha1_key.conf_key_id if self._sha1_key else None
is_authenticated = True if self._sha1_key else False
self.test.vapi.bfd_udp_add(
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
desired_min_tx=self.desired_min_tx,
required_min_rx=self.required_min_rx,
detect_mult=self.detect_mult,
conf_key_id = self._sha1_key.conf_key_id if self._sha1_key else None
is_authenticated = True if self._sha1_key else False
self.test.vapi.bfd_udp_upd(
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
desired_min_tx=self.desired_min_tx,
required_min_rx=self.required_min_rx,
detect_mult=self.detect_mult,
def remove_vpp_config(self):
self.test.vapi.bfd_udp_del(
- self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
local_addr=self.local_addr,
peer_addr=self.peer_addr,
)
def object_id(self):
- return "bfd-udp-%s-%s-%s-%s" % (
- self._interface.sw_if_index,
+ return "bfd-udp-%s-%s-%s-%s-%s" % (
+ self._multihop,
+ self._sw_if_index,
self.local_addr,
self.peer_addr,
self.af,
"""set bfd session admin-up"""
self.test.vapi.bfd_udp_session_set_flags(
flags=VppEnum.vl_api_if_status_flags_t.IF_STATUS_API_FLAG_ADMIN_UP,
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
local_addr=self.local_addr,
peer_addr=self.peer_addr,
)
"""set bfd session admin-down"""
self.test.vapi.bfd_udp_session_set_flags(
flags=0,
- sw_if_index=self._interface.sw_if_index,
+ sw_if_index=self._sw_if_index,
local_addr=self.local_addr,
peer_addr=self.peer_addr,
)
import unittest
from random import randint, shuffle, getrandbits
from socket import AF_INET, AF_INET6
+from parameterized import parameterized, parameterized_class
import scapy.compat
from scapy.layers.inet import UDP, IP
BFDDiagCode,
BFDState,
BFD_vpp_echo,
+ BFD_UDP_SH_PORT,
+ BFD_UDP_MH_PORT,
)
from framework import VppTestCase
from asfframework import (
from vpp_gre_interface import VppGreInterface
USEC_IN_SEC = 1000000
+BFD_STATS_V4_SH_PATH = "/bfd/udp4/sessions"
+BFD_STATS_V6_SH_PATH = "/bfd/udp6/sessions"
+BFD_STATS_V4_MH_PATH = "/bfd/udp4/sessions_mh"
+BFD_STATS_V6_MH_PATH = "/bfd/udp6/sessions_mh"
+BFD_IPV4_REMOTE_ADDR = "2.2.2.2"
+BFD_IPV6_REMOTE_ADDR = "2::2"
+BFD_IPV4_REMOTE_ADDR2 = "3.3.3.3"
+BFD_IPV6_REMOTE_ADDR2 = "3::3"
+
+
+def set_ipv4_pfx_route_info(cls, pg_if, dst_ip, set_src):
+ try:
+ if cls.multihop:
+ paths = []
+ # Get list of all the next hops
+ for nh_host in pg_if.remote_hosts:
+ nh_host_ip = nh_host.ip4
+ paths.append(VppRoutePath(nh_host_ip, pg_if.sw_if_index))
+ cls.dst_ip_net = dst_ip
+ # Create a route pointing to list of next hops
+ if paths:
+ rip = VppIpRoute(cls, cls.dst_ip_net, 32, paths)
+ rip.add_vpp_config()
+ cls.logger.info("Route via %s on %s created" % (paths, pg_if.name))
+ if set_src:
+ cls.src_ip_net = cls.loopback0.local_ip4
+ else:
+ cls.dst_ip_net = pg_if.remote_ip4
+ if set_src:
+ cls.src_ip_net = pg_if.local_ip4
+ except BaseException:
+ cls.vapi.want_bfd_events(enable_disable=0)
+ raise
+
+
+def set_ipv6_pfx_route_info(cls, pg_if, dst_ip, set_src):
+ try:
+ if cls.multihop:
+ paths = []
+ # Get list of all the next hops
+ for nh_host in pg_if.remote_hosts:
+ nh_host_ip = nh_host.ip6
+ paths.append(VppRoutePath(nh_host_ip, pg_if.sw_if_index))
+ cls.dst_ip6_net = dst_ip
+ # Create a route pointing to list of next hops
+ if paths:
+ rip = VppIpRoute(cls, cls.dst_ip6_net, 128, paths)
+ rip.add_vpp_config()
+ cls.logger.info("Route via %s on %s created" % (paths, pg_if.name))
+ if set_src:
+ cls.src_ip6_net = cls.loopback0.local_ip6
+ else:
+ cls.dst_ip6_net = cls.pg0.remote_ip6
+ if set_src:
+ cls.src_ip6_net = cls.pg0.local_ip6
+ except BaseException:
+ cls.vapi.want_bfd_events(enable_disable=0)
+ raise
class AuthKeyFactory(object):
)
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
class BFDAPITestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) - API"""
pg0 = None
pg1 = None
+ interface0 = None
+ interface1 = None
+ src_ip_net = ""
+ dst_ip_net = ""
+ src_ip_net2 = ""
+ dst_ip_net2 = ""
+ src_ip6_net = ""
+ dst_ip6_net = ""
+ src_ip6_net2 = ""
+ dst_ip6_net2 = ""
@classmethod
def setUpClass(cls):
super(BFDAPITestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = (
+ f"""""Bidirectional Forwarding Detection (BFD) - API, {hoptype_str}"""
+ )
cls.vapi.cli("set log class bfd level debug")
try:
cls.create_pg_interfaces(range(2))
+ cls.create_loopback_interfaces(2)
+ cls.loopback0 = cls.lo_interfaces[0]
+ cls.loopback0.config_ip4()
+ cls.loopback0.admin_up()
+ cls.loopback1 = cls.lo_interfaces[1]
+ cls.loopback1.config_ip4()
+ cls.loopback1.admin_up()
for i in cls.pg_interfaces:
i.config_ip4()
i.config_ip6()
super(BFDAPITestCase, self).setUp()
self.factory = AuthKeyFactory()
+ if self.multihop:
+ self.interface0 = None
+ self.interface1 = None
+ self.src_ip_net = self.loopback0.local_ip4
+ self.src_ip6_net = self.loopback0.local_ip6
+ self.dst_ip_net = BFD_IPV4_REMOTE_ADDR
+ self.dst_ip6_net = BFD_IPV6_REMOTE_ADDR
+ self.src_ip_net2 = self.loopback1.local_ip4
+ self.src_ip6_net2 = self.loopback1.local_ip6
+ self.dst_ip_net2 = BFD_IPV4_REMOTE_ADDR2
+ self.dst_ip6_net2 = BFD_IPV6_REMOTE_ADDR2
+ else:
+ self.interface0 = self.pg0
+ self.interface1 = self.pg1
+ self.src_ip_net = self.pg0.local_ip4
+ self.src_ip6_net = self.pg0.local_ip6
+ self.dst_ip_net = self.pg0.remote_ip4
+ self.dst_ip6_net = self.pg0.remote_ip6
+ self.src_ip_net2 = self.pg1.local_ip4
+ self.src_ip6_net2 = self.pg1.local_ip6
+ self.dst_ip_net2 = BFD_IPV4_REMOTE_ADDR2
+ self.dst_ip6_net2 = BFD_IPV6_REMOTE_ADDR2
+
def test_add_bfd(self):
"""create a BFD session"""
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
def test_double_add(self):
"""create the same BFD session twice (negative case)"""
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
with self.vapi.assert_negative_api_retval():
def test_add_bfd6(self):
"""create IPv6 BFD session"""
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
"""modify BFD session parameters"""
session = VppBFDUDPSession(
self,
- self.pg0,
- self.pg0.remote_ip4,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
desired_min_tx=50000,
required_min_rx=10000,
detect_mult=1,
"""Create/Modify w/ Update BFD session parameters"""
session = VppBFDUDPSession(
self,
- self.pg0,
- self.pg0.remote_ip4,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
desired_min_tx=50000,
required_min_rx=10000,
detect_mult=1,
"""create a BFD session (SHA1)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ )
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
"""create the same BFD session twice (negative case) (SHA1)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ )
session.add_vpp_config()
with self.assertRaises(Exception):
session.add_vpp_config()
"""create BFD session using non-existent SHA1 (negative case)"""
session = VppBFDUDPSession(
self,
- self.pg0,
- self.pg0.remote_ip4,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
sha1_key=self.factory.create_random_key(self),
)
+ self.session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
with self.assertRaises(Exception):
session.add_vpp_config()
key = self.factory.create_random_key(self)
key.add_vpp_config()
sessions = [
- VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key),
VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, sha1_key=key, af=AF_INET6
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
),
- VppBFDUDPSession(self, self.pg1, self.pg1.remote_ip4, sha1_key=key),
VppBFDUDPSession(
- self, self.pg1, self.pg1.remote_ip6, sha1_key=key, af=AF_INET6
+ self,
+ self.interface0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ sha1_key=key,
+ ),
+ VppBFDUDPSession(
+ self,
+ self.interface1,
+ self.dst_ip_net2,
+ local_addr=self.src_ip_net2,
+ multihop=self.multihop,
+ sha1_key=key,
+ ),
+ VppBFDUDPSession(
+ self,
+ self.interface1,
+ self.dst_ip6_net2,
+ local_addr=self.src_ip6_net2,
+ af=AF_INET6,
+ multihop=self.multihop,
+ sha1_key=key,
),
]
for s in sessions:
"""activate SHA1 authentication"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
session.activate_auth(key)
"""deactivate SHA1 authentication"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
session.activate_auth(key)
session.deactivate_auth()
key2 = self.factory.create_random_key(self)
key1.add_vpp_config()
key2.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key1)
+ session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key1,
+ )
session.add_vpp_config()
session.activate_auth(key2)
def test_set_del_udp_echo_source(self):
"""set/del udp echo source"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
self.create_loopback_interfaces(1)
self.loopback0 = self.lo_interfaces[0]
self.loopback0.admin_up()
our_seq_number=None,
tunnel_header=None,
phy_interface=None,
+ multihop=False,
+ local_addr=None,
+ peer_addr=None,
):
self.test = test
self.af = af
self.tx_packets_echo = 0
self.rx_packets_echo = 0
+ if multihop:
+ self.sw_if_index = 0
+ BFD.udp_dport = BFD_UDP_MH_PORT
+ else:
+ BFD.udp_dport = BFD_UDP_SH_PORT
+ self.sw_if_index = self.interface.sw_if_index
+
+ if local_addr:
+ self.local_addr = local_addr
+ else:
+ if self.af == AF_INET:
+ self.local_addr = self.interface.local_ip4
+ else:
+ self.local_addr = self.interface.local_ip6
+
+ if peer_addr:
+ self.peer_addr = peer_addr
+ else:
+ if self.af == AF_INET:
+ self.peer_addr = self.interface.remote_ip4
+ else:
+ self.peer_addr = self.interface.remote_ip6
+
def inc_seq_num(self):
"""increment sequence number, wrapping if needed"""
if self.our_seq_number == 0xFFFFFFFF:
packet = (
packet
/ IPv6(
- src=self.interface.remote_ip6,
- dst=self.interface.local_ip6,
+ src=self.peer_addr,
+ dst=self.local_addr,
hlim=255,
)
/ UDP(sport=self.udp_sport, dport=BFD.udp_dport)
else:
packet = (
packet
- / IP(
- src=self.interface.remote_ip4, dst=self.interface.local_ip4, ttl=255
- )
+ / IP(src=self.peer_addr, dst=self.local_addr, ttl=255)
/ UDP(sport=self.udp_sport, dport=BFD.udp_dport)
/ bfd
)
"""Verify correctness of IP layer."""
if test.vpp_session.af == AF_INET6:
ip = packet[IPv6]
- local_ip = test.vpp_session.interface.local_ip6
- remote_ip = test.vpp_session.interface.remote_ip6
+ local_ip = test.vpp_session.local_addr
+ remote_ip = test.vpp_session.peer_addr
test.assert_equal(ip.hlim, 255, "IPv6 hop limit")
else:
ip = packet[IP]
- local_ip = test.vpp_session.interface.local_ip4
- remote_ip = test.vpp_session.interface.remote_ip4
+ local_ip = test.vpp_session.local_addr
+ remote_ip = test.vpp_session.peer_addr
test.assert_equal(ip.ttl, 255, "IPv4 TTL")
test.assert_equal(ip.src, local_ip, "IP source address")
test.assert_equal(ip.dst, remote_ip, "IP destination address")
e = event
test.logger.debug("BFD: Event: %s" % reprlib.repr(e))
test.assert_equal(
- e.sw_if_index, test.vpp_session.interface.sw_if_index, "BFD interface index"
+ e.sw_if_index, test.vpp_session._sw_if_index, "BFD interface index"
)
test.assert_equal(
return BFDStats(rx, rx_echo, tx, tx_echo)
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
@tag_fixme_debian11
class BFD4TestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD)"""
-
pg0 = None
+ interface0 = None
vpp_clock_offset = None
vpp_session = None
test_session = None
+ src_ip_net = ""
+ dst_ip_net = ""
@classmethod
def setUpClass(cls):
super(BFD4TestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = (
+ f"""""Bidirectional Forwarding Detection (BFD) - IPv4, {hoptype_str}"""
+ )
cls.vapi.cli("set log class bfd level debug")
try:
cls.create_pg_interfaces([0])
self.factory = AuthKeyFactory()
self.vapi.want_bfd_events()
self.pg0.enable_capture()
+ set_ipv4_pfx_route_info(self, self.pg0, BFD_IPV4_REMOTE_ADDR, True)
+
try:
- self.bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
- self.bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ if self.multihop:
+ self.interface0 = None
+ self.bfd_udp4_sessions = self.statistics[BFD_STATS_V4_MH_PATH]
+ self.bfd_udp6_sessions = self.statistics[BFD_STATS_V6_MH_PATH]
+ else:
+ self.interface0 = self.pg0
+ self.bfd_udp4_sessions = self.statistics[BFD_STATS_V4_SH_PATH]
+ self.bfd_udp6_sessions = self.statistics[BFD_STATS_V6_SH_PATH]
+
self.vapi.cli("trace add bfd-process 500")
- self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.vpp_session = VppBFDUDPSession(
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
- self.test_session = BFDTestSession(self, self.pg0, AF_INET)
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ )
except BaseException:
self.vapi.want_bfd_events(enable_disable=0)
raise
def test_session_up(self):
"""bring BFD session up"""
bfd_session_up(self)
- bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
- bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ if self.multihop:
+ bfd_udp4_sessions = self.statistics[BFD_STATS_V4_MH_PATH]
+ bfd_udp6_sessions = self.statistics[BFD_STATS_V6_MH_PATH]
+ else:
+ bfd_udp4_sessions = self.statistics[BFD_STATS_V4_SH_PATH]
+ bfd_udp6_sessions = self.statistics[BFD_STATS_V6_SH_PATH]
+
self.assert_equal(bfd_udp4_sessions - self.bfd_udp4_sessions, 1)
self.assert_equal(bfd_udp6_sessions, self.bfd_udp6_sessions)
"""immediately honor remote required min rx reduction"""
self.vpp_session.remove_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, desired_min_tx=10000
+ self,
+ self.interface0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ desired_min_tx=10000,
)
self.pg0.enable_capture()
self.vpp_session.add_vpp_config()
def test_echo_looped_back(self):
"""echo packets looped back"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
stats_before = bfd_grab_stats_snapshot(self)
self.pg0.enable_capture()
def test_echo(self):
"""echo function"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
stats_before = bfd_grab_stats_snapshot(self)
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
def test_echo_fail(self):
"""session goes down if echo function fails"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
self.test_session.send_packet()
def test_echo_stop(self):
"""echo function stops if peer sets required min echo rx zero"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
self.test_session.send_packet()
def test_echo_source_removed(self):
"""echo function stops if echo source is removed"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
self.test_session.send_packet()
def test_stale_echo(self):
"""stale echo packets don't keep a session up"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
self.vapi.bfd_udp_set_echo_source(sw_if_index=self.loopback0.sw_if_index)
def test_invalid_echo_checksum(self):
"""echo packets with invalid checksum don't keep a session up"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
self.vapi.bfd_udp_set_echo_source(sw_if_index=self.loopback0.sw_if_index)
intf.config_ip4()
intf.admin_up()
sw_if_index = intf.sw_if_index
- vpp_session = VppBFDUDPSession(self, intf, intf.remote_ip4)
+
+ # Setup routing info for multihop
+ set_ipv4_pfx_route_info(self, intf, BFD_IPV4_REMOTE_ADDR2, False)
+
+ vpp_session = VppBFDUDPSession(
+ self,
+ intf,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
+
vpp_session.add_vpp_config()
vpp_session.admin_up()
intf.remove_vpp_config()
- e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
- self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
- self.assertFalse(vpp_session.query_vpp_config())
+
+ # BFD session is removed only for single-hop session
+ if self.multihop:
+ self.assertTrue(vpp_session.query_vpp_config())
+ else:
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
+ self.assertFalse(vpp_session.query_vpp_config())
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
@tag_fixme_vpp_workers
class BFD6TestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (IPv6)"""
-
pg0 = None
+ interface0 = None
vpp_clock_offset = None
vpp_session = None
test_session = None
+ src_ip6_net = ""
+ dst_ip6_net = ""
@classmethod
def setUpClass(cls):
super(BFD6TestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = (
+ f"""""Bidirectional Forwarding Detection (BFD) - IPv6, {hoptype_str}"""
+ )
cls.vapi.cli("set log class bfd level debug")
try:
cls.create_pg_interfaces([0])
self.factory = AuthKeyFactory()
self.vapi.want_bfd_events()
self.pg0.enable_capture()
+ set_ipv6_pfx_route_info(self, self.pg0, BFD_IPV6_REMOTE_ADDR, True)
+
try:
- self.bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
- self.bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ if self.multihop:
+ self.interface0 = None
+ self.bfd_udp4_sessions = self.statistics[BFD_STATS_V4_MH_PATH]
+ self.bfd_udp6_sessions = self.statistics[BFD_STATS_V6_MH_PATH]
+ else:
+ self.interface0 = self.pg0
+ self.bfd_udp4_sessions = self.statistics[BFD_STATS_V4_SH_PATH]
+ self.bfd_udp6_sessions = self.statistics[BFD_STATS_V6_SH_PATH]
+
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6
+ self,
+ self.interface0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
- self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET6,
+ local_addr=self.src_ip6_net,
+ peer_addr=self.dst_ip6_net,
+ multihop=self.multihop,
+ )
self.logger.debug(self.vapi.cli("show adj nbr"))
except BaseException:
self.vapi.want_bfd_events(enable_disable=0)
raise
def tearDown(self):
+ self.vpp_session.remove_vpp_config()
if not self.vpp_dead:
self.vapi.want_bfd_events(enable_disable=0)
self.vapi.collect_events() # clear the event queue
def test_session_up(self):
"""bring BFD session up"""
bfd_session_up(self)
- bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
- bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ if self.multihop:
+ bfd_udp4_sessions = self.statistics[BFD_STATS_V4_MH_PATH]
+ bfd_udp6_sessions = self.statistics[BFD_STATS_V6_MH_PATH]
+ else:
+ bfd_udp4_sessions = self.statistics[BFD_STATS_V4_SH_PATH]
+ bfd_udp6_sessions = self.statistics[BFD_STATS_V6_SH_PATH]
+
self.assert_equal(bfd_udp4_sessions, self.bfd_udp4_sessions)
self.assert_equal(bfd_udp6_sessions - self.bfd_udp6_sessions, 1)
def test_echo_looped_back(self):
"""echo packets looped back"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
bfd_session_up(self)
stats_before = bfd_grab_stats_snapshot(self)
self.pg0.enable_capture()
def test_echo(self):
"""echo function"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
stats_before = bfd_grab_stats_snapshot(self)
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
intf.config_ip6()
intf.admin_up()
sw_if_index = intf.sw_if_index
- vpp_session = VppBFDUDPSession(self, intf, intf.remote_ip6, af=AF_INET6)
+
+ # Setup routing info for multihop
+ set_ipv6_pfx_route_info(self, intf, BFD_IPV6_REMOTE_ADDR2, False)
+
+ vpp_session = VppBFDUDPSession(
+ self,
+ intf,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ )
+
vpp_session.add_vpp_config()
vpp_session.admin_up()
intf.remove_vpp_config()
- e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
- self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
- self.assertFalse(vpp_session.query_vpp_config())
+ # BFD session is removed only for single-hop session
+ if self.multihop:
+ self.assertTrue(vpp_session.query_vpp_config())
+ else:
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
+ self.assertFalse(vpp_session.query_vpp_config())
+
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
class BFDFIBTestCase(VppTestCase):
"""BFD-FIB interactions (IPv6)"""
vpp_session = None
test_session = None
+ src_ip6_net = ""
+ dst_ip6_net = ""
@classmethod
def setUpClass(cls):
super(BFDFIBTestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = f"""""BFD-FIB interactions (IPv6) - {hoptype_str}"""
+ cls.vapi.cli("set log class bfd level debug")
@classmethod
def tearDownClass(cls):
def setUp(self):
super(BFDFIBTestCase, self).setUp()
self.create_pg_interfaces(range(1))
+ self.create_loopback_interfaces(1)
+ self.loopback0 = self.lo_interfaces[0]
+ self.loopback0.config_ip6()
+ self.loopback0.admin_up()
self.vapi.want_bfd_events()
self.pg0.enable_capture()
i.config_ip6()
i.configure_ipv6_neighbors()
+ set_ipv6_pfx_route_info(self, self.pg0, BFD_IPV6_REMOTE_ADDR, True)
+
def tearDown(self):
if not self.vpp_dead:
self.vapi.want_bfd_events(enable_disable=False)
),
]
- # A recursive and a non-recursive route via a next-hop that
- # will have a BFD session
+ # Two different routes via a next-hop that will have a BFD session.
+ # One of the routes is non-recursive route only for single-hop.
+ if self.multihop:
+ intf_index = 0xFFFFFFFF
+ else:
+ intf_index = self.pg0.sw_if_index
+
ip_2001_s_64 = VppIpRoute(
self,
"2001::",
64,
- [VppRoutePath(self.pg0.remote_ip6, self.pg0.sw_if_index)],
+ [VppRoutePath(self.dst_ip6_net, intf_index)],
)
ip_2002_s_64 = VppIpRoute(
- self, "2002::", 64, [VppRoutePath(self.pg0.remote_ip6, 0xFFFFFFFF)]
+ self, "2002::", 64, [VppRoutePath(self.dst_ip6_net, 0xFFFFFFFF)]
)
ip_2001_s_64.add_vpp_config()
ip_2002_s_64.add_vpp_config()
# bring the session up now the routes are present
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6
+ self,
+ self.pg0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
- self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET6,
+ local_addr=self.src_ip6_net,
+ peer_addr=self.dst_ip6_net,
+ multihop=self.multihop,
+ )
# session is up - traffic passes
bfd_session_up(self)
)
self.assertEqual(captured[IPv6].dst, packet[IPv6].dst)
- # session is up - traffic is dropped
+ # session is down - traffic is dropped
bfd_session_down(self)
self.pg0.add_stream(p)
bfd_session_down(self)
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
class BFDSHA1TestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (SHA1 auth)"""
-
pg0 = None
vpp_clock_offset = None
vpp_session = None
test_session = None
+ src_ip_net = ""
+ dst_ip_net = ""
@classmethod
def setUpClass(cls):
super(BFDSHA1TestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = f"""""Bidirectional Forwarding Detection (BFD) - SHA1 auth - {hoptype_str}"""
cls.vapi.cli("set log class bfd level debug")
try:
cls.create_pg_interfaces([0])
+ cls.create_loopback_interfaces(1)
+ cls.loopback0 = cls.lo_interfaces[0]
+ cls.loopback0.config_ip4()
+ cls.loopback0.admin_up()
cls.pg0.config_ip4()
+ cls.pg0.configure_ipv4_neighbors()
cls.pg0.admin_up()
cls.pg0.resolve_arp()
self.factory = AuthKeyFactory()
self.vapi.want_bfd_events()
self.pg0.enable_capture()
+ set_ipv4_pfx_route_info(self, self.pg0, BFD_IPV4_REMOTE_ADDR, True)
def tearDown(self):
if not self.vpp_dead:
key = self.factory.create_random_key(self)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
)
key = self.factory.create_random_key(self)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
)
key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
our_seq_number=0xFFFFFFFF - 4,
key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
)
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
+ )
+ rogue_test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
)
- rogue_test_session = BFDTestSession(self, self.pg0, AF_INET)
self.execute_rogue_session_scenario(
vpp_session, legitimate_test_session, rogue_test_session
)
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
# pick a different random bfd key id
x = randint(0, 255)
while x == vpp_session.bfd_key_id:
x = randint(0, 255)
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
)
rogue_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=x
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ bfd_key_id=x,
)
self.execute_rogue_session_scenario(
vpp_session, legitimate_test_session, rogue_test_session
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
)
rogue_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
)
self.execute_rogue_session_scenario(
vpp_session,
key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
our_seq_number=0,
bfd_session_up(self)
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
class BFDAuthOnOffTestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (changing auth)"""
-
pg0 = None
vpp_session = None
test_session = None
@classmethod
def setUpClass(cls):
super(BFDAuthOnOffTestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = f"""""Bidirectional Forwarding Detection (BFD) - changing auth - {hoptype_str}"""
cls.vapi.cli("set log class bfd level debug")
try:
cls.create_pg_interfaces([0])
+ cls.create_loopback_interfaces(1)
+ cls.loopback0 = cls.lo_interfaces[0]
+ cls.loopback0.config_ip4()
+ cls.loopback0.admin_up()
cls.pg0.config_ip4()
+ cls.pg0.configure_ipv4_neighbors()
cls.pg0.admin_up()
cls.pg0.resolve_arp()
self.factory = AuthKeyFactory()
self.vapi.want_bfd_events()
self.pg0.enable_capture()
+ set_ipv4_pfx_route_info(self, self.pg0, BFD_IPV4_REMOTE_ADDR, True)
def tearDown(self):
if not self.vpp_dead:
"""turn auth on without disturbing session state (immediate)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.vpp_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
self.vpp_session.add_vpp_config()
- self.test_session = BFDTestSession(self, self.pg0, AF_INET)
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
p = wait_for_bfd_packet(self)
key = self.factory.create_random_key(self)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
)
key2 = self.factory.create_random_key(self)
key2.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key1,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key1,
bfd_key_id=self.vpp_session.bfd_key_id,
)
"""turn auth on without disturbing session state (delayed)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.vpp_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
self.vpp_session.add_vpp_config()
- self.test_session = BFDTestSession(self, self.pg0, AF_INET)
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
wait_for_bfd_packet(self)
key = self.factory.create_random_key(self)
key.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
)
key2 = self.factory.create_random_key(self)
key2.add_vpp_config()
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key1,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self,
self.pg0,
AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
sha1_key=key1,
bfd_key_id=self.vpp_session.bfd_key_id,
)
self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+@parameterized_class(
+ [
+ {"multihop": False},
+ {"multihop": True},
+ ]
+)
@tag_run_solo
class BFDCLITestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (CLI)"""
@classmethod
def setUpClass(cls):
super(BFDCLITestCase, cls).setUpClass()
+ hoptype_str = "MultiHop" if cls.multihop else "SingleHop"
+ cls.__doc__ = (
+ f"""""Bidirectional Forwarding Detection (BFD) - CLI - {hoptype_str}"""
+ )
cls.vapi.cli("set log class bfd level debug")
try:
- cls.create_pg_interfaces((0,))
+ cls.create_pg_interfaces([0])
+ cls.create_loopback_interfaces(1)
+ cls.loopback0 = cls.lo_interfaces[0]
+ cls.loopback0.config_ip4()
+ cls.loopback0.config_ip6()
+ cls.loopback0.admin_up()
cls.pg0.config_ip4()
cls.pg0.config_ip6()
+ cls.pg0.configure_ipv4_neighbors()
+ cls.pg0.admin_up()
cls.pg0.resolve_arp()
cls.pg0.resolve_ndp()
super(BFDCLITestCase, self).setUp()
self.factory = AuthKeyFactory()
self.pg0.enable_capture()
+ set_ipv4_pfx_route_info(self, self.pg0, BFD_IPV4_REMOTE_ADDR, True)
+ set_ipv6_pfx_route_info(self, self.pg0, BFD_IPV6_REMOTE_ADDR, True)
+
+ if self.multihop:
+ self.cli_str = "multihop"
+ else:
+ self.cli_str = "interface %s" % self.pg0.name
def tearDown(self):
try:
self, auth_type=BFDAuthType.meticulous_keyed_sha1
)
k2.add_vpp_config()
- s1 = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ s1 = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
s1.add_vpp_config()
s2 = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k2
+ self,
+ self.pg0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ sha1_key=k2,
)
s2.add_vpp_config()
self.logger.info(self.vapi.ppcli("show bfd keys"))
)
self.assertTrue(k.query_vpp_config())
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=k
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=k,
)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET,
+ local_addr=self.src_ip_net,
+ peer_addr=self.dst_ip_net,
+ multihop=self.multihop,
+ sha1_key=k,
+ bfd_key_id=self.vpp_session.bfd_key_id,
)
self.vapi.want_bfd_events()
bfd_session_up(self)
)
self.assertTrue(k.query_vpp_config())
self.vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k
+ self,
+ self.pg0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ sha1_key=k,
)
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET6, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ self,
+ self.pg0,
+ AF_INET6,
+ local_addr=self.src_ip6_net,
+ peer_addr=self.dst_ip6_net,
+ multihop=self.multihop,
+ sha1_key=k,
+ bfd_key_id=self.vpp_session.bfd_key_id,
)
self.vapi.want_bfd_events()
bfd_session_up(self)
def test_add_mod_del_bfd_udp(self):
"""create/modify/delete IPv4 BFD UDP session"""
- vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ vpp_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
self.registry.register(vpp_session, self.logger)
cli_add_cmd = (
- "bfd udp session add interface %s local-addr %s "
+ "bfd udp session add %s local-addr %s "
"peer-addr %s desired-min-tx %s required-min-rx %s "
"detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
vpp_session.desired_min_tx,
vpp_session.required_min_rx,
vpp_session.detect_mult,
" failed, rv=-101:Duplicate BFD object",
)
verify_bfd_session_config(self, vpp_session)
+
mod_session = VppBFDUDPSession(
self,
self.pg0,
- self.pg0.remote_ip4,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
detect_mult=4 * vpp_session.detect_mult,
)
self.cli_verify_no_response(
- "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "bfd udp session mod %s local-addr %s peer-addr %s "
"desired-min-tx %s required-min-rx %s detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
mod_session.desired_min_tx,
mod_session.required_min_rx,
mod_session.detect_mult,
)
)
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = (
- "bfd udp session del interface %s local-addr %s "
- "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_del_cmd = "bfd udp session del %s local-addr %s peer-addr %s" % (
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
)
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
)
self.assertFalse(vpp_session.query_vpp_config())
+ if self.multihop:
+ # specifying multihop and interface should fail
+ cli_add_cmd = (
+ "bfd udp session add multihop interface %s local-addr 1.1.1.1 "
+ "peer-addr 2.2.2.2 desired-min-tx 50000 required-min-rx 1000 "
+ "detect-mult 3" % (self.pg0.name)
+ )
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: Incompatible parameter combination, "
+ "interface cannot be specified when multihop is enabled",
+ )
+ cli_mod_cmd = (
+ "bfd udp session mod multihop interface %s local-addr 1.1.1.1 "
+ "peer-addr 2.2.2.2 desired-min-tx 50000 required-min-rx 1000 "
+ "detect-mult 3" % (self.pg0.name)
+ )
+ self.cli_verify_response(
+ cli_mod_cmd,
+ "bfd udp session mod: Incompatible parameter combination, "
+ "interface cannot be specified when multihop is enabled",
+ )
+ cli_del_cmd = (
+ "bfd udp session del multihop interface %s local-addr 1.1.1.1 "
+ "peer-addr 2.2.2.2" % (self.pg0.name)
+ )
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: Incompatible parameter combination, "
+ "interface cannot be specified when multihop is enabled",
+ )
+
+ # Not specifying multihop or interface should fail
+ cli_add_cmd = (
+ "bfd udp session add local-addr 1.1.1.1 peer-addr 2.2.2.2 "
+ "desired-min-tx 50000 required-min-rx 1000 detect-mult 3"
+ )
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: Incompatible parameter combination, "
+ "interface must be set if not multihop",
+ )
+ cli_mod_cmd = (
+ "bfd udp session mod local-addr 1.1.1.1 peer-addr 2.2.2.2 "
+ "desired-min-tx 50000 required-min-rx 1000 detect-mult 3"
+ )
+ self.cli_verify_response(
+ cli_mod_cmd,
+ "bfd udp session mod: Incompatible parameter combination, "
+ "interface must be set if not multihop",
+ )
+ cli_del_cmd = "bfd udp session del local-addr 1.1.1.1 peer-addr 2.2.2.2 "
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: Incompatible parameter combination, "
+ "interface must be set if not multihop",
+ )
+
def test_add_mod_del_bfd_udp6(self):
"""create/modify/delete IPv6 BFD UDP session"""
- vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
+ vpp_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ )
self.registry.register(vpp_session, self.logger)
cli_add_cmd = (
- "bfd udp session add interface %s local-addr %s "
+ "bfd udp session add %s local-addr %s "
"peer-addr %s desired-min-tx %s required-min-rx %s "
"detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip6,
- self.pg0.remote_ip6,
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
vpp_session.desired_min_tx,
vpp_session.required_min_rx,
vpp_session.detect_mult,
mod_session = VppBFDUDPSession(
self,
self.pg0,
- self.pg0.remote_ip6,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
af=AF_INET6,
+ multihop=self.multihop,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
detect_mult=4 * vpp_session.detect_mult,
)
self.cli_verify_no_response(
- "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "bfd udp session mod %s local-addr %s peer-addr %s "
"desired-min-tx %s required-min-rx %s detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip6,
- self.pg0.remote_ip6,
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
mod_session.desired_min_tx,
mod_session.required_min_rx,
mod_session.detect_mult,
)
)
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = (
- "bfd udp session del interface %s local-addr %s "
- "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ cli_del_cmd = "bfd udp session del %s local-addr %s peer-addr %s" % (
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
)
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.registry.register(vpp_session, self.logger)
cli_add_cmd = (
- "bfd udp session add interface %s local-addr %s "
+ "bfd udp session add %s local-addr %s "
"peer-addr %s desired-min-tx %s required-min-rx %s "
"detect-mult %s conf-key-id %s bfd-key-id %s"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
vpp_session.desired_min_tx,
vpp_session.required_min_rx,
vpp_session.detect_mult,
mod_session = VppBFDUDPSession(
self,
self.pg0,
- self.pg0.remote_ip4,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=vpp_session.bfd_key_id,
required_min_rx=2 * vpp_session.required_min_rx,
detect_mult=4 * vpp_session.detect_mult,
)
self.cli_verify_no_response(
- "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "bfd udp session mod %s local-addr %s peer-addr %s "
"desired-min-tx %s required-min-rx %s detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
mod_session.desired_min_tx,
mod_session.required_min_rx,
mod_session.detect_mult,
)
)
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = (
- "bfd udp session del interface %s local-addr %s "
- "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_del_cmd = "bfd udp session del %s local-addr %s peer-addr %s" % (
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
)
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
+ af=AF_INET6,
+ multihop=self.multihop,
+ sha1_key=key,
)
self.registry.register(vpp_session, self.logger)
cli_add_cmd = (
- "bfd udp session add interface %s local-addr %s "
+ "bfd udp session add %s local-addr %s "
"peer-addr %s desired-min-tx %s required-min-rx %s "
"detect-mult %s conf-key-id %s bfd-key-id %s"
% (
- self.pg0.name,
- self.pg0.local_ip6,
- self.pg0.remote_ip6,
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
vpp_session.desired_min_tx,
vpp_session.required_min_rx,
vpp_session.detect_mult,
mod_session = VppBFDUDPSession(
self,
self.pg0,
- self.pg0.remote_ip6,
+ self.dst_ip6_net,
+ local_addr=self.src_ip6_net,
af=AF_INET6,
+ multihop=self.multihop,
sha1_key=key,
bfd_key_id=vpp_session.bfd_key_id,
required_min_rx=2 * vpp_session.required_min_rx,
detect_mult=4 * vpp_session.detect_mult,
)
self.cli_verify_no_response(
- "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "bfd udp session mod %s local-addr %s peer-addr %s "
"desired-min-tx %s required-min-rx %s detect-mult %s"
% (
- self.pg0.name,
- self.pg0.local_ip6,
- self.pg0.remote_ip6,
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
mod_session.desired_min_tx,
mod_session.required_min_rx,
mod_session.detect_mult,
)
)
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = (
- "bfd udp session del interface %s local-addr %s "
- "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ cli_del_cmd = "bfd udp session del %s local-addr %s peer-addr %s" % (
+ self.cli_str,
+ self.src_ip6_net,
+ self.dst_ip6_net,
)
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
self, auth_type=BFDAuthType.meticulous_keyed_sha1
)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
auth_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
session.add_vpp_config()
cli_activate = (
- "bfd udp session auth activate interface %s local-addr %s "
+ "bfd udp session auth activate %s local-addr %s "
"peer-addr %s conf-key-id %s bfd-key-id %s"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
key.conf_key_id,
auth_session.bfd_key_id,
)
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
cli_deactivate = (
- "bfd udp session auth deactivate interface %s local-addr %s "
- "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ "bfd udp session auth deactivate %s local-addr %s "
+ "peer-addr %s" % (self.cli_str, self.src_ip_net, self.dst_ip_net)
)
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
+ if self.multihop:
+ # specifying multihop and interface should fail
+ cli_activate = (
+ "bfd udp session auth activate multihop interface %s "
+ "local-addr %s peer-addr %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.src_ip_net,
+ self.dst_ip_net,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_response(
+ cli_activate,
+ "bfd udp session auth activate: Incompatible parameter "
+ "combination, interface cannot be specified when multihop "
+ "is enabled",
+ )
+ cli_deactivate = (
+ "bfd udp session auth deactivate multihop interface %s "
+ "local-addr %s peer-addr %s"
+ % (
+ self.pg0.name,
+ self.src_ip_net,
+ self.dst_ip_net,
+ )
+ )
+ self.cli_verify_response(
+ cli_deactivate,
+ "bfd udp session auth deactivate: Incompatible parameter "
+ "combination, interface cannot be specified when multihop "
+ "is enabled",
+ )
+ # Not specifying multihop or interface should fail
+ cli_activate = (
+ "bfd udp session auth activate local-addr %s peer-addr %s "
+ "conf-key-id %s bfd-key-id %s"
+ % (
+ self.src_ip_net,
+ self.dst_ip_net,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_response(
+ cli_activate,
+ "bfd udp session auth activate: Incompatible parameter "
+ "combination, interface must be set if not multihop",
+ )
+ cli_deactivate = (
+ "bfd udp session auth deactivate local-addr %s peer-addr %s "
+ % (
+ self.src_ip_net,
+ self.dst_ip_net,
+ )
+ )
+ self.cli_verify_response(
+ cli_deactivate,
+ "bfd udp session auth deactivate: Incompatible parameter "
+ "combination, interface must be set if not multihop",
+ )
+
def test_auth_on_off_delayed(self):
"""turn authentication on and off (delayed)"""
key = self.factory.create_random_key(
self, auth_type=BFDAuthType.meticulous_keyed_sha1
)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
auth_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ sha1_key=key,
)
session.add_vpp_config()
cli_activate = (
- "bfd udp session auth activate interface %s local-addr %s "
+ "bfd udp session auth activate %s local-addr %s "
"peer-addr %s conf-key-id %s bfd-key-id %s delayed yes"
% (
- self.pg0.name,
- self.pg0.local_ip4,
- self.pg0.remote_ip4,
+ self.cli_str,
+ self.src_ip_net,
+ self.dst_ip_net,
key.conf_key_id,
auth_session.bfd_key_id,
)
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
cli_deactivate = (
- "bfd udp session auth deactivate interface %s local-addr %s "
+ "bfd udp session auth deactivate %s local-addr %s "
"peer-addr %s delayed yes"
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ % (self.cli_str, self.src_ip_net, self.dst_ip_net)
)
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
def test_admin_up_down(self):
"""put session admin-up and admin-down"""
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.dst_ip_net,
+ local_addr=self.src_ip_net,
+ multihop=self.multihop,
+ )
session.add_vpp_config()
cli_down = (
- "bfd udp session set-flags admin down interface %s local-addr %s "
- "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ "bfd udp session set-flags admin down %s local-addr %s "
+ "peer-addr %s " % (self.cli_str, self.src_ip_net, self.dst_ip_net)
)
cli_up = (
- "bfd udp session set-flags admin up interface %s local-addr %s "
- "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ "bfd udp session set-flags admin up %s local-addr %s "
+ "peer-addr %s " % (self.cli_str, self.src_ip_net, self.dst_ip_net)
)
self.cli_verify_no_response(cli_down)
verify_bfd_session_config(self, session, state=BFDState.admin_down)
self.cli_verify_no_response(cli_up)
verify_bfd_session_config(self, session, state=BFDState.down)
+ if self.multihop:
+ # specifying multihop and interface should fail
+ cli_up = (
+ "bfd udp session set-flags admin up multihop interface %s "
+ "local-addr %s peer-addr %s"
+ % (
+ self.pg0.name,
+ self.src_ip_net,
+ self.dst_ip_net,
+ )
+ )
+ self.cli_verify_response(
+ cli_up,
+ "bfd udp session set-flags: Incompatible parameter "
+ "combination, interface cannot be specified when multihop "
+ "is enabled",
+ )
+ # Not specifying multihop or interface should fail
+ cli_up = (
+ "bfd udp session set-flags admin up local-addr %s peer-addr %s "
+ % (
+ self.src_ip_net,
+ self.dst_ip_net,
+ )
+ )
+ self.cli_verify_response(
+ cli_up,
+ "bfd udp session set-flags: Incompatible parameter "
+ "combination, interface must be set if not multihop",
+ )
+
def test_set_del_udp_echo_source(self):
"""set/del udp echo source"""
+
+ if self.multihop:
+ self.skipTest(
+ f"Skipping because echo functionality is not supported with multihop"
+ )
+
self.create_loopback_interfaces(1)
self.loopback0 = self.lo_interfaces[0]
self.loopback0.admin_up()
Code Review / vpp.git / commitdiff