*------------------------------------------------------------------
* 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:
#include <vnet/l2/l2_vtr.h>
#include <vnet/classify/input_acl.h>
#include <vnet/classify/policer_classify.h>
+#include <vnet/classify/flow_classify.h>
#include <vnet/mpls/mpls.h>
#if DPDK > 0
#include <vnet/ipsec/ipsec.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/ip/ip_source_and_port_range_check.h>
#include <vnet/policer/xlate.h>
+#include <vnet/span/span.h>
#include <vnet/policer/policer.h>
#include <vnet/policer/police.h>
}
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;
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)
{
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)
{
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)
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
_(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) \
_(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 \
_(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) \
_(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, \
_(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) \
_(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) \
_(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) \
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 */
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);
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)
{
}
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)
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;
}
}
/* 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;
}
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;
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;
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;
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)
{
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;
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;
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;
}
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);
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;
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)
{
}
/* 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 */
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));
}
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)
{
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)
{
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)
{
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;
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)
{
u8 *mask = 0;
u8 *l2 = 0;
u8 *l3 = 0;
+ u8 *l4 = 0;
int i;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
;
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)
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 */
/* 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)
{
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;
u8 *match = 0;
u8 *l2 = 0;
u8 *l3 = 0;
+ u8 *l4 = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
;
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)
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 */
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;
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)
{
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))
{
}
}
- 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);
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)
{
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
{
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;
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++)
{
}
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;
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;
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)
{
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++)
{
}
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 */
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)
{
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 */
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)
{
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 */
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)
{
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)
{
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
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)
{
"<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
_(sw_interface_set_table, \
"<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
+_(sw_interface_set_mpls_enable, \
+ "<intfc> | sw_if_index [disable | dis]") \
_(sw_interface_set_vpath, \
"<intfc> | sw_if_index <id> enable | disable") \
_(sw_interface_set_l2_xconnect, \
"<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
"[shg <split-horizon-group>] [bvi]\n" \
"enable | disable") \
+_(sw_interface_set_dpdk_hqos_pipe, \
+ "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
+ "profile <profile-id>\n") \
+_(sw_interface_set_dpdk_hqos_subport, \
+ "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
+ "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
+_(sw_interface_set_dpdk_hqos_tctbl, \
+ "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
_(bridge_domain_add_del, \
"bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
_(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
"<vpp-if-name> | sw_if_index <id>") \
_(sw_interface_tap_dump, "") \
_(ip_add_del_route, \
- "<addr>/<mask> via <addr> [vrf <n>]\n" \
+ "<addr>/<mask> via <addr> [table-id <n>]\n" \
"[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
"[weight <n>] [drop] [local] [classify <n>] [del]\n" \
"[multipath] [count <n>]") \
+_(mpls_route_add_del, \
+ "<label> <eos> via <addr> [table-id <n>]\n" \
+ "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
+ "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
+ "[multipath] [count <n>]") \
+_(mpls_ip_bind_unbind, \
+ "<label> <addr/len>") \
_(proxy_arp_add_del, \
"<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
_(proxy_arp_intfc_enable_disable, \
"<intfc> | sw_if_index <id> enable | disable") \
_(mpls_add_del_encap, \
"label <n> dst <ip4-addr> [vrf <n>] [del]") \
-_(mpls_add_del_decap, \
- "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
-_(mpls_gre_add_del_tunnel, \
- "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
- "adj <ip4-address>/<mask-width> [del]") \
_(sw_interface_set_unnumbered, \
"<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
_(ip_neighbor_add_del, \
"rloc <locator> p <prio> " \
"w <weight> [rloc <loc> ... ] " \
"action <action> [del-all]") \
-_(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
- "<src-eid> rloc <locator> p <prio> w <weight>"\
- "[rloc <loc> ... ] action <action>") \
+_(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
+ "<local-eid>") \
_(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
_(lisp_map_request_mode, "src-dst|dst-only") \
_(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
_(lisp_eid_table_map_dump, "l2|l3") \
_(lisp_gpe_tunnel_dump, "") \
_(lisp_map_resolver_dump, "") \
+_(lisp_adjacencies_get, "vni <vni>") \
_(show_lisp_status, "") \
_(lisp_get_map_request_itr_rlocs, "") \
_(show_lisp_pitr, "") \
_(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
"[master|slave]") \
_(netmap_delete, "name <interface name>") \
-_(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
_(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
_(mpls_fib_encap_dump, "") \
-_(mpls_fib_decap_dump, "") \
+_(mpls_fib_dump, "") \
_(classify_table_ids, "") \
_(classify_table_by_interface, "sw_if_index <sw_if_index>") \
_(classify_table_info, "table_id <nn>") \
_(ipfix_classify_stream_dump, "") \
_(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
_(ipfix_classify_table_dump, "") \
+_(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [[dst <intfc> | dst_sw_if_index <id>] | disable]") \
+_(sw_interface_span_dump, "") \
_(get_next_index, "node-name <node-name> next-node-name <node-name>") \
_(pg_create_interface, "if_id <nn>") \
_(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
_(ipsec_gre_add_del_tunnel, \
"src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
_(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
-_(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>")
+_(delete_subif,"<intfc> | sw_if_index <nn>") \
+_(l2_interface_pbb_tag_rewrite, \
+ "<intfc> | sw_if_index <nn> \n" \
+ "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
+ "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
+_(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
+_(flow_classify_set_interface, \
+ "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
+_(flow_classify_dump, "type [ip4|ip6]") \
+_(ip_fib_dump, "") \
+_(ip6_fib_dump, "")
/* List of command functions, CLI names map directly to functions */
#define foreach_cli_function \
Code Review / vpp.git / blobdiff