X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vpp-api-test%2Fvat%2Fapi_format.c;h=71c6f24136aa13e0eb5e5460a0eece20d2235eb4;hb=69a9b76d648a108e0a7fad4404b218ebdd6a8ea5;hp=3b93c985791dc99ce4111b2bd314fa146528fa0b;hpb=07d2f84907e776383572fa5cc89071d90a8be36b;p=vpp.git diff --git a/vpp-api-test/vat/api_format.c b/vpp-api-test/vat/api_format.c index 3b93c985791..71c6f24136a 100644 --- a/vpp-api-test/vat/api_format.c +++ b/vpp-api-test/vat/api_format.c @@ -2,7 +2,7 @@ *------------------------------------------------------------------ * api_format.c * - * Copyright (c) 2014 Cisco and/or its affiliates. + * Copyright (c) 2014-2016 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: @@ -35,7 +35,8 @@ #include #include #include -#include +#include +#include #if DPDK > 0 #include #include @@ -456,7 +457,7 @@ unformat_policer_action_type (unformat_input_t * input, va_list * va) } uword -unformat_classify_table_type (unformat_input_t * input, va_list * va) +unformat_policer_classify_table_type (unformat_input_t * input, va_list * va) { u32 *r = va_arg (*va, u32 *); u32 tid; @@ -474,6 +475,23 @@ unformat_classify_table_type (unformat_input_t * input, va_list * va) return 1; } +uword +unformat_flow_classify_table_type (unformat_input_t * input, va_list * va) +{ + u32 *r = va_arg (*va, u32 *); + u32 tid; + + if (unformat (input, "ip4")) + tid = FLOW_CLASSIFY_TABLE_IP4; + else if (unformat (input, "ip6")) + tid = FLOW_CLASSIFY_TABLE_IP6; + else + return 0; + + *r = tid; + return 1; +} + u8 * format_ip4_address (u8 * s, va_list * args) { @@ -1315,53 +1333,6 @@ static void vl_api_control_ping_reply_t_handler_json vam->result_ready = 1; } -static void vl_api_noprint_control_ping_reply_t_handler - (vl_api_noprint_control_ping_reply_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; - } -} - -static void vl_api_noprint_control_ping_reply_t_handler_json - (vl_api_noprint_control_ping_reply_t * mp) -{ - vat_main_t *vam = &vat_main; - i32 retval = ntohl (mp->retval); - - if (vam->noprint_msg) - { - vam->retval = retval; - vam->result_ready = 1; - return; - } - - if (VAT_JSON_NONE != vam->json_tree.type) - { - vat_json_print (vam->ofp, &vam->json_tree); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - } - else - { - /* just print [] */ - vat_json_init_array (&vam->json_tree); - vat_json_print (vam->ofp, &vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - } - - vam->retval = retval; - vam->result_ready = 1; -} - static void vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp) { @@ -2277,47 +2248,23 @@ static void vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp) { vat_main_t *vam = &vat_main; - locator_msg_t loc; - u8 *tmp_str = 0; + u8 *s = 0; - memset (&loc, 0, sizeof (loc)); - if (vam->noprint_msg) + if (mp->local) { - loc.local = mp->local; - loc.priority = mp->priority; - loc.weight = mp->weight; - if (loc.local) - { - loc.sw_if_index = ntohl (mp->sw_if_index); - } - else - { - loc.is_ipv6 = mp->is_ipv6; - clib_memcpy (loc.ip_address, mp->ip_address, - sizeof (loc.ip_address)); - } - vec_add1 (vam->locator_msg, loc); + s = format (s, "%=16d%=16d%=16d\n", + ntohl (mp->sw_if_index), mp->priority, mp->weight); } else { - if (mp->local) - { - tmp_str = format (tmp_str, "%=16d%=16d%=16d\n", - ntohl (mp->sw_if_index), - mp->priority, mp->weight); - } - else - { - tmp_str = format (tmp_str, "%=16U%=16d%=16d\n", - mp->is_ipv6 ? format_ip6_address : - format_ip4_address, - mp->ip_address, mp->priority, mp->weight); - } - - fformat (vam->ofp, "%s", tmp_str); - - vec_free (tmp_str); + s = format (s, "%=16U%=16d%=16d\n", + mp->is_ipv6 ? format_ip6_address : + format_ip4_address, + mp->ip_address, mp->priority, mp->weight); } + + fformat (vam->ofp, "%v", s); + vec_free (s); } static void @@ -2326,59 +2273,37 @@ vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t * { vat_main_t *vam = &vat_main; vat_json_node_t *node = NULL; - locator_msg_t loc; struct in6_addr ip6; struct in_addr ip4; - memset (&loc, 0, sizeof (loc)); - if (vam->noprint_msg) - { - loc.local = mp->local; - loc.priority = mp->priority; - loc.weight = mp->weight; - if (loc.local) - { - loc.sw_if_index = ntohl (mp->sw_if_index); - } - else - { - loc.is_ipv6 = mp->is_ipv6; - clib_memcpy (loc.ip_address, mp->ip_address, - sizeof (loc.ip_address)); - } - vec_add1 (vam->locator_msg, loc); - return; - } - 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, "local", mp->local ? 1 : 0); + vat_json_object_add_uint (node, "priority", mp->priority); + vat_json_object_add_uint (node, "weight", mp->weight); + if (mp->local) - { - vat_json_object_add_uint (node, "locator_index", - ntohl (mp->sw_if_index)); - } + vat_json_object_add_uint (node, "sw_if_index", + clib_net_to_host_u32 (mp->sw_if_index)); else { if (mp->is_ipv6) { clib_memcpy (&ip6, mp->ip_address, sizeof (ip6)); - vat_json_object_add_ip6 (node, "locator", ip6); + vat_json_object_add_ip6 (node, "address", ip6); } else { clib_memcpy (&ip4, mp->ip_address, sizeof (ip4)); - vat_json_object_add_ip4 (node, "locator", ip4); + vat_json_object_add_ip4 (node, "address", ip4); } } - vat_json_object_add_uint (node, "priority", mp->priority); - vat_json_object_add_uint (node, "weight", mp->weight); } static void @@ -2386,11 +2311,13 @@ vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t * mp) { vat_main_t *vam = &vat_main; - locator_set_msg_t ls; + u8 *ls_name = 0; - ls.locator_set_index = ntohl (mp->locator_set_index); - ls.locator_set_name = format (0, "%s", mp->locator_set_name); - vec_add1 (vam->locator_set_msg, ls); + ls_name = format (0, "%s", mp->ls_name); + + fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index), + ls_name); + vec_free (ls_name); } static void @@ -2398,37 +2325,88 @@ static void (vl_api_lisp_locator_set_details_t * mp) { vat_main_t *vam = &vat_main; - locator_set_msg_t ls; + vat_json_node_t *node = 0; + u8 *ls_name = 0; + + ls_name = format (0, "%s", mp->ls_name); + vec_add1 (ls_name, 0); + + 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); - ls.locator_set_index = ntohl (mp->locator_set_index); - ls.locator_set_name = format (0, "%s", mp->locator_set_name); - vec_add1 (vam->locator_set_msg, ls); + vat_json_init_object (node); + vat_json_object_add_string_copy (node, "ls_name", ls_name); + vat_json_object_add_uint (node, "ls_index", + clib_net_to_host_u32 (mp->ls_index)); + vec_free (ls_name); } -static void -add_lisp_eid_table_entry (vat_main_t * vam, - vl_api_lisp_eid_table_details_t * mp) +static u8 * +format_lisp_flat_eid (u8 * s, va_list * args) +{ + u32 type = va_arg (*args, u32); + u8 *eid = va_arg (*args, u8 *); + u32 eid_len = va_arg (*args, u32); + + switch (type) + { + case 0: + return format (s, "%U/%d", format_ip4_address, eid, eid_len); + case 1: + return format (s, "%U/%d", format_ip6_address, eid, eid_len); + case 2: + return format (s, "%U", format_ethernet_address, eid); + } + return 0; +} + +static u8 * +format_lisp_eid_vat (u8 * s, va_list * args) { - eid_table_t eid_table; + u32 type = va_arg (*args, u32); + u8 *eid = va_arg (*args, u8 *); + u32 eid_len = va_arg (*args, u32); + u8 *seid = va_arg (*args, u8 *); + u32 seid_len = va_arg (*args, u32); + u32 is_src_dst = va_arg (*args, u32); + + if (is_src_dst) + s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len); + + s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len); - memset (&eid_table, 0, sizeof (eid_table)); - eid_table.is_local = mp->is_local; - eid_table.locator_set_index = clib_net_to_host_u32 (mp->locator_set_index); - eid_table.eid_type = mp->eid_type; - eid_table.vni = clib_net_to_host_u32 (mp->vni); - eid_table.eid_prefix_len = mp->eid_prefix_len; - eid_table.ttl = clib_net_to_host_u32 (mp->ttl); - eid_table.action = mp->action; - eid_table.authoritative = mp->authoritative; - clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid)); - vec_add1 (vam->eid_tables, eid_table); + return s; } static void vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp) { vat_main_t *vam = &vat_main; - add_lisp_eid_table_entry (vam, mp); + u8 *s = 0, *eid = 0; + + if (~0 == mp->locator_set_index) + s = format (0, "action: %d", mp->action); + else + s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index)); + + eid = format (0, "%U", format_lisp_eid_vat, + mp->eid_type, + mp->eid, + mp->eid_prefix_len, + mp->seid, mp->seid_prefix_len, mp->is_src_dst); + vec_add1 (eid, 0); + + fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n", + clib_net_to_host_u32 (mp->vni), + eid, + mp->is_local ? "local" : "remote", + s, clib_net_to_host_u32 (mp->ttl), mp->authoritative); + vec_free (s); + vec_free (eid); } static void @@ -2436,7 +2414,35 @@ vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t * mp) { vat_main_t *vam = &vat_main; - add_lisp_eid_table_entry (vam, mp); + vat_json_node_t *node = 0; + u8 *eid = 0; + + 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); + if (~0 == mp->locator_set_index) + vat_json_object_add_uint (node, "action", mp->action); + else + vat_json_object_add_uint (node, "locator_set_index", + clib_net_to_host_u32 (mp->locator_set_index)); + + vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0); + eid = format (0, "%U", format_lisp_eid_vat, + mp->eid_type, + mp->eid, + mp->eid_prefix_len, + mp->seid, mp->seid_prefix_len, mp->is_src_dst); + vec_add1 (eid, 0); + vat_json_object_add_string_copy (node, "eid", eid); + vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni)); + vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl)); + vat_json_object_add_uint (node, "authoritative", (mp->authoritative)); + vec_free (eid); } static void @@ -2596,6 +2602,78 @@ static void vec_free (next_decap_str); } +static void + vl_api_lisp_adjacencies_get_reply_t_handler + (vl_api_lisp_adjacencies_get_reply_t * mp) +{ + vat_main_t *vam = &vat_main; + u32 i, n; + int retval = clib_net_to_host_u32 (mp->retval); + vl_api_lisp_adjacency_t *a; + + if (retval) + goto end; + + n = clib_net_to_host_u32 (mp->count); + + for (i = 0; i < n; i++) + { + a = &mp->adjacencies[i]; + fformat (vam->ofp, "%U %40U\n", + format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len, + format_lisp_flat_eid, a->eid_type, a->reid, + a->reid_prefix_len); + } + +end: + vam->retval = retval; + vam->result_ready = 1; +} + +static void + vl_api_lisp_adjacencies_get_reply_t_handler_json + (vl_api_lisp_adjacencies_get_reply_t * mp) +{ + u8 *s = 0; + vat_main_t *vam = &vat_main; + vat_json_node_t *e = 0, root; + u32 i, n; + int retval = clib_net_to_host_u32 (mp->retval); + vl_api_lisp_adjacency_t *a; + + if (retval) + goto end; + + n = clib_net_to_host_u32 (mp->count); + vat_json_init_array (&root); + + for (i = 0; i < n; i++) + { + e = vat_json_array_add (&root); + a = &mp->adjacencies[i]; + + vat_json_init_object (e); + s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid, + a->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, a->eid_type, a->reid, + a->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_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t * mp) @@ -2723,6 +2801,62 @@ static void vam->result_ready = 1; } +static u8 * +format_lisp_map_request_mode (u8 * s, va_list * args) +{ + u32 mode = va_arg (*args, u32); + + switch (mode) + { + case 0: + return format (0, "dst-only"); + case 1: + return format (0, "src-dst"); + } + return 0; +} + +static void + vl_api_show_lisp_map_request_mode_reply_t_handler + (vl_api_show_lisp_map_request_mode_reply_t * mp) +{ + vat_main_t *vam = &vat_main; + i32 retval = ntohl (mp->retval); + + if (0 <= retval) + { + u32 mode = mp->mode; + fformat (vam->ofp, "map_request_mode: %U\n", + format_lisp_map_request_mode, mode); + } + + vam->retval = retval; + vam->result_ready = 1; +} + +static void + vl_api_show_lisp_map_request_mode_reply_t_handler_json + (vl_api_show_lisp_map_request_mode_reply_t * mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t node; + u8 *s = 0; + u32 mode; + + mode = mp->mode; + s = format (0, "%U", format_lisp_map_request_mode, mode); + vec_add1 (s, 0); + + vat_json_init_object (&node); + vat_json_object_add_string_copy (&node, "map_request_mode", s); + vat_json_print (vam->ofp, &node); + vat_json_free (&node); + + vec_free (s); + vam->retval = ntohl (mp->retval); + vam->result_ready = 1; +} + static void vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp) { @@ -3326,10 +3460,41 @@ static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json vam->result_ready = 1; } +static void vl_api_flow_classify_details_t_handler + (vl_api_flow_classify_details_t * mp) +{ + vat_main_t *vam = &vat_main; + + fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index), + ntohl (mp->table_index)); +} + +static void vl_api_flow_classify_details_t_handler_json + (vl_api_flow_classify_details_t * mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *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); + vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index)); + vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index)); +} + + + #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler #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_lisp_adjacencies_get_reply_t_endian vl_noop_handler +#define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler /* * Generate boilerplate reply handlers, which @@ -3346,6 +3511,9 @@ _(sw_interface_add_del_address_reply) \ _(sw_interface_set_table_reply) \ _(sw_interface_set_vpath_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) \ @@ -3419,6 +3587,7 @@ _(lisp_gpe_enable_disable_reply) \ _(lisp_gpe_add_del_iface_reply) \ _(lisp_enable_disable_reply) \ _(lisp_pitr_set_locator_set_reply) \ +_(lisp_map_request_mode_reply) \ _(lisp_add_del_map_request_itr_rlocs_reply) \ _(lisp_eid_table_add_del_map_reply) \ _(vxlan_gpe_add_del_tunnel_reply) \ @@ -3426,12 +3595,17 @@ _(af_packet_delete_reply) \ _(policer_classify_set_interface_reply) \ _(netmap_create_reply) \ _(netmap_delete_reply) \ -_(ipfix_enable_reply) \ +_(set_ipfix_exporter_reply) \ +_(set_ipfix_classify_stream_reply) \ +_(ipfix_classify_table_add_del_reply) \ +_(flow_classify_set_interface_reply) \ _(pg_capture_reply) \ _(pg_enable_disable_reply) \ _(ip_source_and_port_range_check_add_del_reply) \ _(ip_source_and_port_range_check_interface_add_del_reply)\ -_(delete_subif_reply) +_(delete_subif_reply) \ +_(l2_interface_pbb_tag_rewrite_reply) \ +_(punt_reply) #define _(n) \ static void vl_api_##n##_t_handler \ @@ -3475,7 +3649,6 @@ _(SW_INTERFACE_DETAILS, sw_interface_details) \ _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \ _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \ _(CONTROL_PING_REPLY, control_ping_reply) \ -_(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \ _(CLI_REPLY, cli_reply) \ _(CLI_INBAND_REPLY, cli_inband_reply) \ _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \ @@ -3486,6 +3659,12 @@ _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \ 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) \ @@ -3610,6 +3789,7 @@ _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \ _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \ _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \ _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \ +_(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \ _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \ _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \ _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \ @@ -3619,12 +3799,14 @@ _(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_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \ _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \ _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \ lisp_add_del_map_request_itr_rlocs_reply) \ _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \ lisp_get_map_request_itr_rlocs_reply) \ _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \ +_(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \ _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \ _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \ _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \ @@ -3641,8 +3823,14 @@ _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \ _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \ _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \ _(CLASSIFY_SESSION_DETAILS, classify_session_details) \ -_(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \ -_(IPFIX_DETAILS, ipfix_details) \ +_(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \ +_(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \ +_(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \ +_(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \ +_(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \ +_(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \ +_(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \ +_(FLOW_CLASSIFY_DETAILS, flow_classify_details) \ _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \ _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \ _(PG_CAPTURE_REPLY, pg_capture_reply) \ @@ -3653,7 +3841,9 @@ _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \ ip_source_and_port_range_check_interface_add_del_reply) \ _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \ _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \ -_(DELETE_SUBIF_REPLY, delete_subif_reply) +_(DELETE_SUBIF_REPLY, delete_subif_reply) \ +_(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \ +_(PUNT_REPLY, punt_reply) /* M: construct, but don't yet send a message */ @@ -3706,21 +3896,6 @@ do { \ return -99; \ } while(0); -/* W_L: wait for results, with timeout */ -#define W_L(body) \ -do { \ - timeout = vat_time_now (vam) + 1.0; \ - \ - while (vat_time_now (vam) < timeout) { \ - if (vam->result_ready == 1) { \ - (body); \ - return (vam->retval); \ - } \ - } \ - vam->noprint_msg = 0; \ - return -99; \ -} while(0); - typedef struct { u8 *name; @@ -4325,6 +4500,11 @@ api_sw_interface_dump (vat_main_t * vam) strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1); S; + /* and packet-generator interfaces */ + M (SW_INTERFACE_DUMP, sw_interface_dump); + 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); @@ -4365,6 +4545,12 @@ api_sw_interface_dump (vat_main_t * vam) sizeof (mp->name_filter) - 1); S; + /* and IPSEC tunnel interfaces */ + M (SW_INTERFACE_DUMP, sw_interface_dump); + 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; @@ -4458,16 +4644,235 @@ api_sw_interface_clear_stats (vat_main_t * vam) } static int -api_sw_interface_add_del_address (vat_main_t * vam) +api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam) { unformat_input_t *i = vam->input; - vl_api_sw_interface_add_del_address_t *mp; + vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp; f64 timeout; u32 sw_if_index; u8 sw_if_index_set = 0; - u8 is_add = 1, del_all = 0; - u32 address_length = 0; - u8 v4_address_set = 0; + u32 subport; + u8 subport_set = 0; + u32 pipe; + u8 pipe_set = 0; + u32 profile; + u8 profile_set = 0; + + /* Parse args required to build the message */ + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "sw_if_index %u", &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "subport %u", &subport)) + subport_set = 1; + else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "pipe %u", &pipe)) + pipe_set = 1; + else if (unformat (i, "profile %u", &profile)) + profile_set = 1; + else + break; + } + + if (sw_if_index_set == 0) + { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + if (subport_set == 0) + { + errmsg ("missing subport \n"); + return -99; + } + + if (pipe_set == 0) + { + errmsg ("missing pipe\n"); + return -99; + } + + if (profile_set == 0) + { + errmsg ("missing profile\n"); + return -99; + } + + M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe); + + mp->sw_if_index = ntohl (sw_if_index); + mp->subport = ntohl (subport); + mp->pipe = ntohl (pipe); + mp->profile = ntohl (profile); + + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_set_dpdk_hqos_subport_t *mp; + f64 timeout; + u32 sw_if_index; + u8 sw_if_index_set = 0; + u32 subport; + u8 subport_set = 0; + u32 tb_rate = 1250000000; /* 10GbE */ + u32 tb_size = 1000000; + u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 }; + u32 tc_period = 10; + + /* Parse args required to build the message */ + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "sw_if_index %u", &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "subport %u", &subport)) + subport_set = 1; + else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "rate %u", &tb_rate)) + { + u32 tc_id; + + for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0])); + tc_id++) + tc_rate[tc_id] = tb_rate; + } + else if (unformat (i, "bktsize %u", &tb_size)) + ; + else if (unformat (i, "tc0 %u", &tc_rate[0])) + ; + else if (unformat (i, "tc1 %u", &tc_rate[1])) + ; + else if (unformat (i, "tc2 %u", &tc_rate[2])) + ; + else if (unformat (i, "tc3 %u", &tc_rate[3])) + ; + else if (unformat (i, "period %u", &tc_period)) + ; + else + break; + } + + if (sw_if_index_set == 0) + { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + if (subport_set == 0) + { + errmsg ("missing subport \n"); + return -99; + } + + M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport); + + mp->sw_if_index = ntohl (sw_if_index); + mp->subport = ntohl (subport); + mp->tb_rate = ntohl (tb_rate); + mp->tb_size = ntohl (tb_size); + mp->tc_rate[0] = ntohl (tc_rate[0]); + mp->tc_rate[1] = ntohl (tc_rate[1]); + mp->tc_rate[2] = ntohl (tc_rate[2]); + mp->tc_rate[3] = ntohl (tc_rate[3]); + mp->tc_period = ntohl (tc_period); + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp; + f64 timeout; + u32 sw_if_index; + u8 sw_if_index_set = 0; + u8 entry_set = 0; + u8 tc_set = 0; + u8 queue_set = 0; + u32 entry, tc, queue; + + /* Parse args required to build the message */ + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "sw_if_index %u", &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (i, "entry %d", &entry)) + entry_set = 1; + else if (unformat (i, "tc %d", &tc)) + tc_set = 1; + else if (unformat (i, "queue %d", &queue)) + queue_set = 1; + else + break; + } + + if (sw_if_index_set == 0) + { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + if (entry_set == 0) + { + errmsg ("missing entry \n"); + return -99; + } + + if (tc_set == 0) + { + errmsg ("missing traffic class \n"); + return -99; + } + + if (queue_set == 0) + { + errmsg ("missing queue \n"); + return -99; + } + + M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl); + + mp->sw_if_index = ntohl (sw_if_index); + mp->entry = ntohl (entry); + mp->tc = ntohl (tc); + mp->queue = ntohl (queue); + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_sw_interface_add_del_address (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_add_del_address_t *mp; + f64 timeout; + u32 sw_if_index; + u8 sw_if_index_set = 0; + u8 is_add = 1, del_all = 0; + u32 address_length = 0; + u8 v4_address_set = 0; u8 v6_address_set = 0; ip4_address_t v4address; ip6_address_t v6address; @@ -5362,6 +5767,7 @@ api_ip_add_del_route (vat_main_t * vam) u32 random_seed = 0xdeaddabe; u32 classify_table_index = ~0; u8 is_classify = 0; + u8 resolve_host = 0, resolve_attached = 0; /* Parse args required to build the message */ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) @@ -5417,6 +5823,10 @@ api_ip_add_del_route (vat_main_t * vam) is_add = 1; else if (unformat (i, "not-last")) not_last = 1; + else if (unformat (i, "resolve-via-host")) + resolve_host = 1; + else if (unformat (i, "resolve-via-attached")) + resolve_attached = 1; else if (unformat (i, "multipath")) is_multipath = 1; else if (unformat (i, "vrf %d", &vrf_id)) @@ -5513,6 +5923,8 @@ api_ip_add_del_route (vat_main_t * vam) mp->is_local = is_local; mp->is_classify = is_classify; mp->is_multipath = is_multipath; + mp->is_resolve_host = resolve_host; + mp->is_resolve_attached = resolve_attached; mp->not_last = not_last; mp->next_hop_weight = next_hop_weight; mp->dst_address_length = dst_address_length; @@ -5542,6 +5954,9 @@ api_ip_add_del_route (vat_main_t * vam) } /* send it... */ S; + /* If we receive SIGTERM, stop now... */ + if (vam->do_exit) + break; } /* When testing multiple add/del ops, use a control-ping to sync */ @@ -5574,6 +5989,10 @@ api_ip_add_del_route (vat_main_t * vam) vam->async_errors = 0; after = vat_time_now (vam); + /* slim chance, but we might have eaten SIGTERM on the first iteration */ + if (j > 0) + count = j; + fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n", count, after - before, count / (after - before)); } @@ -7492,16 +7911,147 @@ api_sr_multicast_map_add_del (vat_main_t * vam) } +#define foreach_tcp_proto_field \ +_(src_port) \ +_(dst_port) + +#define foreach_udp_proto_field \ +_(src_port) \ +_(dst_port) + #define foreach_ip4_proto_field \ _(src_address) \ _(dst_address) \ _(tos) \ -_(length) \ +_(length) \ _(fragment_id) \ _(ttl) \ _(protocol) \ _(checksum) +uword +unformat_tcp_mask (unformat_input_t * input, va_list * args) +{ + u8 **maskp = va_arg (*args, u8 **); + u8 *mask = 0; + u8 found_something = 0; + tcp_header_t *tcp; + +#define _(a) u8 a=0; + foreach_tcp_proto_field; +#undef _ + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (0); +#define _(a) else if (unformat (input, #a)) a=1; + foreach_tcp_proto_field +#undef _ + else + break; + } + +#define _(a) found_something += a; + foreach_tcp_proto_field; +#undef _ + + if (found_something == 0) + return 0; + + vec_validate (mask, sizeof (*tcp) - 1); + + tcp = (tcp_header_t *) mask; + +#define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a)); + foreach_tcp_proto_field; +#undef _ + + *maskp = mask; + return 1; +} + +uword +unformat_udp_mask (unformat_input_t * input, va_list * args) +{ + u8 **maskp = va_arg (*args, u8 **); + u8 *mask = 0; + u8 found_something = 0; + udp_header_t *udp; + +#define _(a) u8 a=0; + foreach_udp_proto_field; +#undef _ + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (0); +#define _(a) else if (unformat (input, #a)) a=1; + foreach_udp_proto_field +#undef _ + else + break; + } + +#define _(a) found_something += a; + foreach_udp_proto_field; +#undef _ + + if (found_something == 0) + return 0; + + vec_validate (mask, sizeof (*udp) - 1); + + udp = (udp_header_t *) mask; + +#define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a)); + foreach_udp_proto_field; +#undef _ + + *maskp = mask; + return 1; +} + +typedef struct +{ + u16 src_port, dst_port; +} tcpudp_header_t; + +uword +unformat_l4_mask (unformat_input_t * input, va_list * args) +{ + u8 **maskp = va_arg (*args, u8 **); + u16 src_port = 0, dst_port = 0; + tcpudp_header_t *tcpudp; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "tcp %U", unformat_tcp_mask, maskp)) + return 1; + else if (unformat (input, "udp %U", unformat_udp_mask, maskp)) + return 1; + else if (unformat (input, "src_port")) + src_port = 0xFFFF; + else if (unformat (input, "dst_port")) + dst_port = 0xFFFF; + else + return 0; + } + + if (!src_port && !dst_port) + return 0; + + u8 *mask = 0; + vec_validate (mask, sizeof (tcpudp_header_t) - 1); + + tcpudp = (tcpudp_header_t *) mask; + tcpudp->src_port = src_port; + tcpudp->dst_port = dst_port; + + *maskp = mask; + + return 1; +} + uword unformat_ip4_mask (unformat_input_t * input, va_list * args) { @@ -7779,6 +8329,7 @@ unformat_classify_mask (unformat_input_t * input, va_list * args) u8 *mask = 0; u8 *l2 = 0; u8 *l3 = 0; + u8 *l4 = 0; int i; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) @@ -7789,13 +8340,23 @@ unformat_classify_mask (unformat_input_t * input, va_list * args) ; else if (unformat (input, "l3 %U", unformat_l3_mask, &l3)) ; + else if (unformat (input, "l4 %U", unformat_l4_mask, &l4)) + ; else break; } - if (mask || l2 || l3) + if (l4 && !l3) { - if (l2 || l3) + vec_free (mask); + vec_free (l2); + vec_free (l4); + return 0; + } + + if (mask || l2 || l3 || l4) + { + if (l2 || l3 || l4) { /* "With a free Ethernet header in every package" */ if (l2 == 0) @@ -7806,6 +8367,11 @@ unformat_classify_mask (unformat_input_t * input, va_list * args) vec_append (mask, l3); vec_free (l3); } + if (vec_len (l4)) + { + vec_append (mask, l4); + vec_free (l4); + } } /* Scan forward looking for the first significant mask octet */ @@ -7876,7 +8442,6 @@ out: } #define foreach_ip_next \ -_(miss, MISS) \ _(drop, DROP) \ _(local, LOCAL) \ _(rewrite, REWRITE) @@ -8047,26 +8612,57 @@ api_classify_add_del_table (vat_main_t * vam) } uword -unformat_ip4_match (unformat_input_t * input, va_list * args) +unformat_l4_match (unformat_input_t * input, va_list * args) { u8 **matchp = va_arg (*args, u8 **); - u8 *match = 0; - ip4_header_t *ip; - int version = 0; - u32 version_val; - int hdr_length = 0; - u32 hdr_length_val; - int src = 0, dst = 0; - ip4_address_t src_val, dst_val; - int proto = 0; - u32 proto_val; - int tos = 0; - u32 tos_val; - int length = 0; - u32 length_val; - int fragment_id = 0; - u32 fragment_id_val; - int ttl = 0; + + u8 *proto_header = 0; + int src_port = 0; + int dst_port = 0; + + tcpudp_header_t h; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "src_port %d", &src_port)) + ; + else if (unformat (input, "dst_port %d", &dst_port)) + ; + else + return 0; + } + + h.src_port = clib_host_to_net_u16 (src_port); + h.dst_port = clib_host_to_net_u16 (dst_port); + vec_validate (proto_header, sizeof (h) - 1); + memcpy (proto_header, &h, sizeof (h)); + + *matchp = proto_header; + + return 1; +} + +uword +unformat_ip4_match (unformat_input_t * input, va_list * args) +{ + u8 **matchp = va_arg (*args, u8 **); + u8 *match = 0; + ip4_header_t *ip; + int version = 0; + u32 version_val; + int hdr_length = 0; + u32 hdr_length_val; + int src = 0, dst = 0; + ip4_address_t src_val, dst_val; + int proto = 0; + u32 proto_val; + int tos = 0; + u32 tos_val; + int length = 0; + u32 length_val; + int fragment_id = 0; + u32 fragment_id_val; + int ttl = 0; int ttl_val; int checksum = 0; u32 checksum_val; @@ -8130,13 +8726,13 @@ unformat_ip4_match (unformat_input_t * input, va_list * args) ip->tos = tos_val; if (length) - ip->length = length_val; + ip->length = clib_host_to_net_u16 (length_val); if (ttl) ip->ttl = ttl_val; if (checksum) - ip->checksum = checksum_val; + ip->checksum = clib_host_to_net_u16 (checksum_val); *matchp = match; return 1; @@ -8391,6 +8987,7 @@ unformat_classify_match (unformat_input_t * input, va_list * args) u8 *match = 0; u8 *l2 = 0; u8 *l3 = 0; + u8 *l4 = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { @@ -8400,13 +8997,23 @@ unformat_classify_match (unformat_input_t * input, va_list * args) ; else if (unformat (input, "l3 %U", unformat_l3_match, &l3)) ; + else if (unformat (input, "l4 %U", unformat_l4_match, &l4)) + ; else break; } - if (match || l2 || l3) + if (l4 && !l3) + { + vec_free (match); + vec_free (l2); + vec_free (l4); + return 0; + } + + if (match || l2 || l3 || l4) { - if (l2 || l3) + if (l2 || l3 || l4) { /* "Win a free Ethernet header in every packet" */ if (l2 == 0) @@ -8417,6 +9024,11 @@ unformat_classify_match (unformat_input_t * input, va_list * args) vec_append_aligned (match, l3, sizeof (u32x4)); vec_free (l3); } + if (vec_len (l4)) + { + vec_append_aligned (match, l4, sizeof (u32x4)); + vec_free (l4); + } } /* Make sure the vector is big enough even if key is all 0's */ @@ -8618,10 +9230,10 @@ api_classify_set_interface_l2_tables (vat_main_t * vam) } static int -api_ipfix_enable (vat_main_t * vam) +api_set_ipfix_exporter (vat_main_t * vam) { unformat_input_t *i = vam->input; - vl_api_ipfix_enable_t *mp; + vl_api_set_ipfix_exporter_t *mp; ip4_address_t collector_address; u8 collector_address_set = 0; u32 collector_port = ~0; @@ -8630,6 +9242,7 @@ api_ipfix_enable (vat_main_t * vam) u32 vrf_id = ~0; u32 path_mtu = ~0; u32 template_interval = ~0; + u8 udp_checksum = 0; f64 timeout; while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) @@ -8648,6 +9261,8 @@ api_ipfix_enable (vat_main_t * vam) ; else if (unformat (i, "template_interval %d", &template_interval)) ; + else if (unformat (i, "udp_checksum")) + udp_checksum = 1; else break; } @@ -8664,7 +9279,7 @@ api_ipfix_enable (vat_main_t * vam) return -99; } - M (IPFIX_ENABLE, ipfix_enable); + M (SET_IPFIX_EXPORTER, set_ipfix_exporter); memcpy (mp->collector_address, collector_address.data, sizeof (collector_address.data)); @@ -8673,6 +9288,101 @@ api_ipfix_enable (vat_main_t * vam) mp->vrf_id = htonl (vrf_id); mp->path_mtu = htonl (path_mtu); mp->template_interval = htonl (template_interval); + mp->udp_checksum = udp_checksum; + + S; + W; + /* NOTREACHED */ +} + +static int +api_set_ipfix_classify_stream (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_set_ipfix_classify_stream_t *mp; + u32 domain_id = 0; + u32 src_port = UDP_DST_PORT_ipfix; + f64 timeout; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "domain %d", &domain_id)) + ; + else if (unformat (i, "src_port %d", &src_port)) + ; + else + { + errmsg ("unknown input `%U'", format_unformat_error, i); + return -99; + } + } + + M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream); + + mp->domain_id = htonl (domain_id); + mp->src_port = htons ((u16) src_port); + + S; + W; + /* NOTREACHED */ +} + +static int +api_ipfix_classify_table_add_del (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_ipfix_classify_table_add_del_t *mp; + int is_add = -1; + u32 classify_table_index = ~0; + u8 ip_version = 0; + u8 transport_protocol = 255; + f64 timeout; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "add")) + is_add = 1; + else if (unformat (i, "del")) + is_add = 0; + else if (unformat (i, "table %d", &classify_table_index)) + ; + else if (unformat (i, "ip4")) + ip_version = 4; + else if (unformat (i, "ip6")) + ip_version = 6; + else if (unformat (i, "tcp")) + transport_protocol = 6; + else if (unformat (i, "udp")) + transport_protocol = 17; + else + { + errmsg ("unknown input `%U'", format_unformat_error, i); + return -99; + } + } + + if (is_add == -1) + { + errmsg ("expecting: add|del"); + return -99; + } + if (classify_table_index == ~0) + { + errmsg ("classifier table not specified"); + return -99; + } + if (ip_version == 0) + { + errmsg ("IP version not specified"); + return -99; + } + + M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del); + + mp->is_add = is_add; + mp->table_id = htonl (classify_table_index); + mp->ip_version = ip_version; + mp->transport_protocol = transport_protocol; S; W; @@ -9364,6 +10074,7 @@ api_gre_add_del_tunnel (vat_main_t * vam) f64 timeout; ip4_address_t src4, dst4; u8 is_add = 1; + u8 teb = 0; u8 src_set = 0; u8 dst_set = 0; u32 outer_fib_id = 0; @@ -9378,6 +10089,8 @@ api_gre_add_del_tunnel (vat_main_t * vam) dst_set = 1; else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id)) ; + else if (unformat (line_input, "teb")) + teb = 1; else { errmsg ("parse error '%U'\n", format_unformat_error, line_input); @@ -9403,6 +10116,7 @@ api_gre_add_del_tunnel (vat_main_t * vam) clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4)); mp->outer_fib_id = ntohl (outer_fib_id); mp->is_add = is_add; + mp->teb = teb; S; W; @@ -9415,10 +10129,11 @@ static void vl_api_gre_tunnel_details_t_handler { vat_main_t *vam = &vat_main; - fformat (vam->ofp, "%11d%15U%15U%14d\n", + fformat (vam->ofp, "%11d%15U%15U%6d%14d\n", ntohl (mp->sw_if_index), format_ip4_address, &mp->src_address, - format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id)); + format_ip4_address, &mp->dst_address, + mp->teb, ntohl (mp->outer_fib_id)); } static void vl_api_gre_tunnel_details_t_handler_json @@ -9441,6 +10156,7 @@ static void vl_api_gre_tunnel_details_t_handler_json vat_json_object_add_ip4 (node, "src_address", ip4); clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4)); vat_json_object_add_ip4 (node, "dst_address", ip4); + vat_json_object_add_uint (node, "teb", mp->teb); vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id)); } @@ -9469,8 +10185,9 @@ api_gre_tunnel_dump (vat_main_t * vam) if (!vam->json_output) { - fformat (vam->ofp, "%11s%15s%15s%14s\n", - "sw_if_index", "src_address", "dst_address", "outer_fib_id"); + fformat (vam->ofp, "%11s%15s%15s%6s%14s\n", + "sw_if_index", "src_address", "dst_address", "teb", + "outer_fib_id"); } /* Get list of gre-tunnel interfaces */ @@ -11716,6 +12433,7 @@ api_lisp_add_del_locator_set (vat_main_t * vam) u8 locator_set_name_set = 0; ls_locator_t locator, *locators = 0; u32 sw_if_index, priority, weight; + u32 data_len = 0; /* Parse args required to build the message */ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) @@ -11764,8 +12482,10 @@ api_lisp_add_del_locator_set (vat_main_t * vam) } vec_add1 (locator_set_name, 0); + data_len = sizeof (ls_locator_t) * vec_len (locators); + /* Construct the API message */ - M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set); + M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len); mp->is_add = is_add; clib_memcpy (mp->locator_set_name, locator_set_name, @@ -11774,8 +12494,7 @@ api_lisp_add_del_locator_set (vat_main_t * vam) mp->locator_num = clib_host_to_net_u32 (vec_len (locators)); if (locators) - clib_memcpy (mp->locators, locators, - (sizeof (ls_locator_t) * vec_len (locators))); + clib_memcpy (mp->locators, locators, data_len); vec_free (locators); /* send it... */ @@ -12285,6 +13004,59 @@ api_lisp_enable_disable (vat_main_t * vam) return 0; } +static int +api_show_lisp_map_request_mode (vat_main_t * vam) +{ + f64 timeout = ~0; + vl_api_show_lisp_map_request_mode_t *mp; + + M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode); + + /* send */ + S; + + /* wait for reply */ + W; + + return 0; +} + +static int +api_lisp_map_request_mode (vat_main_t * vam) +{ + f64 timeout = ~0; + unformat_input_t *input = vam->input; + vl_api_lisp_map_request_mode_t *mp; + u8 mode = 0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "dst-only")) + mode = 0; + else if (unformat (input, "src-dst")) + mode = 1; + else + { + errmsg ("parse error '%U'", format_unformat_error, input); + return -99; + } + } + + M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode); + + mp->mode = mode; + + /* send */ + S; + + /* wait for reply */ + W; + + /* notreached */ + return 0; +} + /** * Enable/disable LISP proxy ITR. * @@ -12415,6 +13187,35 @@ api_lisp_eid_table_add_del_map (vat_main_t * vam) return 0; } +uword +unformat_negative_mapping_action (unformat_input_t * input, va_list * args) +{ + u32 *action = va_arg (*args, u32 *); + u8 *s = 0; + + if (unformat (input, "%s", &s)) + { + if (!strcmp ((char *) s, "no-action")) + action[0] = 0; + else if (!strcmp ((char *) s, "natively-forward")) + action[0] = 1; + else if (!strcmp ((char *) s, "send-map-request")) + action[0] = 2; + else if (!strcmp ((char *) s, "drop")) + action[0] = 3; + else + { + clib_warning ("invalid action: '%s'", s); + action[0] = 3; + } + } + else + return 0; + + vec_free (s); + return 1; +} + /** * Add/del remote mapping to/from LISP control plane * @@ -12428,11 +13229,10 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam) vl_api_lisp_add_del_remote_mapping_t *mp; f64 timeout = ~0; u32 vni = 0; - //TODO: seid need remove lisp_eid_vat_t _eid, *eid = &_eid; lisp_eid_vat_t _seid, *seid = &_seid; - u8 is_add = 1, del_all = 0, eid_set = 0; - u32 action = ~0, p, w; + u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0; + u32 action = ~0, p, w, data_len; ip4_address_t rloc4; ip6_address_t rloc6; rloc_t *rlocs = 0, rloc, *curr_rloc = 0; @@ -12454,13 +13254,13 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam) { is_add = 1; } - else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid)) + else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid)) { eid_set = 1; } - else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid)) + else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid)) { - //TODO: Need remove, but first must be remove from CSIT test + seid_set = 1; } else if (unformat (input, "vni %d", &vni)) { @@ -12490,7 +13290,8 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam) vec_add1 (rlocs, rloc); curr_rloc = &rlocs[vec_len (rlocs) - 1]; } - else if (unformat (input, "action %d", &action)) + else if (unformat (input, "action %U", + unformat_negative_mapping_action, &action)) { ; } @@ -12513,17 +13314,22 @@ api_lisp_add_del_remote_mapping (vat_main_t * vam) return -99; } - M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping); + data_len = vec_len (rlocs) * sizeof (rloc_t); + + M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len); mp->is_add = is_add; mp->vni = htonl (vni); mp->action = (u8) action; + mp->is_src_dst = seid_set; mp->eid_len = eid->len; + mp->seid_len = seid->len; mp->del_all = del_all; mp->eid_type = eid->type; lisp_eid_put_vat (mp->eid, eid->addr, eid->type); + lisp_eid_put_vat (mp->seid, seid->addr, seid->type); mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs)); - clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs))); + clib_memcpy (mp->rlocs, rlocs, data_len); vec_free (rlocs); /* send it... */ @@ -12550,15 +13356,15 @@ api_lisp_add_del_adjacency (vat_main_t * vam) vl_api_lisp_add_del_adjacency_t *mp; f64 timeout = ~0; u32 vni = 0; - ip4_address_t seid4, deid4; - ip6_address_t seid6, deid6; - u8 deid_mac[6] = { 0 }; - u8 seid_mac[6] = { 0 }; - u8 deid_type, seid_type; - u32 seid_len = 0, deid_len = 0, len; + ip4_address_t leid4, reid4; + ip6_address_t leid6, reid6; + u8 reid_mac[6] = { 0 }; + u8 leid_mac[6] = { 0 }; + u8 reid_type, leid_type; + u32 leid_len = 0, reid_len = 0, len; u8 is_add = 1; - seid_type = deid_type = (u8) ~ 0; + leid_type = reid_type = (u8) ~ 0; /* Parse args required to build the message */ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) @@ -12571,39 +13377,39 @@ api_lisp_add_del_adjacency (vat_main_t * vam) { is_add = 1; } - else if (unformat (input, "deid %U/%d", unformat_ip4_address, - &deid4, &len)) + else if (unformat (input, "reid %U/%d", unformat_ip4_address, + &reid4, &len)) { - deid_type = 0; /* ipv4 */ - deid_len = len; + reid_type = 0; /* ipv4 */ + reid_len = len; } - else if (unformat (input, "deid %U/%d", unformat_ip6_address, - &deid6, &len)) + else if (unformat (input, "reid %U/%d", unformat_ip6_address, + &reid6, &len)) { - deid_type = 1; /* ipv6 */ - deid_len = len; + reid_type = 1; /* ipv6 */ + reid_len = len; } - else if (unformat (input, "deid %U", unformat_ethernet_address, - deid_mac)) + else if (unformat (input, "reid %U", unformat_ethernet_address, + reid_mac)) { - deid_type = 2; /* mac */ + reid_type = 2; /* mac */ } - else if (unformat (input, "seid %U/%d", unformat_ip4_address, - &seid4, &len)) + else if (unformat (input, "leid %U/%d", unformat_ip4_address, + &leid4, &len)) { - seid_type = 0; /* ipv4 */ - seid_len = len; + leid_type = 0; /* ipv4 */ + leid_len = len; } - else if (unformat (input, "seid %U/%d", unformat_ip6_address, - &seid6, &len)) + else if (unformat (input, "leid %U/%d", unformat_ip6_address, + &leid6, &len)) { - seid_type = 1; /* ipv6 */ - seid_len = len; + leid_type = 1; /* ipv6 */ + leid_len = len; } - else if (unformat (input, "seid %U", unformat_ethernet_address, - seid_mac)) + else if (unformat (input, "leid %U", unformat_ethernet_address, + leid_mac)) { - seid_type = 2; /* mac */ + leid_type = 2; /* mac */ } else if (unformat (input, "vni %d", &vni)) { @@ -12616,38 +13422,38 @@ api_lisp_add_del_adjacency (vat_main_t * vam) } } - if ((u8) ~ 0 == deid_type) + if ((u8) ~ 0 == reid_type) { errmsg ("missing params!"); return -99; } - if (seid_type != deid_type) + if (leid_type != reid_type) { - errmsg ("source and destination EIDs are of different types!"); + errmsg ("remote and local EIDs are of different types!"); return -99; } M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency); mp->is_add = is_add; mp->vni = htonl (vni); - mp->seid_len = seid_len; - mp->deid_len = deid_len; - mp->eid_type = deid_type; + mp->leid_len = leid_len; + mp->reid_len = reid_len; + mp->eid_type = reid_type; switch (mp->eid_type) { case 0: - clib_memcpy (mp->seid, &seid4, sizeof (seid4)); - clib_memcpy (mp->deid, &deid4, sizeof (deid4)); + clib_memcpy (mp->leid, &leid4, sizeof (leid4)); + clib_memcpy (mp->reid, &reid4, sizeof (reid4)); break; case 1: - clib_memcpy (mp->seid, &seid6, sizeof (seid6)); - clib_memcpy (mp->deid, &deid6, sizeof (deid6)); + clib_memcpy (mp->leid, &leid6, sizeof (leid6)); + clib_memcpy (mp->reid, &reid6, sizeof (reid6)); break; case 2: - clib_memcpy (mp->seid, seid_mac, 6); - clib_memcpy (mp->deid, deid_mac, 6); + clib_memcpy (mp->leid, leid_mac, 6); + clib_memcpy (mp->reid, reid_mac, 6); break; default: errmsg ("unknown EID type %d!", mp->eid_type); @@ -12803,382 +13609,136 @@ api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam) } static int -lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index, - u8 filter) +api_lisp_locator_dump (vat_main_t * vam) { + unformat_input_t *input = vam->input; vl_api_lisp_locator_dump_t *mp; f64 timeout = ~0; + u8 is_index_set = 0, is_name_set = 0; + u8 *ls_name = 0; + u32 ls_index = ~0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "ls_name %_%v%_", &ls_name)) + { + is_name_set = 1; + } + else if (unformat (input, "ls_index %d", &ls_index)) + { + is_index_set = 1; + } + else + { + errmsg ("parse error '%U'", format_unformat_error, input); + return -99; + } + } + + if (!is_index_set && !is_name_set) + { + errmsg ("error: expected one of index or name!\n"); + return -99; + } + + if (is_index_set && is_name_set) + { + errmsg ("error: only one param expected!\n"); + return -99; + } + + if (vec_len (ls_name) > 62) + { + errmsg ("error: locator set name too long!"); + return -99; + } + + if (!vam->json_output) + { + fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority", + "weight"); + } M (LISP_LOCATOR_DUMP, lisp_locator_dump); + mp->is_index_set = is_index_set; - mp->locator_set_index = htonl (locator_set_index); - mp->filter = filter; + if (is_index_set) + mp->ls_index = clib_host_to_net_u32 (ls_index); + else + { + vec_add1 (ls_name, 0); + strncpy ((char *) mp->ls_name, (char *) ls_name, + sizeof (mp->ls_name) - 1); + } /* send it... */ S; /* Use a control ping for synchronization */ { - vl_api_noprint_control_ping_t *mp; - M (NOPRINT_CONTROL_PING, noprint_control_ping); + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); S; } /* Wait for a reply... */ W; -} - -static inline void -clean_locator_set_message (vat_main_t * vam) -{ - locator_set_msg_t *ls = 0; - - vec_foreach (ls, vam->locator_set_msg) - { - vec_free (ls->locator_set_name); - } - vec_free (vam->locator_set_msg); + /* NOTREACHED */ + return 0; } static int -print_locator_in_locator_set (vat_main_t * vam, u8 filter) +api_lisp_locator_set_dump (vat_main_t * vam) { - locator_set_msg_t *ls; - locator_msg_t *loc; - u8 *tmp_str = 0; - int i = 0, ret = 0; - - vec_foreach (ls, vam->locator_set_msg) - { - ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter); - if (ret) - { - vec_free (vam->locator_msg); - clean_locator_set_message (vam); - return ret; - } + vl_api_lisp_locator_set_dump_t *mp; + unformat_input_t *input = vam->input; + f64 timeout = ~0; + u8 filter = 0; - tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name, - ls->locator_set_index, - vec_len (vam->locator_msg) ? "" : "\n"); - i = 0; - vec_foreach (loc, vam->locator_msg) + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (i) + if (unformat (input, "local")) { - tmp_str = format (tmp_str, "%=37s", " "); + filter = 1; } - if (loc->local) + else if (unformat (input, "remote")) { - tmp_str = format (tmp_str, "%=16d%=16d%=16d\n", - loc->sw_if_index, loc->priority, loc->weight); + filter = 2; } else { - tmp_str = format (tmp_str, "%=16U%=16d%=16d\n", - loc->is_ipv6 ? format_ip6_address : - format_ip4_address, - loc->ip_address, loc->priority, loc->weight); + errmsg ("parse error '%U'", format_unformat_error, input); + return -99; } - i++; } - fformat (vam->ofp, "%s", tmp_str); - vec_free (tmp_str); - vec_free (vam->locator_msg); - } - - clean_locator_set_message (vam); - - return ret; -} - -static int -json_locator_in_locator_set (vat_main_t * vam, u8 filter) -{ - locator_set_msg_t *ls; - locator_msg_t *loc; - vat_json_node_t *node = NULL; - vat_json_node_t *locator_array; - vat_json_node_t *locator; - struct in6_addr ip6; - struct in_addr ip4; - int ret = 0; - - if (!vec_len (vam->locator_set_msg)) + if (!vam->json_output) { - /* just print [] */ - vat_json_init_array (&vam->json_tree); - vat_json_print (vam->ofp, &vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - return ret; + fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name"); } - if (VAT_JSON_ARRAY != vam->json_tree.type) - { - ASSERT (VAT_JSON_NONE == vam->json_tree.type); - vat_json_init_array (&vam->json_tree); - } + M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump); - vec_foreach (ls, vam->locator_set_msg) - { - ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter); - if (ret) - { - vec_free (ls->locator_set_name); - vec_free (vam->locator_msg); - vec_free (vam->locator_set_msg); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - return ret; - } + mp->filter = filter; - node = vat_json_array_add (&vam->json_tree); - vat_json_init_object (node); - - vat_json_object_add_uint (node, "locator-set-index", - ls->locator_set_index); - vat_json_object_add_string_copy (node, "locator-set", - ls->locator_set_name); - locator_array = vat_json_object_add_list (node, "locator"); - vec_foreach (loc, vam->locator_msg) - { - locator = vat_json_array_add (locator_array); - vat_json_init_object (locator); - if (loc->local) - { - vat_json_object_add_uint (locator, "locator-index", - loc->sw_if_index); - } - else - { - if (loc->is_ipv6) - { - clib_memcpy (&ip6, loc->ip_address, sizeof (ip6)); - vat_json_object_add_ip6 (locator, "locator", ip6); - } - else - { - clib_memcpy (&ip4, loc->ip_address, sizeof (ip4)); - vat_json_object_add_ip4 (locator, "locator", ip4); - } - } - vat_json_object_add_uint (locator, "priority", loc->priority); - vat_json_object_add_uint (locator, "weight", loc->weight); - } - - vec_free (ls->locator_set_name); - vec_free (vam->locator_msg); - } - - vat_json_print (vam->ofp, &vam->json_tree); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - - vec_free (vam->locator_set_msg); - - return ret; -} - -static int -get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set, - u32 * locator_set_index) -{ - locator_set_msg_t *ls; - int ret = 0; - - *locator_set_index = ~0; - - if (!vec_len (vam->locator_set_msg)) - { - return ret; - } - - vec_foreach (ls, vam->locator_set_msg) - { - if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name)) - { - *locator_set_index = ls->locator_set_index; - vec_free (vam->locator_set_msg); - return ret; - } - } - - vec_free (vam->locator_set_msg); - - return ret; -} - -static int -get_locator_set_index (vat_main_t * vam, u8 * locator_set, - u32 * locator_set_index) -{ - vl_api_lisp_locator_set_dump_t *mp; - f64 timeout = ~0; - - M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump); - /* send it... */ - S; + /* send it... */ + S; /* Use a control ping for synchronization */ { - vl_api_noprint_control_ping_t *mp; - M (NOPRINT_CONTROL_PING, noprint_control_ping); - S; - } - - vam->noprint_msg = 1; - /* Wait for a reply... */ - /* *INDENT-OFF* */ - W_L - ({ - get_locator_set_index_from_msg (vam, locator_set, locator_set_index); - vam->noprint_msg = 0; - }); - /* *INDENT-ON* */ - - /* NOTREACHED */ - return 0; -} - -static inline int -lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set, - u8 filter) -{ - int ret = 0; - - ASSERT (vam); - - if (!vam->json_output) - { - fformat (vam->ofp, "%=20s%=16s%=16s\n", - "locator", "priority", "weight"); - } - - if (locator_set) - { - ret = get_locator_set_index (vam, locator_set, &locator_set_index); - } - - if (!ret && ~0 == locator_set_index) - { - return -99; - } - - ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter); - - return ret; -} - -static int -lisp_locator_set_dump (vat_main_t * vam, u8 filter) -{ - vl_api_lisp_locator_set_dump_t *mp; - f64 timeout = ~0; - - if (!vam->json_output) - { - fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n", - "locator-set", "locator-set-index", "locator", "priority", - "weight"); - } - - vam->noprint_msg = 1; - - M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump); - - mp->filter = filter; - - /* send it... */ - S; - - /* Use a control ping for synchronization */ - { - vl_api_noprint_control_ping_t *mp; - M (NOPRINT_CONTROL_PING, noprint_control_ping); + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); S; } - /* Wait for a reply... */ - /* *INDENT-OFF* */ - W_L - ({ - if (vam->noprint_msg) - { - if (!vam->json_output) - { - print_locator_in_locator_set(vam, filter); - } - else - { - json_locator_in_locator_set(vam, filter); - } - } - vam->noprint_msg = 0; - }); - /* *INDENT-ON* */ + W; /* NOTREACHED */ return 0; } -static int -api_lisp_locator_set_dump (vat_main_t * vam) -{ - unformat_input_t *input = vam->input; - vam->noprint_msg = 0; - u32 locator_set_index = ~0; - u8 locator_set_index_set = 0; - u8 *locator_set = 0; - u8 locator_set_set = 0; - u8 filter = 0; - int ret = 0; - - /* Parse args required to build the message */ - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "locator-set-index %u", &locator_set_index)) - { - locator_set_index_set = 1; - } - else if (unformat (input, "locator-set %s", &locator_set)) - { - locator_set_set = 1; - } - else if (unformat (input, "local")) - { - filter = 1; - } - else if (unformat (input, "remote")) - { - filter = 2; - } - else - { - break; - } - } - - if (locator_set_index_set && locator_set_set) - { - errmsg ("use only input parameter!\n"); - return -99; - } - - if (locator_set_index_set || locator_set_set) - { - ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter); - } - else - { - ret = lisp_locator_set_dump (vam, filter); - } - - vec_free (locator_set); - - return ret; -} - static int api_lisp_eid_table_map_dump (vat_main_t * vam) { @@ -13267,412 +13827,6 @@ api_lisp_eid_table_vni_dump (vat_main_t * vam) return 0; } -static int -get_locator_set (vat_main_t * vam) -{ - vl_api_lisp_locator_set_dump_t *mp; - f64 timeout = ~0; - - M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump); - /* send it... */ - S; - - /* Use a control ping for synchronization */ - { - vl_api_noprint_control_ping_t *mp; - M (NOPRINT_CONTROL_PING, noprint_control_ping); - S; - } - - /* Wait for a reply... */ - W; - - /* NOTREACHED */ - return 0; -} - -static inline u8 * -format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table, - int *ret) -{ - u8 *(*format_eid) (u8 *, va_list *) = 0; - - ASSERT (vam != NULL); - ASSERT (eid_table != NULL); - - if (ret) - { - *ret = 0; - } - - switch (eid_table->eid_type) - { - case 0: - case 1: - format_eid = (eid_table->eid_type ? format_ip6_address : - format_ip4_address); - str = format (0, "[%d] %U/%d", eid_table->vni, - format_eid, eid_table->eid, eid_table->eid_prefix_len); - break; - case 2: - str = format (0, "[%d] %U", eid_table->vni, - format_ethernet_address, eid_table->eid); - break; - default: - errmsg ("unknown EID type %d!", eid_table->eid_type); - if (ret) - { - *ret = -99; - } - return 0; - } - - return str; -} - -static inline u8 * -format_locator_set_for_eid_table (vat_main_t * vam, u8 * str, - eid_table_t * eid_table) -{ - locator_set_msg_t *ls = 0; - - ASSERT (vam != NULL); - ASSERT (eid_table != NULL); - - if (eid_table->is_local) - { - vec_foreach (ls, vam->locator_set_msg) - { - if (ls->locator_set_index == eid_table->locator_set_index) - { - str = format (0, "local(%s)", ls->locator_set_name); - return str; - } - } - - str = format (0, "local(N/A)"); - } - else - { - str = format (0, "remote"); - } - - return str; -} - -static inline u8 * -format_locator_for_eid_table (vat_main_t * vam, u8 * str, - eid_table_t * eid_table) -{ - locator_msg_t *loc = 0; - int first_line = 1; - - ASSERT (vam != NULL); - ASSERT (eid_table != NULL); - - if (~0 == eid_table->locator_set_index) - { - return format (0, "action: %d\n", eid_table->action); - } - - vec_foreach (loc, vam->locator_msg) - { - if (!first_line) - { - if (loc->local) - { - str = format (str, "%-55s%-d\n", " ", loc->sw_if_index); - } - else - { - str = format (str, "%=55s%-U\n", " ", - loc->is_ipv6 ? format_ip6_address : - format_ip4_address, loc->ip_address); - } - - continue; - } - - if (loc->local) - { - str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index, - eid_table->ttl, eid_table->authoritative); - } - else - { - str = format (str, "%-30U%-20u%-u\n", - loc->is_ipv6 ? format_ip6_address : - format_ip4_address, - loc->ip_address, eid_table->ttl, - eid_table->authoritative); - } - first_line = 0; - } - - return str; -} - -static int -print_lisp_eid_table_dump (vat_main_t * vam) -{ - eid_table_t *eid_table = 0; - u8 *tmp_str = 0, *tmp_str2 = 0; - int ret = 0; - - ASSERT (vam != NULL); - - ret = get_locator_set (vam); - if (ret) - { - vec_free (vam->eid_tables); - return ret; - } - - fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators", - "ttl", "authoritative"); - - vec_foreach (eid_table, vam->eid_tables) - { - if (~0 != eid_table->locator_set_index) - { - ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, - 0); - if (ret) - { - vec_free (vam->locator_msg); - clean_locator_set_message (vam); - vec_free (vam->eid_tables); - return ret; - } - } - - tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret); - if (ret) - { - vec_free (vam->locator_msg); - clean_locator_set_message (vam); - vec_free (vam->eid_tables); - return ret; - } - - tmp_str = format (0, "%-35s", tmp_str2); - vec_free (tmp_str2); - - tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table); - tmp_str = format (tmp_str, "%-20s", tmp_str2); - vec_free (tmp_str2); - - tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table); - tmp_str = format (tmp_str, "%-s", tmp_str2); - vec_free (tmp_str2); - - fformat (vam->ofp, "%s", tmp_str); - vec_free (tmp_str); - vec_free (vam->locator_msg); - } - - clean_locator_set_message (vam); - vec_free (vam->eid_tables); - - return ret; -} - -static inline void -json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node, - eid_table_t * eid_table) -{ - locator_set_msg_t *ls = 0; - u8 *s = 0; - - ASSERT (vam != NULL); - ASSERT (node != NULL); - ASSERT (eid_table != NULL); - - if (eid_table->is_local) - { - vec_foreach (ls, vam->locator_set_msg) - { - if (ls->locator_set_index == eid_table->locator_set_index) - { - vat_json_object_add_string_copy (node, "locator-set", - ls->locator_set_name); - return; - } - } - - s = format (0, "N/A"); - vec_add1 (s, 0); - vat_json_object_add_string_copy (node, "locator-set", s); - vec_free (s); - } - else - { - s = format (0, "remote"); - vec_add1 (s, 0); - vat_json_object_add_string_copy (node, "locator-set", s); - vec_free (s); - } -} - -static inline int -json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node, - eid_table_t * eid_table) -{ - u8 *s = 0; - struct in6_addr ip6; - struct in_addr ip4; - - ASSERT (vam != NULL); - ASSERT (node != NULL); - ASSERT (eid_table != NULL); - - switch (eid_table->eid_type) - { - case 0: - clib_memcpy (&ip4, eid_table->eid, sizeof (ip4)); - vat_json_object_add_ip4 (node, "eid", ip4); - vat_json_object_add_uint (node, "eid-prefix-len", - eid_table->eid_prefix_len); - break; - case 1: - clib_memcpy (&ip6, eid_table->eid, sizeof (ip6)); - vat_json_object_add_ip6 (node, "eid", ip6); - vat_json_object_add_uint (node, "eid-prefix-len", - eid_table->eid_prefix_len); - break; - case 2: - s = format (0, "%U", format_ethernet_address, eid_table->eid); - vec_add1 (s, 0); - vat_json_object_add_string_copy (node, "eid", s); - vec_free (s); - break; - default: - errmsg ("unknown EID type %d!", eid_table->eid_type); - return -99; - } - - return 0; -} - -static inline void -json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node, - eid_table_t * eid_table) -{ - locator_msg_t *loc = 0; - vat_json_node_t *locator_array = 0; - vat_json_node_t *locator = 0; - struct in6_addr ip6; - struct in_addr ip4; - - ASSERT (vam != NULL); - ASSERT (node != NULL); - ASSERT (eid_table != NULL); - - locator_array = vat_json_object_add_list (node, "locator"); - vec_foreach (loc, vam->locator_msg) - { - locator = vat_json_array_add (locator_array); - vat_json_init_object (locator); - if (loc->local) - { - vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index); - } - else - { - if (loc->is_ipv6) - { - clib_memcpy (&ip6, loc->ip_address, sizeof (ip6)); - vat_json_object_add_ip6 (locator, "locator", ip6); - } - else - { - clib_memcpy (&ip4, loc->ip_address, sizeof (ip4)); - vat_json_object_add_ip4 (locator, "locator", ip4); - } - } - } -} - -static int -json_lisp_eid_table_dump (vat_main_t * vam) -{ - eid_table_t *eid_table; - vat_json_node_t *node = 0; - int ret = 0; - - ASSERT (vam != NULL); - - ret = get_locator_set (vam); - if (ret) - { - vec_free (vam->eid_tables); - return ret; - } - - if (!vec_len (vam->eid_tables)) - { - /* just print [] */ - vat_json_init_array (&vam->json_tree); - vat_json_print (vam->ofp, &vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - return ret; - } - - if (VAT_JSON_ARRAY != vam->json_tree.type) - { - ASSERT (VAT_JSON_NONE == vam->json_tree.type); - vat_json_init_array (&vam->json_tree); - } - - vec_foreach (eid_table, vam->eid_tables) - { - ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0); - if (ret) - { - vec_free (vam->locator_msg); - vec_free (vam->eid_tables); - clean_locator_set_message (vam); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - return ret; - } - - node = vat_json_array_add (&vam->json_tree); - vat_json_init_object (node); - - vat_json_object_add_uint (node, "vni", eid_table->vni); - - json_locator_set_for_eid_table (vam, node, eid_table); - ret = json_eid_for_eid_table (vam, node, eid_table); - if (ret) - { - vec_free (vam->locator_msg); - vec_free (vam->eid_tables); - clean_locator_set_message (vam); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - return ret; - } - - json_locator_for_eid_table (vam, node, eid_table); - - vat_json_object_add_uint (node, "ttl", eid_table->ttl); - vat_json_object_add_uint (node, "authoritative", - eid_table->authoritative); - - vec_free (vam->locator_msg); - } - - vat_json_print (vam->ofp, &vam->json_tree); - vat_json_free (&vam->json_tree); - vam->json_tree.type = VAT_JSON_NONE; - - clean_locator_set_message (vam); - vec_free (vam->eid_tables); - - return ret; -} - static int api_lisp_eid_table_dump (vat_main_t * vam) { @@ -13724,6 +13878,12 @@ api_lisp_eid_table_dump (vat_main_t * vam) } } + if (!vam->json_output) + { + fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", + "ls_index", "ttl", "authoritative"); + } + M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump); mp->filter = filter; @@ -13751,36 +13911,18 @@ api_lisp_eid_table_dump (vat_main_t * vam) } } - vam->noprint_msg = 1; - /* send it... */ S; /* Use a control ping for synchronization */ { - vl_api_noprint_control_ping_t *mp; - M (NOPRINT_CONTROL_PING, noprint_control_ping); + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); S; } /* Wait for a reply... */ - /* *INDENT-OFF* */ - W_L - ({ - if (vam->noprint_msg) - { - if (!vam->json_output) - { - vam->retval = print_lisp_eid_table_dump(vam); - } - else - { - vam->retval = json_lisp_eid_table_dump(vam); - } - } - vam->noprint_msg = 0; - }); - /* *INDENT-ON* */ + W; /* NOTREACHED */ return 0; @@ -13794,23 +13936,69 @@ api_lisp_gpe_tunnel_dump (vat_main_t * vam) if (!vam->json_output) { - fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s" - "%=16s%=16s%=16s%=16s%=16s\n", - "Tunel", "Source", "Destination", "Fib encap", "Fib decap", - "Decap next", "Lisp version", "Flags", "Next protocol", - "ver_res", "res", "iid"); + fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s" + "%=16s%=16s%=16s%=16s%=16s\n", + "Tunel", "Source", "Destination", "Fib encap", "Fib decap", + "Decap next", "Lisp version", "Flags", "Next protocol", + "ver_res", "res", "iid"); + } + + M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump); + /* 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; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_adjacencies_get (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_lisp_adjacencies_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'\n", format_unformat_error, i); + return -99; + } + } + + if (!vni_set) + { + errmsg ("vni not set!\n"); + return -99; + } + + if (!vam->json_output) + { + fformat (vam->ofp, "%s %40s\n", "leid", "reid"); } - M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump); + M (LISP_ADJACENCIES_GET, lisp_adjacencies_get); + 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; @@ -14176,7 +14364,7 @@ api_policer_classify_dump (vat_main_t * vam) f64 timeout = ~0; u8 type = POLICER_CLASSIFY_N_TABLES; - if (unformat (i, "type %U", unformat_classify_table_type, &type)) + if (unformat (i, "type %U", unformat_policer_classify_table_type, &type)) ; else { @@ -14743,25 +14931,26 @@ api_classify_session_dump (vat_main_t * vam) } static void -vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp) +vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp) { vat_main_t *vam = &vat_main; fformat (vam->ofp, "collector_address %U, collector_port %d, " - "src_address %U, fib_index %u, path_mtu %u, " - "template_interval %u\n", + "src_address %U, vrf_id %d, path_mtu %u, " + "template_interval %u, udp_checksum %d\n", format_ip4_address, mp->collector_address, ntohs (mp->collector_port), format_ip4_address, mp->src_address, - ntohl (mp->fib_index), - ntohl (mp->path_mtu), ntohl (mp->template_interval)); + ntohl (mp->vrf_id), ntohl (mp->path_mtu), + ntohl (mp->template_interval), mp->udp_checksum); vam->retval = 0; vam->result_ready = 1; } static void -vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp) + vl_api_ipfix_exporter_details_t_handler_json + (vl_api_ipfix_exporter_details_t * mp) { vat_main_t *vam = &vat_main; vat_json_node_t node; @@ -14776,10 +14965,11 @@ vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp) ntohs (mp->collector_port)); clib_memcpy (&src_address, &mp->src_address, sizeof (src_address)); vat_json_object_add_ip4 (&node, "src_address", src_address); - vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index)); + vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id)); vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu)); vat_json_object_add_uint (&node, "template_interval", ntohl (mp->template_interval)); + vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum); vat_json_print (vam->ofp, &node); vat_json_free (&node); @@ -14788,13 +14978,29 @@ vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp) } int -api_ipfix_dump (vat_main_t * vam) +api_ipfix_exporter_dump (vat_main_t * vam) +{ + vl_api_ipfix_exporter_dump_t *mp; + f64 timeout; + + /* Construct the API message */ + M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump); + mp->context = 0; + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_ipfix_classify_stream_dump (vat_main_t * vam) { - vl_api_ipfix_dump_t *mp; + vl_api_ipfix_classify_stream_dump_t *mp; f64 timeout; /* Construct the API message */ - M (IPFIX_DUMP, ipfix_dump); + M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump); mp->context = 0; S; @@ -14803,6 +15009,92 @@ api_ipfix_dump (vat_main_t * vam) return 0; } +static void + vl_api_ipfix_classify_stream_details_t_handler + (vl_api_ipfix_classify_stream_details_t * mp) +{ + vat_main_t *vam = &vat_main; + fformat (vam->ofp, "domain_id %d, src_port %d\n", + ntohl (mp->domain_id), ntohs (mp->src_port)); + vam->retval = 0; + vam->result_ready = 1; +} + +static void + vl_api_ipfix_classify_stream_details_t_handler_json + (vl_api_ipfix_classify_stream_details_t * mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t node; + + vat_json_init_object (&node); + vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id)); + vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port)); + + vat_json_print (vam->ofp, &node); + vat_json_free (&node); + vam->retval = 0; + vam->result_ready = 1; +} + +static int +api_ipfix_classify_table_dump (vat_main_t * vam) +{ + vl_api_ipfix_classify_table_dump_t *mp; + f64 timeout; + + if (!vam->json_output) + { + fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version", + "transport_protocol"); + } + + /* Construct the API message */ + M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump); + + /* send it... */ + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); + S; + } + W; +} + +static void + vl_api_ipfix_classify_table_details_t_handler + (vl_api_ipfix_classify_table_details_t * mp) +{ + vat_main_t *vam = &vat_main; + fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version, + mp->transport_protocol); +} + +static void + vl_api_ipfix_classify_table_details_t_handler_json + (vl_api_ipfix_classify_table_details_t * mp) +{ + vat_json_node_t *node = NULL; + vat_main_t *vam = &vat_main; + + 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, "table_id", ntohl (mp->table_id)); + vat_json_object_add_uint (node, "ip_version", mp->ip_version); + vat_json_object_add_uint (node, "transport_protocol", + mp->transport_protocol); +} + int api_pg_create_interface (vat_main_t * vam) { @@ -15188,6 +15480,47 @@ api_ipsec_gre_add_del_tunnel (vat_main_t * vam) return 0; } +static int +api_punt (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_punt_t *mp; + f64 timeout; + u32 ipv = ~0; + u32 protocol = ~0; + u32 port = ~0; + int is_add = 1; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "ip %d", &ipv)) + ; + else if (unformat (i, "protocol %d", &protocol)) + ; + else if (unformat (i, "port %d", &port)) + ; + else if (unformat (i, "del")) + is_add = 0; + else + { + clib_warning ("parse error '%U'", format_unformat_error, i); + return -99; + } + } + + M (PUNT, punt); + + mp->is_add = (u8) is_add; + mp->ipv = (u8) ipv; + mp->l4_protocol = (u8) protocol; + mp->l4_port = htons ((u16) port); + + S; + W; + /* NOTREACHED */ + return 0; +} + static void vl_api_ipsec_gre_tunnel_details_t_handler (vl_api_ipsec_gre_tunnel_details_t * mp) { @@ -15300,6 +15633,182 @@ api_delete_subif (vat_main_t * vam) W; } +#define foreach_pbb_vtr_op \ +_("disable", L2_VTR_DISABLED) \ +_("pop", L2_VTR_POP_2) \ +_("push", L2_VTR_PUSH_2) + +static int +api_l2_interface_pbb_tag_rewrite (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_l2_interface_pbb_tag_rewrite_t *mp; + f64 timeout; + u32 sw_if_index = ~0, vtr_op = ~0; + u16 outer_tag = ~0; + u8 dmac[6], smac[6]; + u8 dmac_set = 0, smac_set = 0; + u16 vlanid = 0; + u32 sid = ~0; + u32 tmp; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index)) + ; + else if (unformat (i, "sw_if_index %d", &sw_if_index)) + ; + else if (unformat (i, "vtr_op %d", &vtr_op)) + ; +#define _(n,v) else if (unformat(i, n)) {vtr_op = v;} + foreach_pbb_vtr_op +#undef _ + else if (unformat (i, "translate_pbb_stag")) + { + if (unformat (i, "%d", &tmp)) + { + vtr_op = L2_VTR_TRANSLATE_2_1; + outer_tag = tmp; + } + else + { + errmsg + ("translate_pbb_stag operation requires outer tag definition\n"); + return -99; + } + } + else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac)) + dmac_set++; + else if (unformat (i, "smac %U", unformat_ethernet_address, smac)) + smac_set++; + else if (unformat (i, "sid %d", &sid)) + ; + else if (unformat (i, "vlanid %d", &tmp)) + vlanid = tmp; + else + { + clib_warning ("parse error '%U'", format_unformat_error, i); + return -99; + } + } + + if ((sw_if_index == ~0) || (vtr_op == ~0)) + { + errmsg ("missing sw_if_index or vtr operation\n"); + return -99; + } + if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2)) + && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0))) + { + errmsg + ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid\n"); + return -99; + } + + M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite); + mp->sw_if_index = ntohl (sw_if_index); + mp->vtr_op = ntohl (vtr_op); + mp->outer_tag = ntohs (outer_tag); + clib_memcpy (mp->b_dmac, dmac, sizeof (dmac)); + clib_memcpy (mp->b_smac, smac, sizeof (smac)); + mp->b_vlanid = ntohs (vlanid); + mp->i_sid = ntohl (sid); + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_flow_classify_set_interface (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_flow_classify_set_interface_t *mp; + f64 timeout; + u32 sw_if_index; + int sw_if_index_set; + u32 ip4_table_index = ~0; + u32 ip6_table_index = ~0; + u8 is_add = 1; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index)) + 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, "del")) + is_add = 0; + else if (unformat (i, "ip4-table %d", &ip4_table_index)) + ; + else if (unformat (i, "ip6-table %d", &ip6_table_index)) + ; + else + { + clib_warning ("parse error '%U'", format_unformat_error, i); + return -99; + } + } + + if (sw_if_index_set == 0) + { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface); + + mp->sw_if_index = ntohl (sw_if_index); + mp->ip4_table_index = ntohl (ip4_table_index); + mp->ip6_table_index = ntohl (ip6_table_index); + mp->is_add = is_add; + + S; + W; + /* NOTREACHED */ + return 0; +} + +static int +api_flow_classify_dump (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_flow_classify_dump_t *mp; + f64 timeout = ~0; + u8 type = FLOW_CLASSIFY_N_TABLES; + + if (unformat (i, "type %U", unformat_flow_classify_table_type, &type)) + ; + else + { + errmsg ("classify table type must be specified\n"); + return -99; + } + + if (!vam->json_output) + { + fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table"); + } + + M (FLOW_CLASSIFY_DUMP, flow_classify_dump); + mp->type = type; + /* 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; + + /* NOTREACHED */ + return 0; +} + static int q_or_quit (vat_main_t * vam) { @@ -15615,6 +16124,14 @@ _(sw_interface_set_l2_bridge, \ " | sw_if_index bd_id \n" \ "[shg ] [bvi]\n" \ "enable | disable") \ +_(sw_interface_set_dpdk_hqos_pipe, \ + "rx | sw_if_index subport pipe \n" \ + "profile \n") \ +_(sw_interface_set_dpdk_hqos_subport, \ + "rx | sw_if_index subport [rate ]\n" \ + "[bktsize ] [tc0 ] [tc1 ] [tc2 ] [tc3 ] [period ]\n") \ +_(sw_interface_set_dpdk_hqos_tctbl, \ + "rx | sw_if_index entry tc queue \n") \ _(bridge_domain_add_del, \ "bd_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 ]\n") \ @@ -15734,7 +16251,7 @@ _(vxlan_add_del_tunnel, \ " [decap-next l2|ip4|ip6] [del]") \ _(vxlan_tunnel_dump, "[ | sw_if_index ]") \ _(gre_add_del_tunnel, \ - "src dst [outer-fib-id ] [del]\n") \ + "src dst [outer-fib-id ] [teb] [del]\n") \ _(gre_tunnel_dump, "[ | sw_if_index ]") \ _(l2_fib_clear_table, "") \ _(l2_interface_efp_filter, "sw_if_index enable | disable") \ @@ -15822,27 +16339,30 @@ _(lisp_add_del_map_resolver, " [del]") \ _(lisp_gpe_enable_disable, "enable|disable") \ _(lisp_enable_disable, "enable|disable") \ _(lisp_gpe_add_del_iface, "up|down") \ -_(lisp_add_del_remote_mapping, "add|del vni deid " \ +_(lisp_add_del_remote_mapping, "add|del vni eid " \ + "[seid ] " \ "rloc p " \ "w [rloc ... ] " \ "action [del-all]") \ -_(lisp_add_del_adjacency, "add|del vni deid seid " \ - " rloc p w "\ - "[rloc ... ] action ") \ +_(lisp_add_del_adjacency, "add|del vni reid leid " \ + "") \ _(lisp_pitr_set_locator_set, "locator-set | del") \ +_(lisp_map_request_mode, "src-dst|dst-only") \ _(lisp_add_del_map_request_itr_rlocs, " [del]") \ _(lisp_eid_table_add_del_map, "[del] vni vrf ") \ -_(lisp_locator_set_dump, "[locator-set-index | " \ - "locator-set ] [local | remote]")\ +_(lisp_locator_set_dump, "[local | remote]") \ +_(lisp_locator_dump, "ls_index | ls_name ") \ _(lisp_eid_table_dump, "[eid / | ] [vni] " \ "[local] | [remote]") \ _(lisp_eid_table_vni_dump, "") \ _(lisp_eid_table_map_dump, "l2|l3") \ _(lisp_gpe_tunnel_dump, "") \ _(lisp_map_resolver_dump, "") \ +_(lisp_adjacencies_get, "vni ") \ _(show_lisp_status, "") \ _(lisp_get_map_request_itr_rlocs, "") \ _(show_lisp_pitr, "") \ +_(show_lisp_map_request_mode, "") \ _(af_packet_create, "name [hw_addr ]") \ _(af_packet_delete, "name ") \ _(policer_add_del, "name [del]") \ @@ -15862,10 +16382,14 @@ _(classify_table_ids, "") \ _(classify_table_by_interface, "sw_if_index ") \ _(classify_table_info, "table_id ") \ _(classify_session_dump, "table_id ") \ -_(ipfix_enable, "collector_address [collector_port ] " \ - "src_address [fib_id ] [path_mtu ] " \ - "[template_interval ]") \ -_(ipfix_dump, "") \ +_(set_ipfix_exporter, "collector_address [collector_port ] " \ + "src_address [vrf_id ] [path_mtu ] " \ + "[template_interval ] [udp_checksum]") \ +_(ipfix_exporter_dump, "") \ +_(set_ipfix_classify_stream, "[domain ] [src_port ]") \ +_(ipfix_classify_stream_dump, "") \ +_(ipfix_classify_table_add_del, "table ip4|ip6 [tcp|udp]")\ +_(ipfix_classify_table_dump, "") \ _(get_next_index, "node-name next-node-name ") \ _(pg_create_interface, "if_id ") \ _(pg_capture, "if_id pcap count [disable]") \ @@ -15878,7 +16402,15 @@ _(ip_source_and_port_range_check_interface_add_del, \ _(ipsec_gre_add_del_tunnel, \ "src dst local_sa remote_sa [del]") \ _(ipsec_gre_tunnel_dump, "[sw_if_index ]") \ -_(delete_subif,"sub_sw_if_index sub_if_id ") +_(delete_subif,"sub_sw_if_index sub_if_id ") \ +_(l2_interface_pbb_tag_rewrite, \ + " | sw_if_index \n" \ + "[disable | push | pop | translate_pbb_stag ] \n" \ + "dmac smac sid [vlanid ]") \ +_(punt, "protocol [ip ] [port ] [del]") \ +_(flow_classify_set_interface, \ + " | sw_if_index [ip4-table ] [ip6-table ] [del]") \ +_(flow_classify_dump, "type [ip4|ip6]") /* List of command functions, CLI names map directly to functions */ #define foreach_cli_function \