X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vpp-api-test%2Fvat%2Fapi_format.c;h=65114ec2d70d396adc67b6413f42add97b65fcc2;hb=f6e3dc4778ef910d4ae6114783bd8f50887e6d0d;hp=4b1d41fa177f9b808be261bce6d5b823b42e7991;hpb=3fa0af596056ae6e87692325c7ebe51636635313;p=vpp.git diff --git a/vpp-api-test/vat/api_format.c b/vpp-api-test/vat/api_format.c index 4b1d41fa177..65114ec2d70 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,6 +35,7 @@ #include #include #include +#include #include #if DPDK > 0 #include @@ -47,6 +48,7 @@ #include #include #include +#include #include #include @@ -456,7 +458,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 +476,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) { @@ -1075,40 +1094,6 @@ static void vl_api_add_node_next_reply_t_handler_json vam->result_ready = 1; } -static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler - (vl_api_mpls_gre_add_del_tunnel_reply_t * mp) -{ - vat_main_t *vam = &vat_main; - i32 retval = ntohl (mp->retval); - u32 sw_if_index = ntohl (mp->tunnel_sw_if_index); - - if (retval >= 0 && sw_if_index != (u32) ~ 0) - { - errmsg ("tunnel_sw_if_index %d\n", sw_if_index); - } - vam->retval = retval; - vam->result_ready = 1; -} - -static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json - (vl_api_mpls_gre_add_del_tunnel_reply_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_object_add_uint (&node, "tunnel_sw_if_index", - ntohl (mp->tunnel_sw_if_index)); - - vat_json_print (vam->ofp, &node); - vat_json_free (&node); - - vam->retval = ntohl (mp->retval); - vam->result_ready = 1; -} - - static void vl_api_show_version_reply_t_handler (vl_api_show_version_reply_t * mp) { @@ -2584,6 +2569,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) @@ -3370,10 +3427,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 @@ -3388,16 +3476,21 @@ static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json _(sw_interface_set_flags_reply) \ _(sw_interface_add_del_address_reply) \ _(sw_interface_set_table_reply) \ +_(sw_interface_set_mpls_enable_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) \ _(ip_add_del_route_reply) \ +_(mpls_route_add_del_reply) \ +_(mpls_ip_bind_unbind_reply) \ _(proxy_arp_add_del_reply) \ _(proxy_arp_intfc_enable_disable_reply) \ _(mpls_add_del_encap_reply) \ -_(mpls_add_del_decap_reply) \ _(mpls_ethernet_add_del_tunnel_2_reply) \ _(sw_interface_set_unnumbered_reply) \ _(ip_neighbor_add_del_reply) \ @@ -3474,11 +3567,15 @@ _(netmap_delete_reply) \ _(set_ipfix_exporter_reply) \ _(set_ipfix_classify_stream_reply) \ _(ipfix_classify_table_add_del_reply) \ +_(flow_classify_set_interface_reply) \ +_(sw_interface_span_enable_disable_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 \ @@ -3527,11 +3624,18 @@ _(CLI_INBAND_REPLY, cli_inband_reply) \ _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \ sw_interface_add_del_address_reply) \ _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \ +_(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \ _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \ _(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) \ @@ -3543,12 +3647,12 @@ _(TAP_MODIFY_REPLY, tap_modify_reply) \ _(TAP_DELETE_REPLY, tap_delete_reply) \ _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \ _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_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) \ _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \ proxy_arp_intfc_enable_disable_reply) \ _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \ -_(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \ -_(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \ _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \ mpls_ethernet_add_del_tunnel_reply) \ _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \ @@ -3666,6 +3770,7 @@ _(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) \ @@ -3681,10 +3786,9 @@ _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \ _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \ _(NETMAP_CREATE_REPLY, netmap_create_reply) \ _(NETMAP_DELETE_REPLY, netmap_delete_reply) \ -_(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \ _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \ _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \ -_(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \ +_(MPLS_FIB_DETAILS, mpls_fib_details) \ _(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) \ @@ -3695,6 +3799,10 @@ _(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) \ +_(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \ +_(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \ _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \ _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \ _(PG_CAPTURE_REPLY, pg_capture_reply) \ @@ -3705,7 +3813,11 @@ _(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) \ +_(IP_FIB_DETAILS, ip_fib_details) \ +_(IP6_FIB_DETAILS, ip6_fib_details) /* M: construct, but don't yet send a message */ @@ -4362,6 +4474,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); @@ -4500,6 +4617,225 @@ api_sw_interface_clear_stats (vat_main_t * vam) W; } +static int +api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp; + f64 timeout; + u32 sw_if_index; + u8 sw_if_index_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) { @@ -4577,14 +4913,14 @@ api_sw_interface_add_del_address (vat_main_t * vam) } static int -api_sw_interface_set_table (vat_main_t * vam) +api_sw_interface_set_mpls_enable (vat_main_t * vam) { unformat_input_t *i = vam->input; - vl_api_sw_interface_set_table_t *mp; + vl_api_sw_interface_set_mpls_enable_t *mp; f64 timeout; - u32 sw_if_index, vrf_id = 0; + u32 sw_if_index; u8 sw_if_index_set = 0; - u8 is_ipv6 = 0; + u8 enable = 1; /* Parse args required to build the message */ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) @@ -4593,10 +4929,10 @@ api_sw_interface_set_table (vat_main_t * vam) 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, "vrf %d", &vrf_id)) - ; - else if (unformat (i, "ipv6")) - is_ipv6 = 1; + else if (unformat (i, "disable")) + enable = 0; + else if (unformat (i, "dis")) + enable = 0; else break; } @@ -4608,11 +4944,10 @@ api_sw_interface_set_table (vat_main_t * vam) } /* Construct the API message */ - M (SW_INTERFACE_SET_TABLE, sw_interface_set_table); + M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable); mp->sw_if_index = ntohl (sw_if_index); - mp->is_ipv6 = is_ipv6; - mp->vrf_id = ntohl (vrf_id); + mp->enable = enable; /* send it... */ S; @@ -4622,12 +4957,57 @@ api_sw_interface_set_table (vat_main_t * vam) } static int -api_sw_interface_set_vpath (vat_main_t * vam) +api_sw_interface_set_table (vat_main_t * vam) { unformat_input_t *i = vam->input; - vl_api_sw_interface_set_vpath_t *mp; + vl_api_sw_interface_set_table_t *mp; f64 timeout; - u32 sw_if_index = 0; + u32 sw_if_index, vrf_id = 0; + u8 sw_if_index_set = 0; + u8 is_ipv6 = 0; + + /* Parse args required to build the message */ + 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, "vrf %d", &vrf_id)) + ; + else if (unformat (i, "ipv6")) + is_ipv6 = 1; + else + break; + } + + if (sw_if_index_set == 0) + { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + /* Construct the API message */ + M (SW_INTERFACE_SET_TABLE, sw_interface_set_table); + + mp->sw_if_index = ntohl (sw_if_index); + mp->is_ipv6 = is_ipv6; + mp->vrf_id = ntohl (vrf_id); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; +} + +static int +api_sw_interface_set_vpath (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_set_vpath_t *mp; + f64 timeout; + u32 sw_if_index = 0; u8 sw_if_index_set = 0; u8 is_enable = 0; @@ -5383,6 +5763,7 @@ api_ip_add_del_route (vat_main_t * vam) u8 sw_if_index_set = 0; u8 is_ipv6 = 0; u8 is_local = 0, is_drop = 0; + u8 is_unreach = 0, is_prohibit = 0; u8 create_vrf_if_needed = 0; u8 is_add = 1; u8 next_hop_weight = 1; @@ -5390,7 +5771,7 @@ api_ip_add_del_route (vat_main_t * vam) u8 is_multipath = 0; u8 address_set = 0; u8 address_length_set = 0; - u32 lookup_in_vrf = 0; + u32 next_hop_table_id = 0; u32 resolve_attempts = 0; u32 dst_address_length = 0; u8 next_hop_set = 0; @@ -5405,7 +5786,8 @@ 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, resolve_attached; + u8 resolve_host = 0, resolve_attached = 0; + mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID; /* Parse args required to build the message */ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) @@ -5447,6 +5829,14 @@ api_ip_add_del_route (vat_main_t * vam) { is_drop = 1; } + else if (unformat (i, "null-send-unreach")) + { + is_unreach = 1; + } + else if (unformat (i, "null-send-prohibit")) + { + is_prohibit = 1; + } else if (unformat (i, "local")) { is_local = 1; @@ -5473,7 +5863,11 @@ api_ip_add_del_route (vat_main_t * vam) create_vrf_if_needed = 1; else if (unformat (i, "count %d", &count)) ; - else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf)) + else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id)) + ; + else if (unformat (i, "next-hop-table %d", &next_hop_table_id)) + ; + else if (unformat (i, "out-label %d", &next_hop_out_label)) ; else if (unformat (i, "random")) random_add_del = 1; @@ -5492,9 +5886,11 @@ api_ip_add_del_route (vat_main_t * vam) return -99; } - if (!next_hop_set && !is_drop && !is_local && !is_classify) + if (!next_hop_set && !is_drop && !is_local && + !is_classify && !is_unreach && !is_prohibit) { - errmsg ("next hop / local / drop / classify not set\n"); + errmsg + ("next hop / local / drop / unreach / prohibit / classify not set\n"); return -99; } @@ -5547,7 +5943,7 @@ api_ip_add_del_route (vat_main_t * vam) M (IP_ADD_DEL_ROUTE, ip_add_del_route); mp->next_hop_sw_if_index = ntohl (sw_if_index); - mp->vrf_id = ntohl (vrf_id); + mp->table_id = ntohl (vrf_id); if (resolve_attempts > 0) { mp->resolve_attempts = ntohl (resolve_attempts); @@ -5557,6 +5953,8 @@ api_ip_add_del_route (vat_main_t * vam) mp->is_add = is_add; mp->is_drop = is_drop; + mp->is_unreach = is_unreach; + mp->is_prohibit = is_prohibit; mp->is_ipv6 = is_ipv6; mp->is_local = is_local; mp->is_classify = is_classify; @@ -5566,8 +5964,9 @@ api_ip_add_del_route (vat_main_t * vam) mp->not_last = not_last; mp->next_hop_weight = next_hop_weight; mp->dst_address_length = dst_address_length; - mp->lookup_in_vrf = ntohl (lookup_in_vrf); + mp->next_hop_table_id = ntohl (next_hop_table_id); mp->classify_table_index = ntohl (classify_table_index); + mp->next_hop_out_label = ntohl (next_hop_out_label); if (is_ipv6) { @@ -5592,6 +5991,216 @@ 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 */ + if (count > 1) + { + vl_api_control_ping_t *mp; + f64 after; + + /* Shut off async mode */ + vam->async_mode = 0; + + M (CONTROL_PING, control_ping); + S; + + timeout = vat_time_now (vam) + 1.0; + while (vat_time_now (vam) < timeout) + if (vam->result_ready == 1) + goto out; + vam->retval = -99; + + out: + if (vam->retval == -99) + errmsg ("timeout\n"); + + if (vam->async_errors > 0) + { + errmsg ("%d asynchronous errors\n", vam->async_errors); + vam->retval = -98; + } + 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)); + } + else + { + /* Wait for a reply... */ + W; + } + + /* Return the good/bad news */ + return (vam->retval); +} + +static int +api_mpls_route_add_del (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_mpls_route_add_del_t *mp; + f64 timeout; + u32 sw_if_index = ~0, table_id = 0; + u8 create_table_if_needed = 0; + u8 is_add = 1; + u8 next_hop_weight = 1; + u8 is_multipath = 0; + u32 next_hop_table_id = 0; + u8 next_hop_set = 0; + ip4_address_t v4_next_hop_address = { + .as_u32 = 0, + }; + ip6_address_t v6_next_hop_address = { {0} }; + int count = 1; + int j; + f64 before = 0; + u32 classify_table_index = ~0; + u8 is_classify = 0; + u8 resolve_host = 0, resolve_attached = 0; + mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID; + mpls_label_t local_label = MPLS_LABEL_INVALID; + u8 is_eos = 1; + u8 next_hop_proto_is_ip4 = 1; + + /* Parse args required to build the message */ + 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, "%d", &local_label)) + ; + else if (unformat (i, "eos")) + is_eos = 1; + else if (unformat (i, "non-eos")) + is_eos = 0; + else if (unformat (i, "via %U", unformat_ip4_address, + &v4_next_hop_address)) + { + next_hop_set = 1; + next_hop_proto_is_ip4 = 1; + } + else if (unformat (i, "via %U", unformat_ip6_address, + &v6_next_hop_address)) + { + next_hop_set = 1; + next_hop_proto_is_ip4 = 0; + } + else if (unformat (i, "weight %d", &next_hop_weight)) + ; + else if (unformat (i, "create-table")) + create_table_if_needed = 1; + else if (unformat (i, "classify %d", &classify_table_index)) + { + is_classify = 1; + } + else if (unformat (i, "del")) + is_add = 0; + else if (unformat (i, "add")) + is_add = 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, "count %d", &count)) + ; + else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id)) + { + next_hop_set = 1; + next_hop_proto_is_ip4 = 1; + } + else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id)) + { + next_hop_set = 1; + next_hop_proto_is_ip4 = 0; + } + else if (unformat (i, "next-hop-table %d", &next_hop_table_id)) + ; + else if (unformat (i, "out-label %d", &next_hop_out_label)) + ; + else + { + clib_warning ("parse error '%U'", format_unformat_error, i); + return -99; + } + } + + if (!next_hop_set && !is_classify) + { + errmsg ("next hop / classify not set\n"); + return -99; + } + + if (MPLS_LABEL_INVALID == local_label) + { + errmsg ("missing label\n"); + return -99; + } + + if (count > 1) + { + /* Turn on async mode */ + vam->async_mode = 1; + vam->async_errors = 0; + before = vat_time_now (vam); + } + + for (j = 0; j < count; j++) + { + /* Construct the API message */ + M (MPLS_ROUTE_ADD_DEL, mpls_route_add_del); + + mp->mr_next_hop_sw_if_index = ntohl (sw_if_index); + mp->mr_table_id = ntohl (table_id); + mp->mr_create_table_if_needed = create_table_if_needed; + + mp->mr_is_add = is_add; + mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4; + mp->mr_is_classify = is_classify; + mp->mr_is_multipath = is_multipath; + mp->mr_is_resolve_host = resolve_host; + mp->mr_is_resolve_attached = resolve_attached; + mp->mr_next_hop_weight = next_hop_weight; + mp->mr_next_hop_table_id = ntohl (next_hop_table_id); + mp->mr_classify_table_index = ntohl (classify_table_index); + mp->mr_next_hop_out_label = ntohl (next_hop_out_label); + mp->mr_label = ntohl (local_label); + mp->mr_eos = is_eos; + + if (next_hop_set) + { + if (next_hop_proto_is_ip4) + { + clib_memcpy (mp->mr_next_hop, + &v4_next_hop_address, + sizeof (v4_next_hop_address)); + } + else + { + clib_memcpy (mp->mr_next_hop, + &v6_next_hop_address, + sizeof (v6_next_hop_address)); + } + } + local_label++; + + /* 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 */ @@ -5624,6 +6233,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)); } @@ -5637,6 +6250,89 @@ api_ip_add_del_route (vat_main_t * vam) return (vam->retval); } +static int +api_mpls_ip_bind_unbind (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_mpls_ip_bind_unbind_t *mp; + f64 timeout; + u32 ip_table_id = 0; + u8 create_table_if_needed = 0; + u8 is_bind = 1; + u8 is_ip4 = 1; + ip4_address_t v4_address; + ip6_address_t v6_address; + u32 address_length; + u8 address_set = 0; + mpls_label_t local_label = MPLS_LABEL_INVALID; + + /* Parse args required to build the message */ + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "%U/%d", unformat_ip4_address, + &v4_address, &address_length)) + { + is_ip4 = 1; + address_set = 1; + } + else if (unformat (i, "%U/%d", unformat_ip6_address, + &v6_address, &address_length)) + { + is_ip4 = 0; + address_set = 1; + } + else if (unformat (i, "%d", &local_label)) + ; + else if (unformat (i, "create-table")) + create_table_if_needed = 1; + else if (unformat (i, "table-id %d", &ip_table_id)) + ; + else if (unformat (i, "unbind")) + is_bind = 0; + else if (unformat (i, "bind")) + is_bind = 1; + else + { + clib_warning ("parse error '%U'", format_unformat_error, i); + return -99; + } + } + + if (!address_set) + { + errmsg ("IP addres not set\n"); + return -99; + } + + if (MPLS_LABEL_INVALID == local_label) + { + errmsg ("missing label\n"); + return -99; + } + + /* Construct the API message */ + M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind); + + mp->mb_create_table_if_needed = create_table_if_needed; + mp->mb_is_bind = is_bind; + mp->mb_is_ip4 = is_ip4; + mp->mb_ip_table_id = ntohl (ip_table_id); + mp->mb_mpls_table_id = 0; + mp->mb_label = ntohl (local_label); + mp->mb_address_length = address_length; + + if (is_ip4) + clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address)); + else + clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address)); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; +} + static int api_proxy_arp_add_del (vat_main_t * vam) { @@ -5727,55 +6423,6 @@ api_proxy_arp_intfc_enable_disable (vat_main_t * vam) return 0; } -static int -api_mpls_add_del_decap (vat_main_t * vam) -{ - unformat_input_t *i = vam->input; - vl_api_mpls_add_del_decap_t *mp; - f64 timeout; - u32 rx_vrf_id = 0; - u32 tx_vrf_id = 0; - u32 label = 0; - u8 is_add = 1; - u8 s_bit = 1; - u32 next_index = 1; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "rx_vrf_id %d", &rx_vrf_id)) - ; - else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id)) - ; - else if (unformat (i, "label %d", &label)) - ; - else if (unformat (i, "next-index %d", &next_index)) - ; - else if (unformat (i, "del")) - is_add = 0; - else if (unformat (i, "s-bit-clear")) - s_bit = 0; - else - { - clib_warning ("parse error '%U'", format_unformat_error, i); - return -99; - } - } - - M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap); - - mp->rx_vrf_id = ntohl (rx_vrf_id); - mp->tx_vrf_id = ntohl (tx_vrf_id); - mp->label = ntohl (label); - mp->next_index = ntohl (next_index); - mp->s_bit = s_bit; - mp->is_add = is_add; - - S; - W; - /* NOTREACHED */ - return 0; -} - static int api_mpls_add_del_encap (vat_main_t * vam) { @@ -5828,63 +6475,6 @@ api_mpls_add_del_encap (vat_main_t * vam) return 0; } -static int -api_mpls_gre_add_del_tunnel (vat_main_t * vam) -{ - unformat_input_t *i = vam->input; - vl_api_mpls_gre_add_del_tunnel_t *mp; - f64 timeout; - u32 inner_vrf_id = 0; - u32 outer_vrf_id = 0; - ip4_address_t src_address; - ip4_address_t dst_address; - ip4_address_t intfc_address; - u32 tmp; - u8 intfc_address_length = 0; - u8 is_add = 1; - u8 l2_only = 0; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "inner_vrf_id %d", &inner_vrf_id)) - ; - else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id)) - ; - else if (unformat (i, "src %U", unformat_ip4_address, &src_address)) - ; - else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address)) - ; - else if (unformat (i, "adj %U/%d", unformat_ip4_address, - &intfc_address, &tmp)) - intfc_address_length = tmp; - else if (unformat (i, "l2-only")) - l2_only = 1; - else if (unformat (i, "del")) - is_add = 0; - else - { - clib_warning ("parse error '%U'", format_unformat_error, i); - return -99; - } - } - - M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel); - - mp->inner_vrf_id = ntohl (inner_vrf_id); - mp->outer_vrf_id = ntohl (outer_vrf_id); - clib_memcpy (mp->src_address, &src_address, sizeof (src_address)); - clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address)); - clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address)); - mp->intfc_address_length = intfc_address_length; - mp->l2_only = l2_only; - mp->is_add = is_add; - - S; - W; - /* NOTREACHED */ - return 0; -} - static int api_mpls_ethernet_add_del_tunnel (vat_main_t * vam) { @@ -7227,28 +7817,28 @@ api_ioam_enable (vat_main_t * vam) f64 timeout; u32 id = 0; int has_trace_option = 0; - int has_pow_option = 0; - int has_ppc_option = 0; + int has_pot_option = 0; + int has_seqno_option = 0; + int has_analyse_option = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "trace")) has_trace_option = 1; - else if (unformat (input, "pow")) - has_pow_option = 1; - else if (unformat (input, "ppc encap")) - has_ppc_option = PPC_ENCAP; - else if (unformat (input, "ppc decap")) - has_ppc_option = PPC_DECAP; - else if (unformat (input, "ppc none")) - has_ppc_option = PPC_NONE; + else if (unformat (input, "pot")) + has_pot_option = 1; + else if (unformat (input, "seqno")) + has_seqno_option = 1; + else if (unformat (input, "analyse")) + has_analyse_option = 1; else break; } M (IOAM_ENABLE, ioam_enable); mp->id = htons (id); - mp->trace_ppc = has_ppc_option; - mp->pow_enable = has_pow_option; + mp->seqno = has_seqno_option; + mp->analyse = has_analyse_option; + mp->pot_enable = has_pot_option; mp->trace_enable = has_trace_option; S; @@ -7526,32 +8116,163 @@ api_sr_multicast_map_add_del (vat_main_t * vam) return -99; } - M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del); + M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del); + + mp->is_add = !is_del; + memcpy (mp->policy_name, policy_name, vec_len (policy_name)); + clib_memcpy (mp->multicast_address, &multicast_address, + sizeof (mp->multicast_address)); + + + vec_free (policy_name); + + S; + W; + /* NOTREACHED */ +} + + +#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) \ +_(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; - mp->is_add = !is_del; - memcpy (mp->policy_name, policy_name, vec_len (policy_name)); - clib_memcpy (mp->multicast_address, &multicast_address, - sizeof (mp->multicast_address)); + 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; - vec_free (policy_name); + *maskp = mask; - S; - W; - /* NOTREACHED */ + return 1; } - -#define foreach_ip4_proto_field \ -_(src_address) \ -_(dst_address) \ -_(tos) \ -_(length) \ -_(fragment_id) \ -_(ttl) \ -_(protocol) \ -_(checksum) - uword unformat_ip4_mask (unformat_input_t * input, va_list * args) { @@ -7829,6 +8550,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) @@ -7839,13 +8561,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) @@ -7856,6 +8588,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 */ @@ -8095,6 +8832,37 @@ api_classify_add_del_table (vat_main_t * vam) /* NOTREACHED */ } +uword +unformat_l4_match (unformat_input_t * input, va_list * args) +{ + u8 **matchp = va_arg (*args, u8 **); + + 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) { @@ -8179,13 +8947,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; @@ -8440,6 +9208,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) { @@ -8449,13 +9218,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) @@ -8466,6 +9245,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 */ @@ -9288,13 +10072,7 @@ static uword unformat_vxlan_decap_next u32 *result = va_arg (*args, u32 *); u32 tmp; - if (unformat (input, "drop")) - *result = VXLAN_INPUT_NEXT_DROP; - else if (unformat (input, "ip4")) - *result = VXLAN_INPUT_NEXT_IP4_INPUT; - else if (unformat (input, "ip6")) - *result = VXLAN_INPUT_NEXT_IP6_INPUT; - else if (unformat (input, "l2")) + if (unformat (input, "l2")) *result = VXLAN_INPUT_NEXT_L2_INPUT; else if (unformat (input, "%d", &tmp)) *result = tmp; @@ -12793,15 +13571,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) @@ -12814,39 +13592,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)) { @@ -12859,38 +13637,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); @@ -13397,6 +14175,52 @@ api_lisp_gpe_tunnel_dump (vat_main_t * vam) 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_ADJACENCIES_GET, lisp_adjacencies_get); + mp->vni = clib_host_to_net_u32 (vni); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + static int api_lisp_map_resolver_dump (vat_main_t * vam) { @@ -13755,7 +14579,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 { @@ -13882,48 +14706,28 @@ api_netmap_delete (vat_main_t * vam) return 0; } -static void vl_api_mpls_gre_tunnel_details_t_handler - (vl_api_mpls_gre_tunnel_details_t * mp) +static void vl_api_mpls_eth_tunnel_details_t_handler + (vl_api_mpls_eth_tunnel_details_t * mp) { vat_main_t *vam = &vat_main; i32 i; i32 len = ntohl (mp->nlabels); - if (mp->l2_only == 0) - { - fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ", - ntohl (mp->tunnel_index), - format_ip4_address, &mp->tunnel_src, - format_ip4_address, &mp->tunnel_dst, - format_ip4_address, &mp->intfc_address, - ntohl (mp->mask_width)); - for (i = 0; i < len; i++) - { - fformat (vam->ofp, "%u ", ntohl (mp->labels[i])); - } - fformat (vam->ofp, "\n"); - fformat (vam->ofp, " inner fib index %d, outer fib index %d\n", - ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index)); - } - else + fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ", + ntohl (mp->tunnel_index), + format_ethernet_address, &mp->tunnel_dst_mac, + format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width)); + for (i = 0; i < len; i++) { - fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ", - ntohl (mp->tunnel_index), - format_ip4_address, &mp->tunnel_src, - format_ip4_address, &mp->tunnel_dst, - format_ip4_address, &mp->intfc_address); - for (i = 0; i < len; i++) - { - fformat (vam->ofp, "%u ", ntohl (mp->labels[i])); - } - fformat (vam->ofp, "\n"); - fformat (vam->ofp, " l2 interface %d, outer fib index %d\n", - ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index)); + fformat (vam->ofp, "%u ", ntohl (mp->labels[i])); } + fformat (vam->ofp, "\n"); + fformat (vam->ofp, " tx on %d, rx fib index %d\n", + ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index)); } -static void vl_api_mpls_gre_tunnel_details_t_handler_json - (vl_api_mpls_gre_tunnel_details_t * mp) +static void vl_api_mpls_eth_tunnel_details_t_handler_json + (vl_api_mpls_eth_tunnel_details_t * mp) { vat_main_t *vam = &vat_main; vat_json_node_t *node = NULL; @@ -13948,12 +14752,11 @@ static void vl_api_mpls_gre_tunnel_details_t_handler_json vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index)); vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index)); vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only)); - clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4)); - vat_json_object_add_ip4 (node, "tunnel_src", ip4); - clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4)); - vat_json_object_add_ip4 (node, "tunnel_dst", ip4); - vat_json_object_add_uint (node, "outer_fib_index", - ntohl (mp->outer_fib_index)); + vat_json_object_add_string_copy (node, "tunnel_dst_mac", + format (0, "%U", format_ethernet_address, + &mp->tunnel_dst_mac)); + vat_json_object_add_uint (node, "tx_sw_if_index", + ntohl (mp->tx_sw_if_index)); vat_json_object_add_uint (node, "label_count", len); for (i = 0; i < len; i++) { @@ -13962,9 +14765,9 @@ static void vl_api_mpls_gre_tunnel_details_t_handler_json } static int -api_mpls_gre_tunnel_dump (vat_main_t * vam) +api_mpls_eth_tunnel_dump (vat_main_t * vam) { - vl_api_mpls_gre_tunnel_dump_t *mp; + vl_api_mpls_eth_tunnel_dump_t *mp; f64 timeout; i32 index = -1; @@ -13980,7 +14783,7 @@ api_mpls_gre_tunnel_dump (vat_main_t * vam) fformat (vam->ofp, " tunnel_index %d\n", index); - M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump); + M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump); mp->tunnel_index = htonl (index); S; @@ -13993,34 +14796,30 @@ api_mpls_gre_tunnel_dump (vat_main_t * vam) W; } -static void vl_api_mpls_eth_tunnel_details_t_handler - (vl_api_mpls_eth_tunnel_details_t * mp) +static void vl_api_mpls_fib_encap_details_t_handler + (vl_api_mpls_fib_encap_details_t * mp) { vat_main_t *vam = &vat_main; i32 i; i32 len = ntohl (mp->nlabels); - fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ", - ntohl (mp->tunnel_index), - format_ethernet_address, &mp->tunnel_dst_mac, - format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width)); + fformat (vam->ofp, "table %d, dest %U, label ", + ntohl (mp->fib_index), format_ip4_address, &mp->dest, len); for (i = 0; i < len; i++) { fformat (vam->ofp, "%u ", ntohl (mp->labels[i])); } fformat (vam->ofp, "\n"); - fformat (vam->ofp, " tx on %d, rx fib index %d\n", - ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index)); } -static void vl_api_mpls_eth_tunnel_details_t_handler_json - (vl_api_mpls_eth_tunnel_details_t * mp) +static void vl_api_mpls_fib_encap_details_t_handler_json + (vl_api_mpls_fib_encap_details_t * mp) { vat_main_t *vam = &vat_main; vat_json_node_t *node = NULL; - struct in_addr ip4; i32 i; i32 len = ntohl (mp->nlabels); + struct in_addr ip4; if (VAT_JSON_ARRAY != vam->json_tree.type) { @@ -14030,20 +14829,11 @@ static void vl_api_mpls_eth_tunnel_details_t_handler_json node = vat_json_array_add (&vam->json_tree); vat_json_init_object (node); - vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index)); - clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4)); - vat_json_object_add_ip4 (node, "intfc_address", ip4); - vat_json_object_add_uint (node, "inner_fib_index", - ntohl (mp->inner_fib_index)); - vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width)); - vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index)); - vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index)); - vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only)); - vat_json_object_add_string_copy (node, "tunnel_dst_mac", - format (0, "%U", format_ethernet_address, - &mp->tunnel_dst_mac)); - vat_json_object_add_uint (node, "tx_sw_if_index", - ntohl (mp->tx_sw_if_index)); + vat_json_object_add_uint (node, "table", ntohl (mp->fib_index)); + vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index)); + clib_memcpy (&ip4, &(mp->dest), sizeof (ip4)); + vat_json_object_add_ip4 (node, "dest", ip4); + vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit)); vat_json_object_add_uint (node, "label_count", len); for (i = 0; i < len; i++) { @@ -14052,26 +14842,103 @@ static void vl_api_mpls_eth_tunnel_details_t_handler_json } static int -api_mpls_eth_tunnel_dump (vat_main_t * vam) +api_mpls_fib_encap_dump (vat_main_t * vam) { - vl_api_mpls_eth_tunnel_dump_t *mp; + vl_api_mpls_fib_encap_dump_t *mp; f64 timeout; - i32 index = -1; - /* Parse args required to build the message */ - while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT) + M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump); + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); + S; + } + W; +} + +#define vl_api_mpls_fib_details_t_endian vl_noop_handler +#define vl_api_mpls_fib_details_t_print vl_noop_handler + +static void +vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp) +{ + vat_main_t *vam = &vat_main; + int count = ntohl (mp->count); + vl_api_fib_path_t *fp; + int i; + + fformat (vam->ofp, + "table-id %d, label %u, ess_bit %u\n", + ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit); + fp = mp->path; + for (i = 0; i < count; i++) { - if (!unformat (vam->input, "tunnel_index %d", &index)) + fformat (vam->ofp, + " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, " + "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight), + ntohl (fp->sw_if_index), fp->is_local, fp->is_drop, + fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address, + fp->next_hop, fp->afi); + fp++; + } +} + +static void vl_api_mpls_fib_details_t_handler_json + (vl_api_mpls_fib_details_t * mp) +{ + vat_main_t *vam = &vat_main; + int count = ntohl (mp->count); + vat_json_node_t *node = NULL; + struct in_addr ip4; + struct in6_addr ip6; + vl_api_fib_path_t *fp; + int i; + + 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", ntohl (mp->table_id)); + vat_json_object_add_uint (node, "s_bit", mp->eos_bit); + vat_json_object_add_uint (node, "label", ntohl (mp->label)); + vat_json_object_add_uint (node, "path_count", count); + fp = mp->path; + for (i = 0; i < count; i++) + { + vat_json_object_add_uint (node, "weight", ntohl (fp->weight)); + vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index)); + vat_json_object_add_uint (node, "is_local", fp->is_local); + vat_json_object_add_uint (node, "is_drop", fp->is_drop); + vat_json_object_add_uint (node, "is_unreach", fp->is_unreach); + vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit); + vat_json_object_add_uint (node, "next_hop_afi", fp->afi); + if (fp->afi == IP46_TYPE_IP4) { - index = -1; - break; + clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4)); + vat_json_object_add_ip4 (node, "next_hop", ip4); + } + else if (fp->afi == IP46_TYPE_IP6) + { + clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6)); + vat_json_object_add_ip6 (node, "next_hop", ip6); } } +} - fformat (vam->ofp, " tunnel_index %d\n", index); +static int +api_mpls_fib_dump (vat_main_t * vam) +{ + vl_api_mpls_fib_dump_t *mp; + f64 timeout; - M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump); - mp->tunnel_index = htonl (index); + M (MPLS_FIB_DUMP, mpls_fib_dump); S; /* Use a control ping for synchronization */ @@ -14083,30 +14950,44 @@ api_mpls_eth_tunnel_dump (vat_main_t * vam) W; } -static void vl_api_mpls_fib_encap_details_t_handler - (vl_api_mpls_fib_encap_details_t * mp) +#define vl_api_ip_fib_details_t_endian vl_noop_handler +#define vl_api_ip_fib_details_t_print vl_noop_handler + +static void +vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp) { vat_main_t *vam = &vat_main; - i32 i; - i32 len = ntohl (mp->nlabels); + int count = ntohl (mp->count); + vl_api_fib_path_t *fp; + int i; - fformat (vam->ofp, "table %d, dest %U, label ", - ntohl (mp->fib_index), format_ip4_address, &mp->dest, len); - for (i = 0; i < len; i++) + fformat (vam->ofp, + "table-id %d, prefix %U/%d\n", + ntohl (mp->table_id), format_ip4_address, mp->address, + mp->address_length); + fp = mp->path; + for (i = 0; i < count; i++) { - fformat (vam->ofp, "%u ", ntohl (mp->labels[i])); + fformat (vam->ofp, + " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, " + "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight), + ntohl (fp->sw_if_index), fp->is_local, fp->is_drop, + fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address, + fp->next_hop, fp->afi); + fp++; } - fformat (vam->ofp, "\n"); } -static void vl_api_mpls_fib_encap_details_t_handler_json - (vl_api_mpls_fib_encap_details_t * mp) +static void vl_api_ip_fib_details_t_handler_json + (vl_api_ip_fib_details_t * mp) { vat_main_t *vam = &vat_main; + int count = ntohl (mp->count); vat_json_node_t *node = NULL; - i32 i; - i32 len = ntohl (mp->nlabels); struct in_addr ip4; + struct in6_addr ip6; + vl_api_fib_path_t *fp; + int i; if (VAT_JSON_ARRAY != vam->json_tree.type) { @@ -14116,25 +14997,41 @@ static void vl_api_mpls_fib_encap_details_t_handler_json node = vat_json_array_add (&vam->json_tree); vat_json_init_object (node); - vat_json_object_add_uint (node, "table", ntohl (mp->fib_index)); - vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index)); - clib_memcpy (&ip4, &(mp->dest), sizeof (ip4)); - vat_json_object_add_ip4 (node, "dest", ip4); - vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit)); - vat_json_object_add_uint (node, "label_count", len); - for (i = 0; i < len; i++) + vat_json_object_add_uint (node, "table", ntohl (mp->table_id)); + clib_memcpy (&ip4, &mp->address, sizeof (ip4)); + vat_json_object_add_ip4 (node, "prefix", ip4); + vat_json_object_add_uint (node, "mask_length", mp->address_length); + vat_json_object_add_uint (node, "path_count", count); + fp = mp->path; + for (i = 0; i < count; i++) { - vat_json_object_add_uint (node, "label", ntohl (mp->labels[i])); + vat_json_object_add_uint (node, "weight", ntohl (fp->weight)); + vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index)); + vat_json_object_add_uint (node, "is_local", fp->is_local); + vat_json_object_add_uint (node, "is_drop", fp->is_drop); + vat_json_object_add_uint (node, "is_unreach", fp->is_unreach); + vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit); + vat_json_object_add_uint (node, "next_hop_afi", fp->afi); + if (fp->afi == IP46_TYPE_IP4) + { + clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4)); + vat_json_object_add_ip4 (node, "next_hop", ip4); + } + else if (fp->afi == IP46_TYPE_IP6) + { + clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6)); + vat_json_object_add_ip6 (node, "next_hop", ip6); + } } } static int -api_mpls_fib_encap_dump (vat_main_t * vam) +api_ip_fib_dump (vat_main_t * vam) { - vl_api_mpls_fib_encap_dump_t *mp; + vl_api_ip_fib_dump_t *mp; f64 timeout; - M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump); + M (IP_FIB_DUMP, ip_fib_dump); S; /* Use a control ping for synchronization */ @@ -14146,23 +15043,44 @@ api_mpls_fib_encap_dump (vat_main_t * vam) W; } -static void vl_api_mpls_fib_decap_details_t_handler - (vl_api_mpls_fib_decap_details_t * mp) +#define vl_api_ip6_fib_details_t_endian vl_noop_handler +#define vl_api_ip6_fib_details_t_print vl_noop_handler + +static void +vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp) { vat_main_t *vam = &vat_main; + int count = ntohl (mp->count); + vl_api_fib_path_t *fp; + int i; fformat (vam->ofp, - "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n", - ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag, - ntohl (mp->label), ntohl (mp->s_bit)); + "table-id %d, prefix %U/%d\n", + ntohl (mp->table_id), format_ip6_address, mp->address, + mp->address_length); + fp = mp->path; + for (i = 0; i < count; i++) + { + fformat (vam->ofp, + " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, " + "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight), + ntohl (fp->sw_if_index), fp->is_local, fp->is_drop, + fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address, + fp->next_hop, fp->afi); + fp++; + } } -static void vl_api_mpls_fib_decap_details_t_handler_json - (vl_api_mpls_fib_decap_details_t * mp) +static void vl_api_ip6_fib_details_t_handler_json + (vl_api_ip6_fib_details_t * mp) { vat_main_t *vam = &vat_main; + int count = ntohl (mp->count); vat_json_node_t *node = NULL; struct in_addr ip4; + struct in6_addr ip6; + vl_api_fib_path_t *fp; + int i; if (VAT_JSON_ARRAY != vam->json_tree.type) { @@ -14172,24 +15090,41 @@ static void vl_api_mpls_fib_decap_details_t_handler_json node = vat_json_array_add (&vam->json_tree); vat_json_init_object (node); - vat_json_object_add_uint (node, "table", ntohl (mp->fib_index)); - vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index)); - clib_memcpy (&ip4, &(mp->dest), sizeof (ip4)); - vat_json_object_add_ip4 (node, "dest", ip4); - vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit)); - vat_json_object_add_uint (node, "label", ntohl (mp->label)); - vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id)); - vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id)); - vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag); + vat_json_object_add_uint (node, "table", ntohl (mp->table_id)); + clib_memcpy (&ip6, &mp->address, sizeof (ip6)); + vat_json_object_add_ip6 (node, "prefix", ip6); + vat_json_object_add_uint (node, "mask_length", mp->address_length); + vat_json_object_add_uint (node, "path_count", count); + fp = mp->path; + for (i = 0; i < count; i++) + { + vat_json_object_add_uint (node, "weight", ntohl (fp->weight)); + vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index)); + vat_json_object_add_uint (node, "is_local", fp->is_local); + vat_json_object_add_uint (node, "is_drop", fp->is_drop); + vat_json_object_add_uint (node, "is_unreach", fp->is_unreach); + vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit); + vat_json_object_add_uint (node, "next_hop_afi", fp->afi); + if (fp->afi == IP46_TYPE_IP4) + { + clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4)); + vat_json_object_add_ip4 (node, "next_hop", ip4); + } + else if (fp->afi == IP46_TYPE_IP6) + { + clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6)); + vat_json_object_add_ip6 (node, "next_hop", ip6); + } + } } static int -api_mpls_fib_decap_dump (vat_main_t * vam) +api_ip6_fib_dump (vat_main_t * vam) { - vl_api_mpls_fib_decap_dump_t *mp; + vl_api_ip6_fib_dump_t *mp; f64 timeout; - M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump); + M (IP6_FIB_DUMP, ip6_fib_dump); S; /* Use a control ping for synchronization */ @@ -14486,6 +15421,94 @@ static void mp->transport_protocol); } +static int +api_sw_interface_span_enable_disable (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + vl_api_sw_interface_span_enable_disable_t *mp; + f64 timeout; + u32 src_sw_if_index = ~0; + u32 dst_sw_if_index = ~0; + u8 enable = 1; + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "src %U", unformat_sw_if_index, vam, &src_sw_if_index)) + ; + else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index)) + ; + else + if (unformat + (i, "dst %U", unformat_sw_if_index, vam, &dst_sw_if_index)) + ; + else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index)) + ; + else if (unformat (i, "disable")) + enable = 0; + else + break; + } + + M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable); + + mp->sw_if_index_from = htonl (src_sw_if_index); + mp->sw_if_index_to = htonl (dst_sw_if_index); + mp->enable = enable; + + S; + W; + /* NOTREACHED */ + return 0; +} + +static void +vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t + * mp) +{ + vat_main_t *vam = &vat_main; + + fformat (vam->ofp, "%u => %u\n", + ntohl (mp->sw_if_index_from), ntohl (mp->sw_if_index_to)); +} + +static void + vl_api_sw_interface_span_details_t_handler_json + (vl_api_sw_interface_span_details_t * mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *node = NULL; + + 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, "src-if-index", + ntohl (mp->sw_if_index_from)); + vat_json_object_add_uint (node, "dst-if-index", ntohl (mp->sw_if_index_to)); +} + +static int +api_sw_interface_span_dump (vat_main_t * vam) +{ + vl_api_sw_interface_span_dump_t *mp; + f64 timeout; + + M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump); + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t *mp; + M (CONTROL_PING, control_ping); + S; + } + W; +} + int api_pg_create_interface (vat_main_t * vam) { @@ -14871,6 +15894,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) { @@ -14963,6 +16027,8 @@ api_delete_subif (vat_main_t * vam) while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) { + if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index)) + ; if (unformat (i, "sw_if_index %d", &sw_if_index)) ; else @@ -14983,6 +16049,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) { @@ -15289,6 +16531,8 @@ _(sw_interface_add_del_address, \ " | sw_if_index | [del] [del-all] ") \ _(sw_interface_set_table, \ " | sw_if_index vrf [ipv6]") \ +_(sw_interface_set_mpls_enable, \ + " | sw_if_index [disable | dis]") \ _(sw_interface_set_vpath, \ " | sw_if_index enable | disable") \ _(sw_interface_set_l2_xconnect, \ @@ -15298,6 +16542,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") \ @@ -15315,21 +16567,23 @@ _(tap_delete, \ " | sw_if_index ") \ _(sw_interface_tap_dump, "") \ _(ip_add_del_route, \ - "/ via [vrf ]\n" \ + "/ via [table-id ]\n" \ "[ | sw_if_index ] [resolve-attempts ]\n" \ "[weight ] [drop] [local] [classify ] [del]\n" \ "[multipath] [count ]") \ +_(mpls_route_add_del, \ + "