#include <vnet/span/span.h>
#include <vnet/policer/policer.h>
#include <vnet/policer/police.h>
+#include <vnet/mfib/mfib_types.h>
#include "vat/json_format.h"
#include <vpp/api/vpe_all_api_h.h>
#undef vl_printfun
+#define __plugin_msg_base 0
+#include <vlibapi/vat_helper_macros.h>
+
+f64
+vat_time_now (vat_main_t * vam)
+{
+#if VPP_API_TEST_BUILTIN
+ return vlib_time_now (vam->vlib_main);
+#else
+ return clib_time_now (&vam->clib_time);
+#endif
+}
+
+void
+errmsg (char *fmt, ...)
+{
+ vat_main_t *vam = &vat_main;
+ va_list va;
+ u8 *s;
+
+ va_start (va, fmt);
+ s = va_format (0, fmt, &va);
+ va_end (va);
+
+ vec_add1 (s, 0);
+
+#if VPP_API_TEST_BUILTIN
+ vlib_cli_output (vam->vlib_main, (char *) s);
+#else
+ {
+ if (vam->ifp != stdin)
+ fformat (vam->ofp, "%s(%d): \n", vam->current_file,
+ vam->input_line_number);
+ fformat (vam->ofp, (char *) s);
+ fflush (vam->ofp);
+ }
+#endif
+
+ vec_free (s);
+}
+
static uword
api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
{
return 1;
}
-void vat_suspend (vlib_main_t * vm, f64 interval);
-
#if VPP_API_TEST_BUILTIN == 0
/* Parse an IP4 address %d.%d.%d.%d. */
uword
return 1;
}
+static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
+static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
+static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
+static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
+
+uword
+unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
+{
+ mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
+ mfib_itf_attribute_t attr;
+
+ old = *iflags;
+ FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
+ {
+ if (unformat (input, mfib_itf_flag_long_names[attr]))
+ *iflags |= (1 << attr);
+ }
+ FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
+ {
+ if (unformat (input, mfib_itf_flag_names[attr]))
+ *iflags |= (1 << attr);
+ }
+
+ return (old == *iflags ? 0 : 1);
+}
+
+uword
+unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
+{
+ mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
+ mfib_entry_attribute_t attr;
+
+ old = *eflags;
+ FOR_EACH_MFIB_ATTRIBUTE (attr)
+ {
+ if (unformat (input, mfib_flag_long_names[attr]))
+ *eflags |= (1 << attr);
+ }
+ FOR_EACH_MFIB_ATTRIBUTE (attr)
+ {
+ if (unformat (input, mfib_flag_names[attr]))
+ *eflags |= (1 << attr);
+ }
+
+ return (old == *eflags ? 0 : 1);
+}
+
#if (VPP_API_TEST_BUILTIN==0)
u8 *
format_ip4_address (u8 * s, va_list * args)
}
}
+static void vl_api_vnet_ip4_nbr_counters_t_handler
+ (vl_api_vnet_ip4_nbr_counters_t * mp)
+{
+ /* not supported */
+}
+
+static void vl_api_vnet_ip4_nbr_counters_t_handler_json
+ (vl_api_vnet_ip4_nbr_counters_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ vl_api_ip4_nbr_counter_t *v;
+ ip4_nbr_counter_t *counter;
+ u32 sw_if_index;
+ u32 count;
+ int i;
+
+ sw_if_index = ntohl (mp->sw_if_index);
+ count = ntohl (mp->count);
+ vec_validate (vam->ip4_nbr_counters, sw_if_index);
+
+ if (mp->begin)
+ vec_free (vam->ip4_nbr_counters[sw_if_index]);
+
+ v = (vl_api_ip4_nbr_counter_t *) & mp->c;
+ for (i = 0; i < count; i++)
+ {
+ vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
+ counter = &vam->ip4_nbr_counters[sw_if_index][i];
+ counter->address.s_addr = v->address;
+ counter->packets = clib_net_to_host_u64 (v->packets);
+ counter->bytes = clib_net_to_host_u64 (v->bytes);
+ counter->linkt = v->link_type;
+ v++;
+ }
+}
+
static void vl_api_vnet_ip6_fib_counters_t_handler
(vl_api_vnet_ip6_fib_counters_t * mp)
{
}
}
+static void vl_api_vnet_ip6_nbr_counters_t_handler
+ (vl_api_vnet_ip6_nbr_counters_t * mp)
+{
+ /* not supported */
+}
+
+static void vl_api_vnet_ip6_nbr_counters_t_handler_json
+ (vl_api_vnet_ip6_nbr_counters_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ vl_api_ip6_nbr_counter_t *v;
+ ip6_nbr_counter_t *counter;
+ struct in6_addr ip6;
+ u32 sw_if_index;
+ u32 count;
+ int i;
+
+ sw_if_index = ntohl (mp->sw_if_index);
+ count = ntohl (mp->count);
+ vec_validate (vam->ip6_nbr_counters, sw_if_index);
+
+ if (mp->begin)
+ vec_free (vam->ip6_nbr_counters[sw_if_index]);
+
+ v = (vl_api_ip6_nbr_counter_t *) & mp->c;
+ for (i = 0; i < count; i++)
+ {
+ vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
+ counter = &vam->ip6_nbr_counters[sw_if_index][i];
+ clib_memcpy (&ip6, &v->address, sizeof (ip6));
+ counter->address = ip6;
+ counter->packets = clib_net_to_host_u64 (v->packets);
+ counter->bytes = clib_net_to_host_u64 (v->bytes);
+ v++;
+ }
+}
+
static void vl_api_get_first_msg_id_reply_t_handler
(vl_api_get_first_msg_id_reply_t * mp)
{
vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
}
-static u8 *
-format_decap_next (u8 * s, va_list * args)
-{
- u32 next_index = va_arg (*args, u32);
-
- switch (next_index)
- {
- case LISP_GPE_INPUT_NEXT_DROP:
- return format (s, "drop");
- case LISP_GPE_INPUT_NEXT_IP4_INPUT:
- return format (s, "ip4");
- case LISP_GPE_INPUT_NEXT_IP6_INPUT:
- return format (s, "ip6");
- default:
- return format (s, "unknown %d", next_index);
- }
- return s;
-}
-
-static void
-vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
- mp)
-{
- vat_main_t *vam = &vat_main;
- u8 *iid_str;
- u8 *flag_str = NULL;
-
- iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
-
-#define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
- foreach_lisp_gpe_flag_bit;
-#undef _
-
- print (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
- "%=16d%=16d%=16sd=16d%=16s%=16s",
- mp->tunnels,
- mp->is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->source_ip,
- mp->is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->destination_ip,
- ntohl (mp->encap_fib_id),
- ntohl (mp->decap_fib_id),
- format_decap_next, ntohl (mp->dcap_next),
- mp->ver_res >> 6,
- flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
-
- vec_free (iid_str);
-}
-
-static void
- vl_api_lisp_gpe_tunnel_details_t_handler_json
- (vl_api_lisp_gpe_tunnel_details_t * mp)
-{
- vat_main_t *vam = &vat_main;
- vat_json_node_t *node = NULL;
- struct in6_addr ip6;
- struct in_addr ip4;
- u8 *next_decap_str;
-
- next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
-
- if (VAT_JSON_ARRAY != vam->json_tree.type)
- {
- ASSERT (VAT_JSON_NONE == vam->json_tree.type);
- vat_json_init_array (&vam->json_tree);
- }
- node = vat_json_array_add (&vam->json_tree);
-
- vat_json_init_object (node);
- vat_json_object_add_uint (node, "tunel", mp->tunnels);
- if (mp->is_ipv6)
- {
- clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
- vat_json_object_add_ip6 (node, "source address", ip6);
- clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
- vat_json_object_add_ip6 (node, "destination address", ip6);
- }
- else
- {
- clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
- vat_json_object_add_ip4 (node, "source address", ip4);
- clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
- vat_json_object_add_ip4 (node, "destination address", ip4);
- }
- vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
- vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
- vat_json_object_add_string_copy (node, "decap next", next_decap_str);
- vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
- vat_json_object_add_uint (node, "flags", mp->flags);
- vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
- vat_json_object_add_uint (node, "ver_res", mp->ver_res);
- vat_json_object_add_uint (node, "res", mp->res);
- vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
-
- vec_free (next_decap_str);
-}
-
static void
vl_api_show_lisp_map_register_state_reply_t_handler
(vl_api_show_lisp_map_register_state_reply_t * mp)
vec_free (s);
}
+static void
+api_lisp_gpe_fwd_entry_net_to_host (vl_api_lisp_gpe_fwd_entry_t * e)
+{
+ e->dp_table = clib_net_to_host_u32 (e->dp_table);
+ e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
+}
+
+static void
+ lisp_gpe_fwd_entries_get_reply_t_net_to_host
+ (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
+{
+ u32 i;
+
+ mp->count = clib_net_to_host_u32 (mp->count);
+ for (i = 0; i < mp->count; i++)
+ {
+ api_lisp_gpe_fwd_entry_net_to_host (&mp->entries[i]);
+ }
+}
+
+static void
+ vl_api_lisp_gpe_fwd_entry_path_details_t_handler
+ (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
+
+ if (mp->lcl_loc.is_ip4)
+ format_ip_address_fcn = format_ip4_address;
+ else
+ format_ip_address_fcn = format_ip6_address;
+
+ print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
+ format_ip_address_fcn, &mp->lcl_loc,
+ format_ip_address_fcn, &mp->rmt_loc);
+}
+
+static void
+lisp_fill_locator_node (vat_json_node_t * n, vl_api_lisp_gpe_locator_t * loc)
+{
+ struct in6_addr ip6;
+ struct in_addr ip4;
+
+ if (loc->is_ip4)
+ {
+ clib_memcpy (&ip4, loc->addr, sizeof (ip4));
+ vat_json_object_add_ip4 (n, "address", ip4);
+ }
+ else
+ {
+ clib_memcpy (&ip6, loc->addr, sizeof (ip6));
+ vat_json_object_add_ip6 (n, "address", ip6);
+ }
+ vat_json_object_add_uint (n, "weight", loc->weight);
+}
+
+static void
+ vl_api_lisp_gpe_fwd_entry_path_details_t_handler_json
+ (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ vat_json_node_t *node = NULL;
+ vat_json_node_t *loc_node;
+
+ if (VAT_JSON_ARRAY != vam->json_tree.type)
+ {
+ ASSERT (VAT_JSON_NONE == vam->json_tree.type);
+ vat_json_init_array (&vam->json_tree);
+ }
+ node = vat_json_array_add (&vam->json_tree);
+ vat_json_init_object (node);
+
+ loc_node = vat_json_object_add (node, "local_locator");
+ vat_json_init_object (loc_node);
+ lisp_fill_locator_node (loc_node, &mp->lcl_loc);
+
+ loc_node = vat_json_object_add (node, "remote_locator");
+ vat_json_init_object (loc_node);
+ lisp_fill_locator_node (loc_node, &mp->rmt_loc);
+}
+
+static void
+ vl_api_lisp_gpe_fwd_entries_get_reply_t_handler
+ (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ u32 i;
+ int retval = clib_net_to_host_u32 (mp->retval);
+ vl_api_lisp_gpe_fwd_entry_t *e;
+
+ if (retval)
+ goto end;
+
+ lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
+
+ for (i = 0; i < mp->count; i++)
+ {
+ e = &mp->entries[i];
+ print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
+ format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
+ format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
+ }
+
+end:
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
+static void
+ vl_api_lisp_gpe_fwd_entries_get_reply_t_handler_json
+ (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
+{
+ u8 *s = 0;
+ vat_main_t *vam = &vat_main;
+ vat_json_node_t *e = 0, root;
+ u32 i;
+ int retval = clib_net_to_host_u32 (mp->retval);
+ vl_api_lisp_gpe_fwd_entry_t *fwd;
+
+ if (retval)
+ goto end;
+
+ lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
+ vat_json_init_array (&root);
+
+ for (i = 0; i < mp->count; i++)
+ {
+ e = vat_json_array_add (&root);
+ fwd = &mp->entries[i];
+
+ vat_json_init_object (e);
+ vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
+ vat_json_object_add_int (e, "dp_table", fwd->dp_table);
+
+ s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
+ fwd->leid_prefix_len);
+ vec_add1 (s, 0);
+ vat_json_object_add_string_copy (e, "leid", s);
+ vec_free (s);
+
+ s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
+ fwd->reid_prefix_len);
+ vec_add1 (s, 0);
+ vat_json_object_add_string_copy (e, "reid", s);
+ vec_free (s);
+ }
+
+ vat_json_print (vam->ofp, &root);
+ vat_json_free (&root);
+
+end:
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
static void
vl_api_lisp_adjacencies_get_reply_t_handler
(vl_api_lisp_adjacencies_get_reply_t * mp)
#define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
#define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
#define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
+#define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
+#define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
+#define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
+#define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
#define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
#define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
_(sw_interface_set_vpath_reply) \
_(sw_interface_set_vxlan_bypass_reply) \
_(sw_interface_set_l2_bridge_reply) \
-_(sw_interface_set_dpdk_hqos_pipe_reply) \
-_(sw_interface_set_dpdk_hqos_subport_reply) \
-_(sw_interface_set_dpdk_hqos_tctbl_reply) \
_(bridge_domain_add_del_reply) \
_(sw_interface_set_l2_xconnect_reply) \
_(l2fib_add_del_reply) \
_(ip_add_del_route_reply) \
+_(ip_mroute_add_del_reply) \
_(mpls_route_add_del_reply) \
_(mpls_ip_bind_unbind_reply) \
_(proxy_arp_add_del_reply) \
_(sw_interface_tag_add_del_reply) \
_(sw_interface_set_mtu_reply)
+#if DPDK > 0
+#define foreach_standard_dpdk_reply_retval_handler \
+_(sw_interface_set_dpdk_hqos_pipe_reply) \
+_(sw_interface_set_dpdk_hqos_subport_reply) \
+_(sw_interface_set_dpdk_hqos_tctbl_reply)
+#endif
+
#define _(n) \
static void vl_api_##n##_t_handler \
(vl_api_##n##_t * mp) \
foreach_standard_reply_retval_handler;
#undef _
+#if DPDK > 0
+#define _(n) \
+ static void vl_api_##n##_t_handler \
+ (vl_api_##n##_t * mp) \
+ { \
+ vat_main_t * vam = &vat_main; \
+ i32 retval = ntohl(mp->retval); \
+ if (vam->async_mode) { \
+ vam->async_errors += (retval < 0); \
+ } else { \
+ vam->retval = retval; \
+ vam->result_ready = 1; \
+ } \
+ }
+foreach_standard_dpdk_reply_retval_handler;
+#undef _
+
+#define _(n) \
+ static void vl_api_##n##_t_handler_json \
+ (vl_api_##n##_t * mp) \
+ { \
+ vat_main_t * vam = &vat_main; \
+ vat_json_node_t node; \
+ vat_json_init_object(&node); \
+ vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
+ vat_json_print(vam->ofp, &node); \
+ vam->retval = ntohl(mp->retval); \
+ vam->result_ready = 1; \
+ }
+foreach_standard_dpdk_reply_retval_handler;
+#undef _
+#endif
+
/*
* Table of message reply handlers, must include boilerplate handlers
* we just generated
sw_interface_set_l2_xconnect_reply) \
_(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
sw_interface_set_l2_bridge_reply) \
-_(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
- sw_interface_set_dpdk_hqos_pipe_reply) \
-_(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
- sw_interface_set_dpdk_hqos_subport_reply) \
-_(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
- sw_interface_set_dpdk_hqos_tctbl_reply) \
_(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
_(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
_(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
_(TAP_DELETE_REPLY, tap_delete_reply) \
_(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
_(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
+_(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
_(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
_(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
_(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
_(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
_(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
_(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
+_(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
+_(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
_(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
_(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
_(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
_(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
_(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
_(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
-_(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
_(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
_(LISP_MAP_SERVER_DETAILS, lisp_map_server_details) \
_(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
+_(LISP_GPE_FWD_ENTRIES_GET_REPLY, lisp_gpe_fwd_entries_get_reply) \
+_(LISP_GPE_FWD_ENTRY_PATH_DETAILS, \
+ lisp_gpe_fwd_entry_path_details) \
_(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
_(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
lisp_add_del_map_request_itr_rlocs_reply) \
_(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
_(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
-/* M: construct, but don't yet send a message */
-
-#define M(T,t) \
-do { \
- vam->result_ready = 0; \
- mp = vl_msg_api_alloc_as_if_client(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
- mp->_vl_msg_id = ntohs (VL_API_##T); \
- mp->client_index = vam->my_client_index; \
-} while(0);
-
-#define M2(T,t,n) \
-do { \
- vam->result_ready = 0; \
- mp = vl_msg_api_alloc_as_if_client(sizeof(*mp)+(n)); \
- memset (mp, 0, sizeof (*mp)); \
- mp->_vl_msg_id = ntohs (VL_API_##T); \
- mp->client_index = vam->my_client_index; \
-} while(0);
-
-
-/* S: send a message */
-#define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
-
-/* W: wait for results, with timeout */
-#define W \
-do { \
- timeout = vat_time_now (vam) + 1.0; \
- \
- while (vat_time_now (vam) < timeout) { \
- if (vam->result_ready == 1) { \
- return (vam->retval); \
- } \
- vat_suspend (vam->vlib_main, 1e-3); \
- } \
- return -99; \
-} while(0);
-
-/* W2: wait for results, with timeout */
-#define W2(body) \
-do { \
- timeout = vat_time_now (vam) + 1.0; \
- \
- while (vat_time_now (vam) < timeout) { \
- if (vam->result_ready == 1) { \
- (body); \
- return (vam->retval); \
- } \
- vat_suspend (vam->vlib_main, 1e-3); \
- } \
- return -99; \
-} while(0);
+#if DPDK > 0
+#define foreach_vpe_dpdk_api_reply_msg \
+_(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
+ sw_interface_set_dpdk_hqos_pipe_reply) \
+_(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
+ sw_interface_set_dpdk_hqos_subport_reply) \
+_(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
+ sw_interface_set_dpdk_hqos_tctbl_reply)
+#endif
typedef struct
{
u64 packets;
ip4_fib_counter_t *c4;
ip6_fib_counter_t *c6;
+ ip4_nbr_counter_t *n4;
+ ip6_nbr_counter_t *n6;
int i, j;
if (!vam->json_output)
}
}
- /* ip6 fib counters */
- msg_array = vat_json_object_add (&node, "ip6_fib_counters");
+ /* ip6 fib counters */
+ msg_array = vat_json_object_add (&node, "ip6_fib_counters");
+ vat_json_init_array (msg_array);
+ for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
+ {
+ msg = vat_json_array_add (msg_array);
+ vat_json_init_object (msg);
+ vat_json_object_add_uint (msg, "vrf_id",
+ vam->ip6_fib_counters_vrf_id_by_index[i]);
+ counter_array = vat_json_object_add (msg, "c");
+ vat_json_init_array (counter_array);
+ for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
+ {
+ counter = vat_json_array_add (counter_array);
+ vat_json_init_object (counter);
+ c6 = &vam->ip6_fib_counters[i][j];
+ vat_json_object_add_ip6 (counter, "address", c6->address);
+ vat_json_object_add_uint (counter, "address_length",
+ c6->address_length);
+ vat_json_object_add_uint (counter, "packets", c6->packets);
+ vat_json_object_add_uint (counter, "bytes", c6->bytes);
+ }
+ }
+
+ /* ip4 nbr counters */
+ msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
+ vat_json_init_array (msg_array);
+ for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
+ {
+ msg = vat_json_array_add (msg_array);
+ vat_json_init_object (msg);
+ vat_json_object_add_uint (msg, "sw_if_index", i);
+ counter_array = vat_json_object_add (msg, "c");
+ vat_json_init_array (counter_array);
+ for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
+ {
+ counter = vat_json_array_add (counter_array);
+ vat_json_init_object (counter);
+ n4 = &vam->ip4_nbr_counters[i][j];
+ vat_json_object_add_ip4 (counter, "address", n4->address);
+ vat_json_object_add_uint (counter, "link-type", n4->linkt);
+ vat_json_object_add_uint (counter, "packets", n4->packets);
+ vat_json_object_add_uint (counter, "bytes", n4->bytes);
+ }
+ }
+
+ /* ip6 nbr counters */
+ msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
vat_json_init_array (msg_array);
- for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
+ for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
{
msg = vat_json_array_add (msg_array);
vat_json_init_object (msg);
- vat_json_object_add_uint (msg, "vrf_id",
- vam->ip6_fib_counters_vrf_id_by_index[i]);
+ vat_json_object_add_uint (msg, "sw_if_index", i);
counter_array = vat_json_object_add (msg, "c");
vat_json_init_array (counter_array);
- for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
+ for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
{
counter = vat_json_array_add (counter_array);
vat_json_init_object (counter);
- c6 = &vam->ip6_fib_counters[i][j];
- vat_json_object_add_ip6 (counter, "address", c6->address);
- vat_json_object_add_uint (counter, "address_length",
- c6->address_length);
- vat_json_object_add_uint (counter, "packets", c6->packets);
- vat_json_object_add_uint (counter, "bytes", c6->bytes);
+ n6 = &vam->ip6_nbr_counters[i][j];
+ vat_json_object_add_ip6 (counter, "address", n6->address);
+ vat_json_object_add_uint (counter, "packets", n6->packets);
+ vat_json_object_add_uint (counter, "bytes", n6->bytes);
}
}
}
- M (CLI_REQUEST, cli_request);
+ M (CLI_REQUEST, mp);
/*
* Copy cmd into shared memory.
* in \n\0.
*/
u32 len = vec_len (vam->input->buffer);
- M2 (CLI_INBAND, cli_inband, len);
+ M2 (CLI_INBAND, mp, len);
clib_memcpy (mp->cmd, vam->input->buffer, len);
mp->length = htonl (len);
}
/* Construct the API message */
- M (CREATE_LOOPBACK, create_loopback);
+ M (CREATE_LOOPBACK, mp);
if (mac_set)
clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
}
/* Construct the API message */
- M (DELETE_LOOPBACK, delete_loopback);
+ M (DELETE_LOOPBACK, mp);
mp->sw_if_index = ntohl (sw_if_index);
S;
return -99;
}
- M (WANT_STATS, want_stats);
+ M (WANT_STATS, mp);
mp->enable_disable = enable;
S;
return -99;
}
- M (WANT_INTERFACE_EVENTS, want_interface_events);
+ M (WANT_INTERFACE_EVENTS, mp);
mp->enable_disable = enable;
vam->interface_event_display = enable;
vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
/* Get list of ethernets */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
S;
/* and local / loopback interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
S;
/* and packet-generator interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
S;
/* and vxlan-gpe tunnel interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "vxlan_gpe",
sizeof (mp->name_filter) - 1);
S;
/* and vxlan tunnel interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
S;
/* and host (af_packet) interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
S;
/* and l2tpv3 tunnel interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
sizeof (mp->name_filter) - 1);
S;
/* and GRE tunnel interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
S;
/* and LISP-GPE interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "lisp_gpe",
sizeof (mp->name_filter) - 1);
S;
/* and IPSEC tunnel interfaces */
- M (SW_INTERFACE_DUMP, sw_interface_dump);
+ M (SW_INTERFACE_DUMP, mp);
mp->name_filter_valid = 1;
strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
/* Construct the API message */
- M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
+ M (SW_INTERFACE_SET_FLAGS, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->admin_up_down = admin_up;
mp->link_up_down = link_up;
}
/* Construct the API message */
- M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
+ M (SW_INTERFACE_CLEAR_STATS, mp);
if (sw_if_index_set == 1)
mp->sw_if_index = ntohl (sw_if_index);
W;
}
+#if DPDK >0
static int
api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
{
return -99;
}
- M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
+ M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->subport = ntohl (subport);
return -99;
}
- M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
+ M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->subport = ntohl (subport);
return -99;
}
- M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
+ M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->entry = ntohl (entry);
/* NOTREACHED */
return 0;
}
+#endif
static int
api_sw_interface_add_del_address (vat_main_t * vam)
}
/* Construct the API message */
- M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
+ M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_add = is_add;
}
/* Construct the API message */
- M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable);
+ M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = enable;
}
/* Construct the API message */
- M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
+ M (SW_INTERFACE_SET_TABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_ipv6 = is_ipv6;
return -99;
}
- M (SW_INTERFACE_GET_TABLE, sw_interface_get_table);
+ M (SW_INTERFACE_GET_TABLE, mp);
mp->sw_if_index = htonl (sw_if_index);
mp->is_ipv6 = is_ipv6;
}
/* Construct the API message */
- M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
+ M (SW_INTERFACE_SET_VPATH, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = is_enable;
f64 timeout;
u32 sw_if_index = 0;
u8 sw_if_index_set = 0;
- u8 is_enable = 0;
+ u8 is_enable = 1;
u8 is_ipv6 = 0;
/* Parse args required to build the message */
}
/* Construct the API message */
- M (SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass);
+ M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = is_enable;
return -99;
}
- M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
+ M (SW_INTERFACE_SET_L2_XCONNECT, mp);
mp->rx_sw_if_index = ntohl (rx_sw_if_index);
mp->tx_sw_if_index = ntohl (tx_sw_if_index);
return -99;
}
- M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
+ M (SW_INTERFACE_SET_L2_BRIDGE, mp);
mp->rx_sw_if_index = ntohl (rx_sw_if_index);
mp->bd_id = ntohl (bd_id);
break;
}
- M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
+ M (BRIDGE_DOMAIN_DUMP, mp);
mp->bd_id = ntohl (bd_id);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
return -99;
}
- M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
+ M (BRIDGE_DOMAIN_ADD_DEL, mp);
mp->bd_id = ntohl (bd_id);
mp->flood = flood;
for (j = 0; j < count; j++)
{
- M (L2FIB_ADD_DEL, l2fib_add_del);
+ M (L2FIB_ADD_DEL, mp);
mp->mac = mac;
mp->bd_id = ntohl (bd_id);
/* Shut off async mode */
vam->async_mode = 0;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
timeout = vat_time_now (vam) + 1.0;
return -99;
}
- M (L2_FLAGS, l2_flags);
+ M (L2_FLAGS, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->feature_bitmap = ntohl (feature_bitmap);
return -99;
}
- M (BRIDGE_FLAGS, bridge_flags);
+ M (BRIDGE_FLAGS, mp);
mp->bd_id = ntohl (bd_id);
mp->feature_bitmap = ntohl (flags);
return -99;
}
- M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
+ M (BD_IP_MAC_ADD_DEL, mp);
mp->bd_id = ntohl (bd_id);
mp->is_ipv6 = is_ipv6;
u8 name_set = 0;
u8 *tap_name;
u8 *tag = 0;
+ ip4_address_t ip4_address;
+ u32 ip4_mask_width;
+ int ip4_address_set = 0;
+ ip6_address_t ip6_address;
+ u32 ip6_mask_width;
+ int ip6_address_set = 0;
memset (mac_address, 0, sizeof (mac_address));
name_set = 1;
else if (unformat (i, "tag %s", &tag))
;
+ else if (unformat (i, "address %U/%d",
+ unformat_ip4_address, &ip4_address, &ip4_mask_width))
+ ip4_address_set = 1;
+ else if (unformat (i, "address %U/%d",
+ unformat_ip6_address, &ip6_address, &ip6_mask_width))
+ ip6_address_set = 1;
else
break;
}
}
/* Construct the API message */
- M (TAP_CONNECT, tap_connect);
+ M (TAP_CONNECT, mp);
mp->use_random_mac = random_mac;
clib_memcpy (mp->mac_address, mac_address, 6);
if (tag)
clib_memcpy (mp->tag, tag, vec_len (tag));
+ if (ip4_address_set)
+ {
+ mp->ip4_address_set = 1;
+ clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
+ mp->ip4_mask_width = ip4_mask_width;
+ }
+ if (ip6_address_set)
+ {
+ mp->ip6_address_set = 1;
+ clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
+ mp->ip6_mask_width = ip6_mask_width;
+ }
+
vec_free (tap_name);
vec_free (tag);
vec_add1 (tap_name, 0);
/* Construct the API message */
- M (TAP_MODIFY, tap_modify);
+ M (TAP_MODIFY, mp);
mp->use_random_mac = random_mac;
mp->sw_if_index = ntohl (sw_if_index);
}
/* Construct the API message */
- M (TAP_DELETE, tap_delete);
+ M (TAP_DELETE, mp);
mp->sw_if_index = ntohl (sw_if_index);
for (j = 0; j < count; j++)
{
/* Construct the API message */
- M2 (IP_ADD_DEL_ROUTE, ip_add_del_route,
+ M2 (IP_ADD_DEL_ROUTE, mp,
sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
mp->next_hop_sw_if_index = ntohl (sw_if_index);
/* Shut off async mode */
vam->async_mode = 0;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
timeout = vat_time_now (vam) + 1.0;
return (vam->retval);
}
+static int
+api_ip_mroute_add_del (vat_main_t * vam)
+{
+ unformat_input_t *i = vam->input;
+ vl_api_ip_mroute_add_del_t *mp;
+ f64 timeout;
+ u32 sw_if_index = ~0, vrf_id = 0;
+ u8 is_ipv6 = 0;
+ u8 is_local = 0;
+ u8 create_vrf_if_needed = 0;
+ u8 is_add = 1;
+ u8 address_set = 0;
+ u32 grp_address_length = 0;
+ ip4_address_t v4_grp_address, v4_src_address;
+ ip6_address_t v6_grp_address, v6_src_address;
+ mfib_itf_flags_t iflags = 0;
+ mfib_entry_flags_t eflags = 0;
+
+ /* Parse args required to build the message */
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (i, "sw_if_index %d", &sw_if_index))
+ ;
+ else if (unformat (i, "%U %U",
+ unformat_ip4_address, &v4_src_address,
+ unformat_ip4_address, &v4_grp_address))
+ {
+ grp_address_length = 64;
+ address_set = 1;
+ is_ipv6 = 0;
+ }
+ else if (unformat (i, "%U %U",
+ unformat_ip6_address, &v6_src_address,
+ unformat_ip6_address, &v6_grp_address))
+ {
+ grp_address_length = 256;
+ address_set = 1;
+ is_ipv6 = 1;
+ }
+ else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
+ {
+ memset (&v4_src_address, 0, sizeof (v4_src_address));
+ grp_address_length = 32;
+ address_set = 1;
+ is_ipv6 = 0;
+ }
+ else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
+ {
+ memset (&v6_src_address, 0, sizeof (v6_src_address));
+ grp_address_length = 128;
+ address_set = 1;
+ is_ipv6 = 1;
+ }
+ else if (unformat (i, "/%d", &grp_address_length))
+ ;
+ else if (unformat (i, "local"))
+ {
+ is_local = 1;
+ }
+ else if (unformat (i, "del"))
+ is_add = 0;
+ else if (unformat (i, "add"))
+ is_add = 1;
+ else if (unformat (i, "vrf %d", &vrf_id))
+ ;
+ else if (unformat (i, "create-vrf"))
+ create_vrf_if_needed = 1;
+ else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
+ ;
+ else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
+ ;
+ else
+ {
+ clib_warning ("parse error '%U'", format_unformat_error, i);
+ return -99;
+ }
+ }
+
+ if (address_set == 0)
+ {
+ errmsg ("missing addresses\n");
+ return -99;
+ }
+
+ /* Construct the API message */
+ M (IP_MROUTE_ADD_DEL, mp);
+
+ mp->next_hop_sw_if_index = ntohl (sw_if_index);
+ mp->table_id = ntohl (vrf_id);
+ mp->create_vrf_if_needed = create_vrf_if_needed;
+
+ mp->is_add = is_add;
+ mp->is_ipv6 = is_ipv6;
+ mp->is_local = is_local;
+ mp->itf_flags = ntohl (iflags);
+ mp->entry_flags = ntohl (eflags);
+ mp->grp_address_length = grp_address_length;
+ mp->grp_address_length = ntohs (mp->grp_address_length);
+
+ if (is_ipv6)
+ {
+ clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
+ clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
+ }
+ else
+ {
+ clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
+ clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
+
+ }
+
+ /* send it... */
+ S;
+ /* Wait for a reply... */
+ W;
+}
+
static int
api_mpls_route_add_del (vat_main_t * vam)
{
for (j = 0; j < count; j++)
{
/* Construct the API message */
- M2 (MPLS_ROUTE_ADD_DEL, mpls_route_add_del,
+ M2 (MPLS_ROUTE_ADD_DEL, mp,
sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
/* Shut off async mode */
vam->async_mode = 0;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
timeout = vat_time_now (vam) + 1.0;
}
/* Construct the API message */
- M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
+ M (MPLS_IP_BIND_UNBIND, mp);
mp->mb_create_table_if_needed = create_table_if_needed;
mp->mb_is_bind = is_bind;
return -99;
}
- M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
+ M (PROXY_ARP_ADD_DEL, mp);
mp->vrf_id = ntohl (vrf_id);
mp->is_add = is_add;
return -99;
}
- M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
+ M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable_disable = enable;
}
}
- M2 (MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del,
- sizeof (mpls_label_t) * vec_len (labels));
+ M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
mp->mt_sw_if_index = ntohl (sw_if_index);
return -99;
}
- M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
+ M (SW_INTERFACE_SET_UNNUMBERED, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
}
/* Construct the API message */
- M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
+ M (IP_NEIGHBOR_ADD_DEL, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_add = is_add;
return -99;
}
- M (RESET_VRF, reset_vrf);
+ M (RESET_VRF, mp);
mp->vrf_id = ntohl (vrf_id);
mp->is_ipv6 = is_ipv6;
errmsg ("missing vlan_id");
return -99;
}
- M (CREATE_VLAN_SUBIF, create_vlan_subif);
+ M (CREATE_VLAN_SUBIF, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->vlan_id = ntohl (vlan_id);
errmsg ("missing sub_id");
return -99;
}
- M (CREATE_SUBIF, create_subif);
+ M (CREATE_SUBIF, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->sub_id = ntohl (sub_id);
return -99;
}
- M (OAM_ADD_DEL, oam_add_del);
+ M (OAM_ADD_DEL, mp);
mp->vrf_id = ntohl (vrf_id);
mp->is_add = is_add;
return -99;
}
- M (RESET_FIB, reset_fib);
+ M (RESET_FIB, mp);
mp->vrf_id = ntohl (vrf_id);
mp->is_ipv6 = is_ipv6;
}
/* Construct the API message */
- M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
+ M (DHCP_PROXY_CONFIG, mp);
mp->insert_circuit_id = insert_cid;
mp->is_add = is_add;
}
/* Construct the API message */
- M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
+ M (DHCP_PROXY_CONFIG_2, mp);
mp->insert_circuit_id = insert_cid;
mp->is_add = is_add;
return -99;
}
- M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
+ M (DHCP_PROXY_SET_VSS, mp);
mp->tbl_id = ntohl (tbl_id);
mp->fib_id = ntohl (fib_id);
mp->oui = ntohl (oui);
vec_add1 (hostname, 0);
/* Construct the API message */
- M (DHCP_CLIENT_CONFIG, dhcp_client_config);
+ M (DHCP_CLIENT_CONFIG, mp);
mp->sw_if_index = ntohl (sw_if_index);
clib_memcpy (mp->hostname, hostname, vec_len (hostname));
return -99;
}
- M (SET_IP_FLOW_HASH, set_ip_flow_hash);
+ M (SET_IP_FLOW_HASH, mp);
mp->src = src;
mp->dst = dst;
mp->sport = sport;
return -99;
}
- M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
+ M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = enable;
f64 timeout;
u32 sw_if_index;
u8 sw_if_index_set = 0;
- u32 address_length = 0;
u8 v6_address_set = 0;
ip6_address_t v6address;
sw_if_index_set = 1;
else if (unformat (i, "sw_if_index %d", &sw_if_index))
sw_if_index_set = 1;
- else if (unformat (i, "%U/%d",
- unformat_ip6_address, &v6address, &address_length))
+ else if (unformat (i, "%U", unformat_ip6_address, &v6address))
v6_address_set = 1;
else
break;
}
/* Construct the API message */
- M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
- sw_interface_ip6_set_link_local_address);
+ M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
mp->sw_if_index = ntohl (sw_if_index);
clib_memcpy (mp->address, &v6address, sizeof (v6address));
- mp->address_length = address_length;
/* send it... */
S;
}
/* Construct the API message */
- M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
+ M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
mp->sw_if_index = ntohl (sw_if_index);
clib_memcpy (mp->address, &v6address, sizeof (v6address));
}
/* Construct the API message */
- M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
+ M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->max_interval = ntohl (max_interval);
return -99;
}
- M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
+ M (SET_ARP_NEIGHBOR_LIMIT, mp);
mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
mp->is_ipv6 = is_ipv6;
return -99;
}
- M (L2_PATCH_ADD_DEL, l2_patch_add_del);
+ M (L2_PATCH_ADD_DEL, mp);
mp->rx_sw_if_index = ntohl (rx_sw_if_index);
mp->tx_sw_if_index = ntohl (tx_sw_if_index);
else
break;
}
- M (IOAM_ENABLE, ioam_enable);
+ M (IOAM_ENABLE, mp);
mp->id = htons (id);
mp->seqno = has_seqno_option;
mp->analyse = has_analyse_option;
vl_api_ioam_disable_t *mp;
f64 timeout;
- M (IOAM_DISABLE, ioam_disable);
+ M (IOAM_DISABLE, mp);
S;
W;
return 0;
return -99;
}
- M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
+ M2 (SR_TUNNEL_ADD_DEL, mp,
vec_len (segments) * sizeof (ip6_address_t)
+ vec_len (tags) * sizeof (ip6_address_t));
return -99;
}
- M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
+ M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
return -99;
}
- M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
+ M (SR_MULTICAST_MAP_ADD_DEL, mp);
mp->is_add = !is_del;
memcpy (mp->policy_name, policy_name, vec_len (policy_name));
return -99;
}
- M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
+ M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
mp->is_add = is_add;
mp->del_chain = del_chain;
return -99;
}
- M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
+ M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
mp->is_add = is_add;
mp->table_index = ntohl (table_index);
}
- M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
+ M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->table_index = ntohl (table_index);
}
- M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
+ M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->ip4_table_index = ntohl (ip4_table_index);
return -99;
}
- M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
+ M (SET_IPFIX_EXPORTER, mp);
memcpy (mp->collector_address, collector_address.data,
sizeof (collector_address.data));
}
}
- M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
+ M (SET_IPFIX_CLASSIFY_STREAM, mp);
mp->domain_id = htonl (domain_id);
mp->src_port = htons ((u16) src_port);
return -99;
}
- M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
+ M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
mp->is_add = is_add;
mp->table_id = htonl (classify_table_index);
return -99;
}
- M (GET_NODE_INDEX, get_node_index);
+ M (GET_NODE_INDEX, mp);
clib_memcpy (mp->node_name, name, vec_len (name));
vec_free (name);
return -99;
}
- M (GET_NEXT_INDEX, get_next_index);
+ M (GET_NEXT_INDEX, mp);
clib_memcpy (mp->node_name, node_name, vec_len (node_name));
clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
vec_free (node_name);
return -99;
}
- M (ADD_NODE_NEXT, add_node_next);
+ M (ADD_NODE_NEXT, mp);
clib_memcpy (mp->node_name, name, vec_len (name));
clib_memcpy (mp->next_name, next, vec_len (next));
vec_free (name);
return -99;
}
- M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
+ M (L2TPV3_CREATE_TUNNEL, mp);
clib_memcpy (mp->client_address, client_address.as_u8,
sizeof (mp->client_address));
return -99;
}
- M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
+ M (L2TPV3_SET_TUNNEL_COOKIES, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
return -99;
}
- M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
+ M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable_disable = enable_disable;
return -99;
}
- M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
+ M (L2TPV3_SET_LOOKUP_KEY, mp);
mp->key = key;
f64 timeout;
/* Get list of l2tpv3-tunnel interfaces */
- M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
+ M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
/* Get list of tap interfaces */
- M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
+ M (SW_INTERFACE_TAP_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
return -99;
}
- M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
+ M (VXLAN_ADD_DEL_TUNNEL, mp);
if (ipv6_set)
{
}
/* Get list of vxlan-tunnel interfaces */
- M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
+ M (VXLAN_TUNNEL_DUMP, mp);
mp->sw_if_index = htonl (sw_if_index);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
- M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
+ M (GRE_ADD_DEL_TUNNEL, mp);
clib_memcpy (&mp->src_address, &src4, sizeof (src4));
clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
}
/* Get list of gre-tunnel interfaces */
- M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
+ M (GRE_TUNNEL_DUMP, mp);
mp->sw_if_index = htonl (sw_if_index);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
vl_api_l2_fib_clear_table_t *mp;
f64 timeout;
- M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
+ M (L2_FIB_CLEAR_TABLE, mp);
S;
W;
return -99;
}
- M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
+ M (L2_INTERFACE_EFP_FILTER, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable_disable = enable;
return -99;
}
- M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
- mp->sw_if_index = ntohl (sw_if_index);
+ M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
+ mp->sw_if_index = ntohl (sw_if_index);
mp->vtr_op = ntohl (vtr_op);
mp->push_dot1q = ntohl (push_dot1q);
mp->tag1 = ntohl (tag1);
}
vec_add1 (file_name, 0);
- M (CREATE_VHOST_USER_IF, create_vhost_user_if);
+ M (CREATE_VHOST_USER_IF, mp);
mp->is_server = is_server;
clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
}
vec_add1 (file_name, 0);
- M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
+ M (MODIFY_VHOST_USER_IF, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_server = is_server;
}
- M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
+ M (DELETE_VHOST_USER_IF, mp);
mp->sw_if_index = ntohl (sw_if_index);
"Interface name idx hdr_sz features server regions filename");
/* Get list of vhost-user interfaces */
- M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
+ M (SW_INTERFACE_VHOST_USER_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
vl_api_show_version_t *mp;
f64 timeout;
- M (SHOW_VERSION, show_version);
+ M (SHOW_VERSION, mp);
S;
W;
return -99;
}
- M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
+ M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
if (ipv6_set)
}
/* Get list of vxlan-tunnel interfaces */
- M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
+ M (VXLAN_GPE_TUNNEL_DUMP, mp);
mp->sw_if_index = htonl (sw_if_index);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
/* Get list of l2 fib entries */
- M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
+ M (L2_FIB_TABLE_DUMP, mp);
mp->bd_id = ntohl (bd_id);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
return -99;
}
- M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
+ M (INTERFACE_NAME_RENUMBER, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->new_show_dev_instance = ntohl (new_show_dev_instance);
return -99;
}
- M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
+ M (WANT_IP4_ARP_EVENTS, mp);
mp->enable_disable = enable_disable;
mp->pid = getpid ();
mp->address = address.as_u32;
return -99;
}
- M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
+ M (WANT_IP6_ND_EVENTS, mp);
mp->enable_disable = enable_disable;
mp->pid = getpid ();
clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
return -99;
}
- M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
+ M (INPUT_ACL_SET_INTERFACE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->ip4_table_index = ntohl (ip4_table_index);
vam->current_sw_if_index = sw_if_index;
vam->is_ipv6 = ipv6_set;
- M (IP_ADDRESS_DUMP, ip_address_dump);
+ M (IP_ADDRESS_DUMP, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_ipv6 = ipv6_set;
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
- M (IP_DUMP, ip_dump);
+ M (IP_DUMP, mp);
mp->is_ipv6 = ipv6_set;
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
return -99;
}
- M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
+ M (IPSEC_SPD_ADD_DEL, mp);
mp->spd_id = ntohl (spd_id);
mp->is_add = is_add;
return -99;
}
- M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
+ M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
mp->spd_id = ntohl (spd_id);
mp->sw_if_index = ntohl (sw_if_index);
}
- M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
+ M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
mp->spd_id = ntohl (spd_id);
mp->priority = ntohl (priority);
if (unformat
(i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
{
-#if DPDK_CRYPTO==1
- if (integ_alg < IPSEC_INTEG_ALG_NONE ||
-#else
if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
-#endif
integ_alg >= IPSEC_INTEG_N_ALG)
{
clib_warning ("unsupported integ-alg: '%U'",
}
-#if DPDK_CRYPTO==1
- /*Special cases, aes-gcm-128 encryption */
- if (crypto_alg == IPSEC_CRYPTO_ALG_AES_GCM_128)
- {
- if (integ_alg != IPSEC_INTEG_ALG_NONE
- && integ_alg != IPSEC_INTEG_ALG_AES_GCM_128)
- {
- clib_warning
- ("unsupported: aes-gcm-128 crypto-alg needs none as integ-alg");
- return -99;
- }
- else /*set integ-alg internally to aes-gcm-128 */
- integ_alg = IPSEC_INTEG_ALG_AES_GCM_128;
- }
- else if (integ_alg == IPSEC_INTEG_ALG_AES_GCM_128)
- {
- clib_warning ("unsupported integ-alg: aes-gcm-128");
- return -99;
- }
- else if (integ_alg == IPSEC_INTEG_ALG_NONE)
- {
- clib_warning ("unsupported integ-alg: none");
- return -99;
- }
-#endif
-
-
- M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
+ M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
mp->sad_id = ntohl (sad_id);
mp->is_add = is_add;
}
}
- M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
+ M (IPSEC_SA_SET_KEY, mp);
mp->sa_id = ntohl (sa_id);
mp->crypto_key_length = vec_len (ck);
return -99;
}
- M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
+ M (IKEV2_PROFILE_ADD_DEL, mp);
clib_memcpy (mp->name, name, vec_len (name));
mp->is_add = is_add;
return -99;
}
- M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
+ M (IKEV2_PROFILE_SET_AUTH, mp);
mp->is_hex = is_hex;
mp->auth_method = (u8) auth_method;
return -99;
}
- M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
+ M (IKEV2_PROFILE_SET_ID, mp);
mp->is_local = is_local;
mp->id_type = (u8) id_type;
return -99;
}
- M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
+ M (IKEV2_PROFILE_SET_TS, mp);
mp->is_local = is_local;
mp->proto = (u8) proto;
return -99;
}
- M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
+ M (IKEV2_SET_LOCAL_KEY, mp);
clib_memcpy (mp->key_file, file, vec_len (file));
vec_free (file);
}
/* Construct the API message */
- M (MAP_ADD_DOMAIN, map_add_domain);
+ M (MAP_ADD_DOMAIN, mp);
clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
mp->ip4_prefix_len = ip4_prefix_len;
}
/* Construct the API message */
- M (MAP_DEL_DOMAIN, map_del_domain);
+ M (MAP_DEL_DOMAIN, mp);
mp->index = ntohl (index);
}
/* Construct the API message */
- M (MAP_ADD_DEL_RULE, map_add_del_rule);
+ M (MAP_ADD_DEL_RULE, mp);
mp->index = ntohl (index);
mp->is_add = is_add;
f64 timeout;
/* Construct the API message */
- M (MAP_DOMAIN_DUMP, map_domain_dump);
+ M (MAP_DOMAIN_DUMP, mp);
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
/* Construct the API message */
- M (MAP_RULE_DUMP, map_rule_dump);
+ M (MAP_RULE_DUMP, mp);
mp->domain_index = htonl (domain_index);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
return -99;
}
- M (GET_FIRST_MSG_ID, get_first_msg_id);
+ M (GET_FIRST_MSG_ID, mp);
clib_memcpy (mp->name, name, vec_len (name));
S;
W;
}
/* Construct the API message */
- M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
+ M (COP_INTERFACE_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable_disable = enable_disable;
}
/* Construct the API message */
- M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
+ M (COP_WHITELIST_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->fib_id = ntohl (fib_id);
mp->ip4 = ip4;
vl_api_get_node_graph_t *mp;
f64 timeout;
- M (GET_NODE_GRAPH, get_node_graph);
+ M (GET_NODE_GRAPH, mp);
/* send it... */
S;
clib_memcpy (dst, eid, lisp_eid_size_vat (type));
}
-/* *INDENT-OFF* */
-/** Used for transferring locators via VPP API */
-typedef CLIB_PACKED(struct
-{
- u32 sw_if_index; /**< locator sw_if_index */
- u8 priority; /**< locator priority */
- u8 weight; /**< locator weight */
-}) ls_locator_t;
-/* *INDENT-ON* */
-
static int
api_lisp_add_del_locator_set (vat_main_t * vam)
{
u8 is_add = 1;
u8 *locator_set_name = NULL;
u8 locator_set_name_set = 0;
- ls_locator_t locator, *locators = 0;
+ vl_api_local_locator_t locator, *locators = 0;
u32 sw_if_index, priority, weight;
u32 data_len = 0;
}
vec_add1 (locator_set_name, 0);
- data_len = sizeof (ls_locator_t) * vec_len (locators);
+ data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
/* Construct the API message */
- M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
+ M2 (LISP_ADD_DEL_LOCATOR_SET, mp, data_len);
mp->is_add = is_add;
clib_memcpy (mp->locator_set_name, locator_set_name,
vec_add1 (locator_set_name, 0);
/* Construct the API message */
- M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
+ M (LISP_ADD_DEL_LOCATOR, mp);
mp->is_add = is_add;
mp->sw_if_index = ntohl (sw_if_index);
vec_add1 (locator_set_name, 0);
/* Construct the API message */
- M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
+ M (LISP_ADD_DEL_LOCAL_EID, mp);
mp->is_add = is_add;
lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
static int
api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
{
+ u32 dp_table = 0, vni = 0;;
unformat_input_t *input = vam->input;
vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
f64 timeout = ~0;
lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
u8 rmt_eid_set = 0, lcl_eid_set = 0;
- u32 action = ~0, p, w;
+ u32 action = ~0, w;
ip4_address_t rmt_rloc4, lcl_rloc4;
ip6_address_t rmt_rloc6, lcl_rloc6;
- rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
+ vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
+ 0;
memset (&rloc, 0, sizeof (rloc));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "del"))
- {
- is_add = 0;
- }
- else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
+ is_add = 0;
+ else if (unformat (input, "add"))
+ is_add = 1;
+ else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
{
rmt_eid_set = 1;
}
- else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
+ else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
{
lcl_eid_set = 1;
}
- else if (unformat (input, "p %d w %d", &p, &w))
+ else if (unformat (input, "vrf %d", &dp_table))
+ ;
+ else if (unformat (input, "bd %d", &dp_table))
+ ;
+ else if (unformat (input, "vni %d", &vni))
+ ;
+ else if (unformat (input, "w %d", &w))
{
if (!curr_rloc)
{
errmsg ("No RLOC configured for setting priority/weight!");
return -99;
}
- curr_rloc->priority = p;
curr_rloc->weight = w;
}
else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
rloc.is_ip4 = 1;
clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
- rloc.priority = rloc.weight = 0;
+ rloc.weight = 0;
vec_add1 (lcl_locs, rloc);
clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
vec_add1 (rmt_locs, rloc);
- /* priority and weight saved in rmt loc */
+ /* weight saved in rmt loc */
curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
}
else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
{
rloc.is_ip4 = 0;
clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
- rloc.priority = rloc.weight = 0;
+ rloc.weight = 0;
vec_add1 (lcl_locs, rloc);
clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
vec_add1 (rmt_locs, rloc);
- /* priority and weight saved in rmt loc */
+ /* weight saved in rmt loc */
curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
}
else if (unformat (input, "action %d", &action))
}
/* Construct the API message */
- M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
+ M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, mp,
+ sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
mp->is_add = is_add;
lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
mp->eid_type = rmt_eid->type;
+ mp->dp_table = clib_host_to_net_u32 (dp_table);
+ mp->vni = clib_host_to_net_u32 (vni);
mp->rmt_len = rmt_eid->len;
mp->lcl_len = lcl_eid->len;
mp->action = action;
if (0 != rmt_locs && 0 != lcl_locs)
{
- mp->loc_num = vec_len (rmt_locs);
- clib_memcpy (mp->lcl_locs, lcl_locs,
- (sizeof (rloc_t) * vec_len (lcl_locs)));
- clib_memcpy (mp->rmt_locs, rmt_locs,
- (sizeof (rloc_t) * vec_len (rmt_locs)));
+ mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
+ clib_memcpy (mp->locs, lcl_locs,
+ (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
+
+ u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
+ clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
+ (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
}
vec_free (lcl_locs);
vec_free (rmt_locs);
}
/* Construct the API message */
- M (LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server);
+ M (LISP_ADD_DEL_MAP_SERVER, mp);
mp->is_add = is_add;
if (ipv6_set)
}
/* Construct the API message */
- M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
+ M (LISP_ADD_DEL_MAP_RESOLVER, mp);
mp->is_add = is_add;
if (ipv6_set)
}
/* Construct the API message */
- M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
+ M (LISP_GPE_ENABLE_DISABLE, mp);
mp->is_en = is_en;
}
/* Construct the API message */
- M (LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable);
+ M (LISP_RLOC_PROBE_ENABLE_DISABLE, mp);
mp->is_enabled = is_en;
}
/* Construct the API message */
- M (LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable);
+ M (LISP_MAP_REGISTER_ENABLE_DISABLE, mp);
mp->is_enabled = is_en;
}
/* Construct the API message */
- M (LISP_ENABLE_DISABLE, lisp_enable_disable);
+ M (LISP_ENABLE_DISABLE, mp);
mp->is_en = is_en;
f64 timeout = ~0;
vl_api_show_lisp_map_register_state_t *mp;
- M (SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state);
+ M (SHOW_LISP_MAP_REGISTER_STATE, mp);
/* send */
S;
f64 timeout = ~0;
vl_api_show_lisp_rloc_probe_state_t *mp;
- M (SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state);
+ M (SHOW_LISP_RLOC_PROBE_STATE, mp);
/* send */
S;
f64 timeout = ~0;
vl_api_show_lisp_map_request_mode_t *mp;
- M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
+ M (SHOW_LISP_MAP_REQUEST_MODE, mp);
/* send */
S;
}
}
- M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
+ M (LISP_MAP_REQUEST_MODE, mp);
mp->mode = mode;
return -99;
}
- M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
+ M (LISP_PITR_SET_LOCATOR_SET, mp);
mp->is_add = is_add;
clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
print (vam->ofp, "%=20s", "lisp status:");
}
- M (SHOW_LISP_PITR, show_lisp_pitr);
+ M (SHOW_LISP_PITR, mp);
/* send it... */
S;
return -99;
}
- M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
+ M (LISP_EID_TABLE_ADD_DEL_MAP, mp);
mp->is_add = is_add;
mp->vni = htonl (vni);
u32 action = ~0, p, w, data_len;
ip4_address_t rloc4;
ip6_address_t rloc6;
- rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
+ vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
memset (&rloc, 0, sizeof (rloc));
return -99;
}
- data_len = vec_len (rlocs) * sizeof (rloc_t);
+ data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
- M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
+ M2 (LISP_ADD_DEL_REMOTE_MAPPING, mp, data_len);
mp->is_add = is_add;
mp->vni = htonl (vni);
mp->action = (u8) action;
return -99;
}
- M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
+ M (LISP_ADD_DEL_ADJACENCY, mp);
mp->is_add = is_add;
mp->vni = htonl (vni);
mp->leid_len = leid_len;
}
/* Construct the API message */
- M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
+ M (LISP_GPE_ADD_DEL_IFACE, mp);
mp->is_add = is_add;
mp->dp_table = dp_table;
return -99;
}
- M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
+ M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
mp->is_add = is_add;
if (is_add)
{
print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
}
- M (LISP_LOCATOR_DUMP, lisp_locator_dump);
+ M (LISP_LOCATOR_DUMP, mp);
mp->is_index_set = is_index_set;
if (is_index_set)
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
}
- M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
+ M (LISP_LOCATOR_SET_DUMP, mp);
mp->filter = filter;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
}
- M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
+ M (LISP_EID_TABLE_MAP_DUMP, mp);
mp->is_l2 = is_l2;
/* send it... */
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
print (vam->ofp, "VNI");
}
- M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
+ M (LISP_EID_TABLE_VNI_DUMP, mp);
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
"type", "ls_index", "ttl", "authoritative", "key_id", "key");
}
- M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
+ M (LISP_EID_TABLE_DUMP, mp);
mp->filter = filter;
if (eid_set)
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
}
static int
-api_lisp_gpe_tunnel_dump (vat_main_t * vam)
+api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
{
- vl_api_lisp_gpe_tunnel_dump_t *mp;
+ unformat_input_t *i = vam->input;
+ vl_api_lisp_gpe_fwd_entries_get_t *mp;
f64 timeout = ~0;
+ u8 vni_set = 0;
+ u32 vni = ~0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (i, "vni %d", &vni))
+ {
+ vni_set = 1;
+ }
+ else
+ {
+ errmsg ("parse error '%U'", format_unformat_error, i);
+ return -99;
+ }
+ }
+
+ if (!vni_set)
+ {
+ errmsg ("vni not set!");
+ return -99;
+ }
if (!vam->json_output)
{
- print (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
- "%=16s%=16s%=16s%=16s%=16s",
- "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
- "Decap next", "Lisp version", "Flags", "Next protocol",
- "ver_res", "res", "iid");
+ print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
+ "leid", "reid");
}
- M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
+ M (LISP_GPE_FWD_ENTRIES_GET, mp);
+ mp->vni = clib_host_to_net_u32 (vni);
+
/* send it... */
S;
- /* Use a control ping for synchronization */
- {
- vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
- S;
- }
/* Wait for a reply... */
W;
return 0;
}
+#define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
+#define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
+#define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
+#define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
+
static int
api_lisp_adjacencies_get (vat_main_t * vam)
{
print (vam->ofp, "%s %40s", "leid", "reid");
}
- M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
+ M (LISP_ADJACENCIES_GET, mp);
mp->vni = clib_host_to_net_u32 (vni);
/* send it... */
print (vam->ofp, "%=20s", "Map server");
}
- M (LISP_MAP_SERVER_DUMP, lisp_map_server_dump);
+ M (LISP_MAP_SERVER_DUMP, mp);
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
print (vam->ofp, "%=20s", "Map resolver");
}
- M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
+ M (LISP_MAP_RESOLVER_DUMP, mp);
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
}
- M (SHOW_LISP_STATUS, show_lisp_status);
+ M (SHOW_LISP_STATUS, mp);
+ /* send it... */
+ S;
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
+{
+ vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
+ f64 timeout = ~0;
+ unformat_input_t *i = vam->input;
+ u32 fwd_entry_index = ~0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (i, "index %d", &fwd_entry_index))
+ ;
+ else
+ break;
+ }
+
+ if (~0 == fwd_entry_index)
+ {
+ errmsg ("no index specified!");
+ return -99;
+ }
+
+ if (!vam->json_output)
+ {
+ print (vam->ofp, "first line");
+ }
+
+ M (LISP_GPE_FWD_ENTRY_PATH_DUMP, mp);
+
/* send it... */
S;
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t *mp;
+ M (CONTROL_PING, mp);
+ S;
+ }
/* Wait for a reply... */
W;
print (vam->ofp, "%=20s", "itr-rlocs:");
}
- M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
+ M (LISP_GET_MAP_REQUEST_ITR_RLOCS, mp);
/* send it... */
S;
/* Wait for a reply... */
return -99;
}
- M (AF_PACKET_CREATE, af_packet_create);
+ M (AF_PACKET_CREATE, mp);
clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
clib_memcpy (mp->hw_addr, hw_addr, 6);
return -99;
}
- M (AF_PACKET_DELETE, af_packet_delete);
+ M (AF_PACKET_DELETE, mp);
clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
vec_free (host_if_name);
return -99;
}
- M (POLICER_ADD_DEL, policer_add_del);
+ M (POLICER_ADD_DEL, mp);
clib_memcpy (mp->name, name, vec_len (name));
vec_free (name);
break;
}
- M (POLICER_DUMP, policer_dump);
+ M (POLICER_DUMP, mp);
mp->match_name_valid = match_name_valid;
clib_memcpy (mp->match_name, match_name, vec_len (match_name));
vec_free (match_name);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
return -99;
}
- M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
+ M (POLICER_CLASSIFY_SET_INTERFACE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->ip4_table_index = ntohl (ip4_table_index);
print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
}
- M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
+ M (POLICER_CLASSIFY_DUMP, mp);
mp->type = type;
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
return -99;
}
- M (NETMAP_CREATE, netmap_create);
+ M (NETMAP_CREATE, mp);
clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
clib_memcpy (mp->hw_addr, hw_addr, 6);
return -99;
}
- M (NETMAP_DELETE, netmap_delete);
+ M (NETMAP_DELETE, mp);
clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
vec_free (if_name);
print (vam->ofp, " tunnel_index %d", index);
- M (MPLS_TUNNEL_DUMP, mpls_tunnel_dump);
+ M (MPLS_TUNNEL_DUMP, mp);
mp->tunnel_index = htonl (index);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
vl_api_mpls_fib_dump_t *mp;
f64 timeout;
- M (MPLS_FIB_DUMP, mpls_fib_dump);
+ M (MPLS_FIB_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
vl_api_ip_fib_dump_t *mp;
f64 timeout;
- M (IP_FIB_DUMP, ip_fib_dump);
+ M (IP_FIB_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
return -99;
}
- M (IP_NEIGHBOR_DUMP, ip_neighbor_dump);
+ M (IP_NEIGHBOR_DUMP, mp);
mp->is_ipv6 = (u8) is_ipv6;
mp->sw_if_index = ntohl (sw_if_index);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
vl_api_ip6_fib_dump_t *mp;
f64 timeout;
- M (IP6_FIB_DUMP, ip6_fib_dump);
+ M (IP6_FIB_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
f64 timeout;
/* Construct the API message */
- M (CLASSIFY_TABLE_IDS, classify_table_ids);
+ M (CLASSIFY_TABLE_IDS, mp);
mp->context = 0;
S;
}
/* Construct the API message */
- M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
+ M (CLASSIFY_TABLE_BY_INTERFACE, mp);
mp->context = 0;
mp->sw_if_index = ntohl (sw_if_index);
}
/* Construct the API message */
- M (CLASSIFY_TABLE_INFO, classify_table_info);
+ M (CLASSIFY_TABLE_INFO, mp);
mp->context = 0;
mp->table_id = ntohl (table_id);
}
/* Construct the API message */
- M (CLASSIFY_SESSION_DUMP, classify_session_dump);
+ M (CLASSIFY_SESSION_DUMP, mp);
mp->context = 0;
mp->table_id = ntohl (table_id);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
f64 timeout;
/* Construct the API message */
- M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
+ M (IPFIX_EXPORTER_DUMP, mp);
mp->context = 0;
S;
f64 timeout;
/* Construct the API message */
- M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
+ M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
mp->context = 0;
S;
}
/* Construct the API message */
- M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
+ M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
break;
}
- M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable);
+ M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
mp->sw_if_index_from = htonl (src_sw_if_index);
mp->sw_if_index_to = htonl (dst_sw_if_index);
vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
- vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
+ if (0 != sw_if_to_name)
+ {
+ vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
+ }
vat_json_object_add_uint (node, "state", mp->state);
}
vl_api_sw_interface_span_dump_t *mp;
f64 timeout;
- M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump);
+ M (SW_INTERFACE_SPAN_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
/* Construct the API message */
- M (PG_CREATE_INTERFACE, pg_create_interface);
+ M (PG_CREATE_INTERFACE, mp);
mp->context = 0;
mp->interface_id = ntohl (if_id);
u32 name_len = vec_len (pcap_file);
/* Construct the API message */
- M (PG_CAPTURE, pg_capture);
+ M (PG_CAPTURE, mp);
mp->context = 0;
mp->interface_id = ntohl (if_id);
mp->is_enabled = enable;
u32 name_len = vec_len (stream_name);
/* Construct the API message */
- M (PG_ENABLE_DISABLE, pg_enable_disable);
+ M (PG_ENABLE_DISABLE, mp);
mp->context = 0;
mp->is_enabled = enable;
if (stream_name_set != 0)
return -99;
}
- M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
- ip_source_and_port_range_check_add_del);
+ M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
mp->is_add = is_add;
}
/* Construct the API message */
- M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
- ip_source_and_port_range_check_interface_add_del);
+ M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_add = is_add;
}
}
- M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
+ M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
mp->local_sa_id = ntohl (local_sa_id);
mp->remote_sa_id = ntohl (remote_sa_id);
}
}
- M (PUNT, punt);
+ M (PUNT, mp);
mp->is_add = (u8) is_add;
mp->ipv = (u8) ipv;
}
/* Get list of gre-tunnel interfaces */
- M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
+ M (IPSEC_GRE_TUNNEL_DUMP, mp);
mp->sw_if_index = htonl (sw_if_index);
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
/* Construct the API message */
- M (DELETE_SUBIF, delete_subif);
+ M (DELETE_SUBIF, mp);
mp->sw_if_index = ntohl (sw_if_index);
S;
return -99;
}
- M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
+ M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->vtr_op = ntohl (vtr_op);
mp->outer_tag = ntohs (outer_tag);
return -99;
}
- M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
+ M (FLOW_CLASSIFY_SET_INTERFACE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->ip4_table_index = ntohl (ip4_table_index);
print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
}
- M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
+ M (FLOW_CLASSIFY_DUMP, mp);
mp->type = type;
/* send it... */
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
/* Wait for a reply... */
}
/* Construct the API message */
- M (FEATURE_ENABLE_DISABLE, feature_enable_disable);
+ M (FEATURE_ENABLE_DISABLE, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = enable;
clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
}
/* Construct the API message */
- M (SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del);
+ M (SW_INTERFACE_TAG_ADD_DEL, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->is_add = enable;
if (enable)
print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
}
- M (L2_XCONNECT_DUMP, l2_xconnect_dump);
+ M (L2_XCONNECT_DUMP, mp);
S;
/* Use a control ping for synchronization */
{
vl_api_control_ping_t *mp;
- M (CONTROL_PING, control_ping);
+ M (CONTROL_PING, mp);
S;
}
W;
}
/* Construct the API message */
- M (SW_INTERFACE_SET_MTU, sw_interface_set_mtu);
+ M (SW_INTERFACE_SET_MTU, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->mtu = ntohs ((u16) mtu);
_(sw_interface_set_vpath, \
"<intfc> | sw_if_index <id> enable | disable") \
_(sw_interface_set_vxlan_bypass, \
- "<intfc> | sw_if_index <id> [ip4 | ip6] enable | disable") \
+ "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
_(sw_interface_set_l2_xconnect, \
"rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
"enable | disable") \
"<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
"[shg <split-horizon-group>] [bvi]\n" \
"enable | disable") \
-_(sw_interface_set_dpdk_hqos_pipe, \
- "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
- "profile <profile-id>\n") \
-_(sw_interface_set_dpdk_hqos_subport, \
- "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
- "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
-_(sw_interface_set_dpdk_hqos_tctbl, \
- "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
_(bridge_domain_add_del, \
"bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
_(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
"[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
"[weight <n>] [drop] [local] [classify <n>] [del]\n" \
"[multipath] [count <n>]") \
+_(ip_mroute_add_del, \
+ "<src> <grp>/<mask> [table-id <n>]\n" \
+ "[<intfc> | sw_if_index <id>] [local] [del]") \
_(mpls_route_add_del, \
"<label> <eos> via <addr> [table-id <n>]\n" \
"[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
"<ipv4|ipv6>/<prefix> | <L2 address> " \
"locator-set <locator_name> [del]" \
"[key-id sha1|sha256 secret-key <secret-key>]") \
-_(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
- "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
+_(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
+ "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
_(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
_(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
_(lisp_gpe_enable_disable, "enable|disable") \
"[local] | [remote]") \
_(lisp_eid_table_vni_dump, "") \
_(lisp_eid_table_map_dump, "l2|l3") \
-_(lisp_gpe_tunnel_dump, "") \
_(lisp_map_resolver_dump, "") \
_(lisp_map_server_dump, "") \
_(lisp_adjacencies_get, "vni <vni>") \
+_(lisp_gpe_fwd_entries_get, "vni <vni>") \
+_(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
_(show_lisp_rloc_probe_state, "") \
_(show_lisp_map_register_state, "") \
_(show_lisp_status, "") \
_(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
_(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
+#if DPDK > 0
+#define foreach_vpe_dpdk_api_msg \
+_(sw_interface_set_dpdk_hqos_pipe, \
+ "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
+ "profile <profile-id>\n") \
+_(sw_interface_set_dpdk_hqos_subport, \
+ "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
+ "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
+_(sw_interface_set_dpdk_hqos_tctbl, \
+ "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
+#endif
+
/* List of command functions, CLI names map directly to functions */
#define foreach_cli_function \
_(comment, "usage: comment <ignore-rest-of-line>") \
foreach_vpe_api_reply_msg;
#undef _
+#if DPDK > 0
+#define _(N,n) \
+ static void vl_api_##n##_t_handler_uni \
+ (vl_api_##n##_t * mp) \
+ { \
+ vat_main_t * vam = &vat_main; \
+ if (vam->json_output) { \
+ vl_api_##n##_t_handler_json(mp); \
+ } else { \
+ vl_api_##n##_t_handler(mp); \
+ } \
+ }
+foreach_vpe_dpdk_api_reply_msg;
+#undef _
+#endif
+
void
vat_api_hookup (vat_main_t * vam)
{
foreach_vpe_api_reply_msg;
#undef _
+#if DPDK > 0
+#define _(N,n) \
+ vl_msg_api_set_handlers(VL_API_##N, #n, \
+ vl_api_##n##_t_handler_uni, \
+ vl_noop_handler, \
+ vl_api_##n##_t_endian, \
+ vl_api_##n##_t_print, \
+ sizeof(vl_api_##n##_t), 1);
+ foreach_vpe_dpdk_api_reply_msg;
+#undef _
+#endif
+
#if (VPP_API_TEST_BUILTIN==0)
vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
#endif
#define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
foreach_vpe_api_msg;
#undef _
+#if DPDK >0
+#define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
+ foreach_vpe_dpdk_api_msg;
+#undef _
+#endif
/* Help strings */
#define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
foreach_vpe_api_msg;
#undef _
+#if DPDK >0
+#define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
+ foreach_vpe_dpdk_api_msg;
+#undef _
+#endif
/* CLI functions */
#define _(n,h) hash_set_mem (vam->function_by_name, #n, n);