/*
*------------------------------------------------------------------
- * api_format.c
- *
+ * api_format.c
+ *
* Copyright (c) 2014 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.
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
- * limitations under the License.
+ * limitations under the License.
*------------------------------------------------------------------
*/
#include <vnet/vxlan-gpe/vxlan_gpe.h>
#include <vnet/lisp-gpe/lisp_gpe.h>
-#include <api/vpe_msg_enum.h>
-#include <vnet/l2/l2_classify.h>
+#include <vpp-api/vpe_msg_enum.h>
+#include <vnet/l2/l2_classify.h>
#include <vnet/l2/l2_vtr.h>
#include <vnet/classify/input_acl.h>
+#include <vnet/classify/policer_classify.h>
+#include <vnet/mpls-gre/mpls.h>
#if DPDK > 0
#include <vnet/ipsec/ipsec.h>
#include <vnet/ipsec/ikev2.h>
#include <vnet/cop/cop.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/policer/xlate.h>
+#include <vnet/policer/policer.h>
+#include <vnet/policer/police.h>
#include "vat/json_format.h"
+#include <sys/stat.h>
+
#define vl_typedefs /* define message structures */
-#include <api/vpe_all_api_h.h>
+#include <vpp-api/vpe_all_api_h.h>
#undef vl_typedefs
/* declare message handlers for each api */
#define vl_endianfun /* define message structures */
-#include <api/vpe_all_api_h.h>
+#include <vpp-api/vpe_all_api_h.h>
#undef vl_endianfun
/* instantiate all the print functions we know about */
#define vl_print(handle, ...)
#define vl_printfun
-#include <api/vpe_all_api_h.h>
+#include <vpp-api/vpe_all_api_h.h>
#undef vl_printfun
uword unformat_sw_if_index (unformat_input_t * input, va_list * args)
n_colon = 0;
n_hex_digits++;
}
-
+
/* Save position of :: */
if (n_colon == 2)
{
return 1;
}
+uword
+unformat_dscp (unformat_input_t * input, va_list * va)
+{
+ u8 * r = va_arg (*va, u8 *);
+
+ if (0) ;
+#define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
+ foreach_vnet_dscp
+#undef _
+ else
+ return 0;
+ return 1;
+}
+
+uword
+unformat_policer_action_type (unformat_input_t * input, va_list * va)
+{
+ sse2_qos_pol_action_params_st * a
+ = va_arg (*va, sse2_qos_pol_action_params_st *);
+
+ if (unformat (input, "drop"))
+ a->action_type = SSE2_QOS_ACTION_DROP;
+ else if (unformat (input, "transmit"))
+ a->action_type = SSE2_QOS_ACTION_TRANSMIT;
+ else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
+ a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
+ else
+ return 0;
+ return 1;
+}
+
+uword
+unformat_classify_table_type (unformat_input_t * input, va_list * va)
+{
+ u32 * r = va_arg (*va, u32 *);
+ u32 tid;
+
+ if (unformat (input, "ip4"))
+ tid = POLICER_CLASSIFY_TABLE_IP4;
+ else if (unformat (input, "ip6"))
+ tid = POLICER_CLASSIFY_TABLE_IP6;
+ else if (unformat (input, "l2"))
+ tid = POLICER_CLASSIFY_TABLE_L2;
+ else
+ return 0;
+
+ *r = tid;
+ return 1;
+}
+
u8 * format_ip4_address (u8 * s, va_list * args)
{
u8 * a = va_arg (*args, u8 *);
u8 * format_ip46_address (u8 * s, va_list * args)
{
ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
- return ip46_address_is_ip4(ip46)?
+ ip46_type_t type = va_arg (*args, ip46_type_t);
+ int is_ip4 = 1;
+
+ switch (type)
+ {
+ case IP46_TYPE_ANY:
+ is_ip4 = ip46_address_is_ip4(ip46);
+ break;
+ case IP46_TYPE_IP4:
+ is_ip4 = 1;
+ break;
+ case IP46_TYPE_IP6:
+ is_ip4 = 0;
+ break;
+ }
+
+ return is_ip4 ?
format(s, "%U", format_ip4_address, &ip46->ip4):
format(s, "%U", format_ip6_address, &ip46->ip6);
}
a->as_u64[1] = clib_net_to_host_u64 (v1);
}
+void increment_mac_address (u64 *mac)
+{
+ u64 tmp = *mac;
+
+ tmp = clib_net_to_host_u64(tmp);
+ tmp += 1<<16; /* skip unused (least significant) octets */
+ tmp = clib_host_to_net_u64 (tmp);
+ *mac = tmp;
+}
-static void vl_api_create_loopback_reply_t_handler
+static void vl_api_create_loopback_reply_t_handler
(vl_api_create_loopback_reply_t * mp)
{
vat_main_t * vam = &vat_main;
i32 retval = ntohl(mp->retval);
vam->retval = retval;
- vam->result_ready = 1;
vam->regenerate_interface_table = 1;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
+ vam->result_ready = 1;
}
static void vl_api_create_loopback_reply_t_handler_json
vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->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_af_packet_create_reply_t_handler
+(vl_api_af_packet_create_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+
+ vam->retval = retval;
+ vam->regenerate_interface_table = 1;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
+ vam->result_ready = 1;
+}
+
+static void vl_api_af_packet_create_reply_t_handler_json
+(vl_api_af_packet_create_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, "sw_if_index", ntohl(mp->sw_if_index));
+
vat_json_print(vam->ofp, &node);
vat_json_free(&node);
vam->result_ready = 1;
}
-static void vl_api_create_vlan_subif_reply_t_handler
+static void vl_api_create_vlan_subif_reply_t_handler
(vl_api_create_vlan_subif_reply_t * mp)
{
vat_main_t * vam = &vat_main;
i32 retval = ntohl(mp->retval);
vam->retval = retval;
- vam->result_ready = 1;
vam->regenerate_interface_table = 1;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
+ vam->result_ready = 1;
}
static void vl_api_create_vlan_subif_reply_t_handler_json
vam->result_ready = 1;
}
-static void vl_api_create_subif_reply_t_handler
+static void vl_api_create_subif_reply_t_handler
(vl_api_create_subif_reply_t * mp)
{
vat_main_t * vam = &vat_main;
i32 retval = ntohl(mp->retval);
vam->retval = retval;
- vam->result_ready = 1;
vam->regenerate_interface_table = 1;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
+ vam->result_ready = 1;
}
static void vl_api_create_subif_reply_t_handler_json
vam->result_ready = 1;
}
-static void vl_api_interface_name_renumber_reply_t_handler
+static void vl_api_interface_name_renumber_reply_t_handler
(vl_api_interface_name_renumber_reply_t * mp)
{
vat_main_t * vam = &vat_main;
i32 retval = ntohl(mp->retval);
vam->retval = retval;
- vam->result_ready = 1;
vam->regenerate_interface_table = 1;
+ vam->result_ready = 1;
}
static void vl_api_interface_name_renumber_reply_t_handler_json
vam->result_ready = 1;
}
-/*
+/*
* Special-case: build the interface table, maintain
* the next loopback sw_if_index vbl.
*/
vat_main_t * vam = &vat_main;
u8 * s = format (0, "%s%c", mp->interface_name, 0);
- hash_set_mem (vam->sw_if_index_by_interface_name, s,
+ hash_set_mem (vam->sw_if_index_by_interface_name, s,
ntohl(mp->sw_if_index));
/* In sub interface case, fill the sub interface table entry */
vat_json_init_object(&node);
vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
- vat_json_object_add_uint(&node, "reply_in_shmem",
+ vat_json_object_add_uint(&node, "reply_in_shmem",
ntohl(mp->reply_in_shmem));
/* Toss the shared-memory original... */
pthread_mutex_lock (&am->vlib_rp->mutex);
reply = (u8 *)(mp->reply_in_shmem);
vec_free (reply);
-
+
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
- vam->result_ready = 1;
- if (retval == 0 &&
+ if (retval == 0 &&
((mp->new_table_index != 0xFFFFFFFF) ||
(mp->skip_n_vectors != 0xFFFFFFFF) ||
(mp->match_n_vectors != 0xFFFFFFFF)))
- /*
+ /*
* Note: this is just barely thread-safe, depends on
* the main thread spinning waiting for an answer...
*/
errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
ntohl(mp->new_table_index),
ntohl(mp->skip_n_vectors), ntohl(mp->match_n_vectors));
+ vam->result_ready = 1;
}
}
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
- vam->result_ready = 1;
if (retval == 0)
errmsg ("node index %d\n", ntohl(mp->node_index));
+ vam->result_ready = 1;
}
}
vam->result_ready = 1;
}
+static void vl_api_get_next_index_reply_t_handler
+(vl_api_get_next_index_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+ if (vam->async_mode) {
+ vam->async_errors += (retval < 0);
+ } else {
+ vam->retval = retval;
+ if (retval == 0)
+ errmsg ("next node index %d\n", ntohl(mp->next_index));
+ vam->result_ready = 1;
+ }
+}
+
+static void vl_api_get_next_index_reply_t_handler_json
+(vl_api_get_next_index_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, "next_index", ntohl(mp->next_index));
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
static void vl_api_add_node_next_reply_t_handler
(vl_api_add_node_next_reply_t * mp)
{
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
- vam->result_ready = 1;
if (retval == 0)
errmsg ("next index %d\n", ntohl(mp->next_index));
+ vam->result_ready = 1;
}
}
vam->result_ready = 1;
}
-static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
+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;
}
-static void vl_api_show_version_reply_t_handler
+static void vl_api_show_version_reply_t_handler
(vl_api_show_version_reply_t * mp)
{
vat_main_t * vam = &vat_main;
vam->result_ready = 1;
}
-static void vl_api_ip4_arp_event_t_handler
+static void vl_api_ip4_arp_event_t_handler
(vl_api_ip4_arp_event_t * mp)
{
vat_main_t * vam = &vat_main;
/* JSON output not supported */
}
-/*
+/*
* Special-case: build the bridge domain table, maintain
* the next bd id vbl.
*/
vat_json_init_array(array);
}
-/*
+/*
* Special-case: build the bridge domain sw if table.
*/
static void vl_api_bridge_domain_sw_if_details_t_handler
u32 sw_if_index;
sw_if_index = ntohl (mp->sw_if_index);
- hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
+ hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
({
if ((u32) p->value[0] == sw_if_index) {
sw_if_name = (u8 *)(p->key);
break;
}
}));
-
- fformat (vam->ofp, "%7d %3d %s", sw_if_index,
- mp->shg, sw_if_name ? (char *)sw_if_name :
+
+ fformat (vam->ofp, "%7d %3d %s", sw_if_index,
+ mp->shg, sw_if_name ? (char *)sw_if_name :
"sw_if_index not found!");
}
vam->result_ready = 1;
}
+static void vl_api_noprint_control_ping_reply_t_handler
+(vl_api_noprint_control_ping_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+ if (vam->async_mode) {
+ vam->async_errors += (retval < 0);
+ } else {
+ vam->retval = retval;
+ vam->result_ready = 1;
+ }
+}
+
+static void vl_api_noprint_control_ping_reply_t_handler_json
+(vl_api_noprint_control_ping_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+
+ if (vam->noprint_msg) {
+ vam->retval = retval;
+ vam->result_ready = 1;
+ return;
+ }
+
+ if (VAT_JSON_NONE != vam->json_tree.type) {
+ vat_json_print(vam->ofp, &vam->json_tree);
+ vat_json_free(&vam->json_tree);
+ vam->json_tree.type = VAT_JSON_NONE;
+ } else {
+ /* just print [] */
+ vat_json_init_array(&vam->json_tree);
+ vat_json_print(vam->ofp, &vam->json_tree);
+ vam->json_tree.type = VAT_JSON_NONE;
+ }
+
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
static void vl_api_l2_flags_reply_t_handler
(vl_api_l2_flags_reply_t * mp)
{
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
- vam->result_ready = 1;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
+ vam->result_ready = 1;
}
+
}
static void vl_api_tap_connect_reply_t_handler_json
vam->retval = ntohl(mp->retval);
vam->result_ready = 1;
+
}
static void vl_api_tap_modify_reply_t_handler
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
vam->result_ready = 1;
}
}
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
vam->result_ready = 1;
}
}
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
vam->result_ready = 1;
}
}
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
vam->result_ready = 1;
}
}
vam->async_errors += (retval < 0);
} else {
vam->retval = retval;
+ vam->sw_if_index = ntohl (mp->sw_if_index);
vam->result_ready = 1;
}
}
{
vat_main_t * vam = &vat_main;
i32 retval = ntohl(mp->retval);
-
+
if (vam->async_mode) {
vam->async_errors += (retval < 0);
} else {
vat_json_init_object(&node);
vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
- vat_json_object_add_uint(&node, "first_msg_id",
+ vat_json_object_add_uint(&node, "first_msg_id",
(uint) ntohs(mp->first_msg_id));
vat_json_print(vam->ofp, &node);
void * oldheap;
vlib_node_t * node;
int i;
-
+
if (vam->async_mode) {
vam->async_errors += (retval < 0);
} else {
oldheap = svm_push_data_heap (am->vlib_rp);
vec_free (reply);
-
+
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
oldheap = svm_push_data_heap (am->vlib_rp);
vec_free (reply);
-
+
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
}
static void
-vl_api_lisp_locator_set_details_t_handler (
- vl_api_lisp_locator_set_details_t *mp)
+vl_api_lisp_locator_details_t_handler (
+ vl_api_lisp_locator_details_t *mp)
{
vat_main_t *vam = &vat_main;
- u8 * tmp_str = NULL;
-
- if (mp->local) {
- fformat(vam->ofp, "%=20s%=16d%=16d%=16d\n",
- mp->locator_set_name,
- ntohl(mp->sw_if_index),
- mp->priority,
- mp->weight);
+ locator_msg_t loc;
+ u8 * tmp_str = 0;
+
+ memset(&loc, 0, sizeof(loc));
+ if (vam->noprint_msg) {
+ loc.local = mp->local;
+ loc.priority = mp->priority;
+ loc.weight = mp->weight;
+ if (loc.local) {
+ loc.sw_if_index = ntohl(mp->sw_if_index);
+ } else {
+ loc.is_ipv6 = mp->is_ipv6;
+ clib_memcpy(loc.ip_address, mp->ip_address, sizeof(loc.ip_address));
+ }
+ vec_add1(vam->locator_msg, loc);
} else {
- tmp_str = format(0,"%U/%d",
- mp->is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->ip_address,
- mp->prefix_len);
-
- fformat(vam->ofp, "%=20s%=16s%=16d%=16d\n",
- mp->locator_set_name,
- tmp_str,
- mp->priority,
- mp->weight);
+ if (mp->local) {
+ tmp_str = format(tmp_str, "%=16d%=16d%=16d\n",
+ ntohl(mp->sw_if_index),
+ mp->priority,
+ mp->weight);
+ } else {
+ tmp_str = format(tmp_str, "%=16U%=16d%=16d\n",
+ mp->is_ipv6 ? format_ip6_address :
+ format_ip4_address,
+ mp->ip_address,
+ mp->priority,
+ mp->weight);
+ }
+
+ fformat(vam->ofp, "%s", tmp_str);
+
vec_free(tmp_str);
}
}
static void
-vl_api_lisp_locator_set_details_t_handler_json (
- vl_api_lisp_locator_set_details_t *mp)
+vl_api_lisp_locator_details_t_handler_json (
+ vl_api_lisp_locator_details_t *mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t *node = NULL;
+ locator_msg_t loc;
struct in6_addr ip6;
struct in_addr ip4;
+ memset(&loc, 0, sizeof(loc));
+ if (vam->noprint_msg) {
+ loc.local = mp->local;
+ loc.priority = mp->priority;
+ loc.weight = mp->weight;
+ if (loc.local) {
+ loc.sw_if_index = ntohl(mp->sw_if_index);
+ } else {
+ loc.is_ipv6 = mp->is_ipv6;
+ clib_memcpy(loc.ip_address, mp->ip_address, sizeof(loc.ip_address));
+ }
+ vec_add1(vam->locator_msg, loc);
+ return;
+ }
+
if (VAT_JSON_ARRAY != vam->json_tree.type) {
ASSERT(VAT_JSON_NONE == vam->json_tree.type);
vat_json_init_array(&vam->json_tree);
node = vat_json_array_add(&vam->json_tree);
vat_json_init_object(node);
- vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
+
if (mp->local) {
- vat_json_object_add_uint(node, "locator", ntohl(mp->sw_if_index));
+ vat_json_object_add_uint(node, "locator_index", ntohl(mp->sw_if_index));
} else {
- if (mp->is_ipv6) {
- clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
- vat_json_object_add_ip6(node, "locator", ip6);
- } else {
- clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
- vat_json_object_add_ip4(node, "locator", ip4);
- }
- vat_json_object_add_uint(node, "prefix-length", mp->prefix_len);
+ if (mp->is_ipv6) {
+ clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
+ vat_json_object_add_ip6(node, "locator", ip6);
+ } else {
+ clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
+ vat_json_object_add_ip4(node, "locator", ip4);
+ }
}
vat_json_object_add_uint(node, "priority", mp->priority);
vat_json_object_add_uint(node, "weight", mp->weight);
}
+static void
+vl_api_lisp_locator_set_details_t_handler (
+ vl_api_lisp_locator_set_details_t *mp)
+{
+ vat_main_t *vam = &vat_main;
+ locator_set_msg_t ls;
+
+ ls.locator_set_index = ntohl(mp->locator_set_index);
+ ls.locator_set_name = format(0, "%s", mp->locator_set_name);
+ vec_add1(vam->locator_set_msg, ls);
+}
+
+static void
+vl_api_lisp_locator_set_details_t_handler_json (
+ vl_api_lisp_locator_set_details_t *mp)
+{
+ vat_main_t *vam = &vat_main;
+ locator_set_msg_t ls;
+
+ ls.locator_set_index = ntohl(mp->locator_set_index);
+ ls.locator_set_name = format(0, "%s", mp->locator_set_name);
+ vec_add1(vam->locator_set_msg, ls);
+}
+
static void
vl_api_lisp_local_eid_table_details_t_handler (
vl_api_lisp_local_eid_table_details_t *mp)
{
vat_main_t *vam = &vat_main;
u8 *prefix;
+ u8 * (*format_eid)(u8 *, va_list *) = 0;
+
+ switch (mp->eid_type)
+ {
+ case 0: format_eid = format_ip4_address; break;
+ case 1: format_eid = format_ip6_address; break;
+ case 2: format_eid = format_ethernet_address; break;
+ default:
+ errmsg ("unknown EID type %d!", mp->eid_type);
+ return;
+ }
- prefix = format(0, "%U/%d",
- mp->eid_is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->eid_ip_address,
- mp->eid_prefix_len);
+ prefix = format(0, "[%d] %U/%d",
+ clib_net_to_host_u32 (mp->vni),
+ format_eid, mp->eid, mp->eid_prefix_len);
fformat(vam->ofp, "%=20s%=30s\n",
mp->locator_set_name, prefix);
vec_free(prefix);
}
+static void
+vl_api_lisp_eid_table_map_details_t_handler (
+ vl_api_lisp_eid_table_map_details_t *mp)
+{
+ vat_main_t *vam = &vat_main;
+
+ u8 * line = format(0, "%=10d%=10d",
+ clib_net_to_host_u32 (mp->vni),
+ clib_net_to_host_u32 (mp->vrf));
+ fformat(vam->ofp, "%v\n", line);
+ vec_free(line);
+}
+
+static void
+vl_api_lisp_eid_table_map_details_t_handler_json (
+ vl_api_lisp_eid_table_map_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, "vrf", clib_net_to_host_u32 (mp->vrf));
+ vat_json_object_add_uint(node, "vni", clib_net_to_host_u32 (mp->vni));
+}
+
static void
vl_api_lisp_local_eid_table_details_t_handler_json (
vl_api_lisp_local_eid_table_details_t *mp)
vat_json_node_t *node = NULL;
struct in6_addr ip6;
struct in_addr ip4;
+ u8 * s = 0;
if (VAT_JSON_ARRAY != vam->json_tree.type) {
ASSERT(VAT_JSON_NONE == vam->json_tree.type);
vat_json_init_object(node);
vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
- if (mp->eid_is_ipv6) {
- clib_memcpy(&ip6, mp->eid_ip_address, sizeof(ip6));
- vat_json_object_add_ip6(node, "eid address", ip6);
- } else {
- clib_memcpy(&ip4, mp->eid_ip_address, sizeof(ip4));
- vat_json_object_add_ip4(node, "eid address", ip4);
- }
- vat_json_object_add_uint(node, "eid prefix len", mp->eid_prefix_len);
+ switch (mp->eid_type)
+ {
+ case 0:
+ clib_memcpy(&ip4, mp->eid, sizeof(ip4));
+ vat_json_object_add_ip4(node, "eid", ip4);
+ vat_json_object_add_uint(node, "eid-prefix-len", mp->eid_prefix_len);
+ break;
+ case 1:
+ clib_memcpy(&ip6, mp->eid, sizeof(ip6));
+ vat_json_object_add_ip6(node, "eid", ip6);
+ vat_json_object_add_uint(node, "eid-prefix-len", mp->eid_prefix_len);
+ break;
+ case 2:
+ s = format (0, "%U", format_ethernet_address, mp->eid);
+ vec_add1(s, 0);
+ vat_json_object_add_string_copy(node, "eid", s);
+ vec_free(s);
+ break;
+ default:
+ errmsg ("unknown EID type %d!", mp->eid_type);
+ return;
+ }
+ vat_json_object_add_uint(node, "vni", clib_net_to_host_u32 (mp->vni));
}
static u8 *
}
static void
-vl_api_lisp_enable_disable_status_details_t_handler
-(vl_api_lisp_enable_disable_status_details_t *mp)
+vl_api_show_lisp_status_reply_t_handler
+(vl_api_show_lisp_status_reply_t * mp)
{
vat_main_t *vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+
+ if (0 <= retval) {
+ fformat(vam->ofp, "feature: %s\ngpe: %s\n",
+ mp->feature_status ? "enabled" : "disabled",
+ mp->gpe_status ? "enabled" : "disabled");
+ }
- fformat(vam->ofp, "feature: %s\ngpe: %s\n",
- mp->feature_status ? "enabled" : "disabled",
- mp->gpe_status ? "enabled" : "disabled");
+ vam->retval = retval;
+ vam->result_ready = 1;
}
static void
-vl_api_lisp_enable_disable_status_details_t_handler_json
-(vl_api_lisp_enable_disable_status_details_t *mp)
+vl_api_show_lisp_status_reply_t_handler_json
+(vl_api_show_lisp_status_reply_t *mp)
{
vat_main_t *vam = &vat_main;
- vat_json_node_t *node = NULL;
+ vat_json_node_t node;
u8 * gpe_status = NULL;
u8 * feature_status = NULL;
gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
feature_status = format (0, "%s",
mp->feature_status ? "enabled" : "disabled");
+ vec_add1 (gpe_status, 0);
+ vec_add1 (feature_status, 0);
- if (VAT_JSON_ARRAY != vam->json_tree.type) {
- ASSERT(VAT_JSON_NONE == vam->json_tree.type);
- vat_json_init_array(&vam->json_tree);
- }
- node = vat_json_array_add(&vam->json_tree);
-
- vat_json_init_object(node);
- vat_json_object_add_string_copy(node, "gpe_status", gpe_status);
- vat_json_object_add_string_copy(node, "feature_status", feature_status);
+ vat_json_init_object(&node);
+ vat_json_object_add_string_copy(&node, "gpe_status", gpe_status);
+ vat_json_object_add_string_copy(&node, "feature_status", feature_status);
vec_free (gpe_status);
vec_free (feature_status);
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
}
-static u8 * format_policer_type (u8 * s, va_list * va)
+static void
+vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler (
+ vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
{
- u32 i = va_arg (*va, u32);
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
- if (i == SSE2_QOS_POLICER_TYPE_1R2C)
- s = format (s, "1r2c");
- else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
- s = format (s, "1r3c");
- else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
- s = format (s, "2r3c-2698");
- else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
- s = format (s, "2r3c-4115");
+ if (retval >= 0) {
+ fformat(vam->ofp, "%=20s\n",
+ mp->locator_set_name);
+ }
+
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
+static void
+vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json (
+ vl_api_lisp_get_map_request_itr_rlocs_reply_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_string_copy(node, "itr-rlocs", mp->locator_set_name);
+
+ vat_json_print(vam->ofp, node);
+ vat_json_free(node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void
+vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+
+ if (0 <= retval) {
+ fformat(vam->ofp, "%-20s%-16s\n",
+ mp->status ? "enabled" : "disabled",
+ mp->status ? (char *) mp->locator_set_name : "");
+ }
+
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
+static void
+vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t * mp)
+{
+ vat_main_t *vam = &vat_main;
+ vat_json_node_t node;
+ u8 * status = 0;
+
+ status = format (0, "%s", mp->status ? "enabled" : "disabled");
+ vec_add1 (status, 0);
+
+ vat_json_init_object(&node);
+ vat_json_object_add_string_copy(&node, "status", status);
+ if (mp->status) {
+ vat_json_object_add_string_copy(&node, "locator_set", mp->locator_set_name);
+ }
+
+ vec_free (status);
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static u8 * format_policer_type (u8 * s, va_list * va)
+{
+ u32 i = va_arg (*va, u32);
+
+ if (i == SSE2_QOS_POLICER_TYPE_1R2C)
+ s = format (s, "1r2c");
+ else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
+ s = format (s, "1r3c");
+ else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
+ s = format (s, "2r3c-2698");
+ else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
+ s = format (s, "2r3c-4115");
else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
s = format (s, "2r3c-mef5cf1");
else
return s;
}
+static u8 * format_policer_action_type (u8 * s, va_list * va)
+{
+ u32 i = va_arg (*va, u32);
+
+ if (i == SSE2_QOS_ACTION_DROP)
+ s = format (s, "drop");
+ else if (i == SSE2_QOS_ACTION_TRANSMIT)
+ s = format (s, "transmit");
+ else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ s = format (s, "mark-and-transmit");
+ else
+ s = format (s, "ILLEGAL");
+ return s;
+}
+
+static u8 * format_dscp (u8 * s, va_list * va)
+{
+ u32 i = va_arg (*va, u32);
+ char * t = 0;
+
+ switch (i) {
+ #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
+ foreach_vnet_dscp
+ #undef _
+ default:
+ return format (s, "ILLEGAL");
+ }
+ s = format (s, "%s", t);
+ return s;
+}
+
static void vl_api_policer_details_t_handler
(vl_api_policer_details_t * mp)
{
vat_main_t * vam = &vat_main;
+ u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
+
+ if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ conform_dscp_str = format(0, "%U", format_dscp, mp->conform_dscp);
+ else
+ conform_dscp_str = format(0, "");
+
+ if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ exceed_dscp_str = format(0, "%U", format_dscp, mp->exceed_dscp);
+ else
+ exceed_dscp_str = format(0, "");
+
+ if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ violate_dscp_str = format(0, "%U", format_dscp, mp->violate_dscp);
+ else
+ violate_dscp_str = format(0, "");
fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
"rate type %U, round type %U, %s rate, %s color-aware, "
"cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
- "cur bkt %u, ext lim %u, ext bkt %u, last update %llu\n",
+ "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
+ "conform action %U%s, exceed action %U%s, violate action %U%s\n",
mp->name,
format_policer_type, mp->type,
ntohl(mp->cir),
ntohl(mp->eir),
- ntohl(mp->cb),
- ntohl(mp->eb),
+ clib_net_to_host_u64(mp->cb),
+ clib_net_to_host_u64(mp->eb),
format_policer_rate_type, mp->rate_type,
format_policer_round_type, mp->round_type,
mp->single_rate ? "single" : "dual",
ntohl(mp->current_bucket),
ntohl(mp->extended_limit),
ntohl(mp->extended_bucket),
- clib_net_to_host_u64(mp->last_update_time));
+ clib_net_to_host_u64(mp->last_update_time),
+ format_policer_action_type, mp->conform_action_type,
+ conform_dscp_str,
+ format_policer_action_type, mp->exceed_action_type,
+ exceed_dscp_str,
+ format_policer_action_type, mp->violate_action_type,
+ violate_dscp_str);
+
+ vec_free(conform_dscp_str);
+ vec_free(exceed_dscp_str);
+ vec_free(violate_dscp_str);
}
static void vl_api_policer_details_t_handler_json
vat_main_t * vam = &vat_main;
vat_json_node_t *node;
u8 *rate_type_str, *round_type_str, *type_str;
+ u8 *conform_action_str, *exceed_action_str, *violate_action_str;
rate_type_str = format(0, "%U", format_policer_rate_type, mp->rate_type);
round_type_str = format(0, "%U", format_policer_round_type, mp->round_type);
type_str = format(0, "%U", format_policer_type, mp->type);
+ conform_action_str = format(0, "%U", format_policer_action_type,
+ mp->conform_action_type);
+ exceed_action_str = format(0, "%U", format_policer_action_type,
+ mp->exceed_action_type);
+ violate_action_str = format(0, "%U", format_policer_action_type,
+ mp->violate_action_type);
if (VAT_JSON_ARRAY != vam->json_tree.type) {
ASSERT(VAT_JSON_NONE == vam->json_tree.type);
ntohl(mp->extended_bucket));
vat_json_object_add_uint(node, "last_update_time",
ntohl(mp->last_update_time));
+ vat_json_object_add_string_copy(node, "conform_action", conform_action_str);
+ if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT) {
+ u8 *dscp_str = format(0, "%U", format_dscp, mp->conform_dscp);
+ vat_json_object_add_string_copy(node, "conform_dscp", dscp_str);
+ vec_free(dscp_str);
+ }
+ vat_json_object_add_string_copy(node, "exceed_action", exceed_action_str);
+ if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT) {
+ u8 *dscp_str = format(0, "%U", format_dscp, mp->exceed_dscp);
+ vat_json_object_add_string_copy(node, "exceed_dscp", dscp_str);
+ vec_free(dscp_str);
+ }
+ vat_json_object_add_string_copy(node, "violate_action", violate_action_str);
+ if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT) {
+ u8 *dscp_str = format(0, "%U", format_dscp, mp->violate_dscp);
+ vat_json_object_add_string_copy(node, "violate_dscp", dscp_str);
+ vec_free(dscp_str);
+ }
vec_free(rate_type_str);
vec_free(round_type_str);
vec_free(type_str);
+ vec_free(conform_action_str);
+ vec_free(exceed_action_str);
+ vec_free(violate_action_str);
+}
+
+static void vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ int i, count = ntohl(mp->count);
+
+ if (count>0)
+ fformat (vam->ofp, "classify table ids (%d) : ", count);
+ for (i = 0; i < count; i++)
+ {
+ fformat (vam->ofp, "%d", ntohl(mp->ids[i]));
+ fformat (vam->ofp, (i<count-1)?",":"\n");
+ }
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_classify_table_ids_reply_t_handler_json (vl_api_classify_table_ids_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ int i, count = ntohl(mp->count);
+
+ if (count>0) {
+ vat_json_node_t node;
+
+ vat_json_init_object(&node);
+ for (i = 0; i < count; i++)
+ {
+ vat_json_object_add_uint(&node, "table_id", ntohl(mp->ids[i]));
+ }
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+ }
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_classify_table_by_interface_reply_t_handler (vl_api_classify_table_by_interface_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ u32 table_id;
+
+ table_id = ntohl(mp->l2_table_id);
+ if (table_id != ~0)
+ fformat (vam->ofp, "l2 table id : %d\n", table_id);
+ else
+ fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
+ table_id = ntohl(mp->ip4_table_id);
+ if (table_id != ~0)
+ fformat (vam->ofp, "ip4 table id : %d\n", table_id);
+ else
+ fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
+ table_id = ntohl(mp->ip6_table_id);
+ if (table_id != ~0)
+ fformat (vam->ofp, "ip6 table id : %d\n", table_id);
+ else
+ fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_classify_table_by_interface_reply_t_handler_json (vl_api_classify_table_by_interface_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, "l2_table_id", ntohl(mp->l2_table_id));
+ vat_json_object_add_int(&node, "ip4_table_id", ntohl(mp->ip4_table_id));
+ vat_json_object_add_int(&node, "ip6_table_id", ntohl(mp->ip6_table_id));
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_policer_add_del_reply_t_handler
+(vl_api_policer_add_del_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+ if (vam->async_mode) {
+ vam->async_errors += (retval < 0);
+ } else {
+ vam->retval = retval;
+ vam->result_ready = 1;
+ if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
+ /*
+ * Note: this is just barely thread-safe, depends on
+ * the main thread spinning waiting for an answer...
+ */
+ errmsg ("policer index %d\n", ntohl(mp->policer_index));
+ }
+}
+
+static void vl_api_policer_add_del_reply_t_handler_json
+(vl_api_policer_add_del_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, "policer_index", ntohl(mp->policer_index));
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+/* Format hex dump. */
+u8 * format_hex_bytes (u8 * s, va_list * va)
+{
+ u8 * bytes = va_arg (*va, u8 *);
+ int n_bytes = va_arg (*va, int);
+ uword i;
+
+ /* Print short or long form depending on byte count. */
+ uword short_form = n_bytes <= 32;
+ uword indent = format_get_indent (s);
+
+ if (n_bytes == 0)
+ return s;
+
+ for (i = 0; i < n_bytes; i++)
+ {
+ if (! short_form && (i % 32) == 0)
+ s = format (s, "%08x: ", i);
+ s = format (s, "%02x", bytes[i]);
+ if (! short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
+ s = format (s, "\n%U", format_white_space, indent);
+ }
+
+ return s;
+}
+
+static void vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ i32 retval = ntohl(mp->retval);
+ if (retval == 0) {
+ fformat (vam->ofp, "classify table info :\n");
+ fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n", ntohl(mp->active_sessions), ntohl(mp->next_table_index), ntohl(mp->miss_next_index));
+ fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n", ntohl(mp->nbuckets), ntohl(mp->skip_n_vectors), ntohl(mp->match_n_vectors));
+ fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask, ntohl(mp->mask_length));
+ }
+ vam->retval = retval;
+ vam->result_ready = 1;
+}
+
+static void vl_api_classify_table_info_reply_t_handler_json (vl_api_classify_table_info_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t node;
+
+ i32 retval = ntohl(mp->retval);
+ if (retval == 0) {
+ vat_json_init_object(&node);
+
+ vat_json_object_add_int(&node, "sessions", ntohl(mp->active_sessions));
+ vat_json_object_add_int(&node, "nexttbl", ntohl(mp->next_table_index));
+ vat_json_object_add_int(&node, "nextnode", ntohl(mp->miss_next_index));
+ vat_json_object_add_int(&node, "nbuckets", ntohl(mp->nbuckets));
+ vat_json_object_add_int(&node, "skip", ntohl(mp->skip_n_vectors));
+ vat_json_object_add_int(&node, "match", ntohl(mp->match_n_vectors));
+ u8 * s = format (0, "%U%c",format_hex_bytes, mp->mask, ntohl(mp->mask_length), 0);
+ vat_json_object_add_string_copy(&node, "mask", s);
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+ }
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+
+ fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ", ntohl(mp->hit_next_index), ntohl(mp->advance), ntohl(mp->opaque_index));
+ fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match, ntohl(mp->match_length));
+}
+
+static void vl_api_classify_session_details_t_handler_json (vl_api_classify_session_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_int(node, "next_index", ntohl(mp->hit_next_index));
+ vat_json_object_add_int(node, "advance", ntohl(mp->advance));
+ vat_json_object_add_int(node, "opaque", ntohl(mp->opaque_index));
+ u8 * s = format (0, "%U%c",format_hex_bytes, mp->match, ntohl(mp->match_length), 0);
+ vat_json_object_add_string_copy(node, "match", s);
+}
+
+static void vl_api_pg_create_interface_reply_t_handler
+(vl_api_pg_create_interface_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+
+ vam->retval = ntohl(mp->retval);
+ vam->result_ready = 1;
+}
+
+static void vl_api_pg_create_interface_reply_t_handler_json
+(vl_api_pg_create_interface_reply_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t node;
+
+ i32 retval = ntohl(mp->retval);
+ if (retval == 0) {
+ vat_json_init_object(&node);
+
+ vat_json_object_add_int(&node, "sw_if_index", ntohl(mp->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_policer_classify_details_t_handler
+(vl_api_policer_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_policer_classify_details_t_handler_json
+(vl_api_policer_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_ip6_fib_counters_t_endian vl_noop_handler
#define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
-/*
- * Generate boilerplate reply handlers, which
+/*
+ * Generate boilerplate reply handlers, which
* dig the return value out of the xxx_reply_t API message,
* stick it into vam->retval, and set vam->result_ready
*
_(lisp_add_del_locator_set_reply) \
_(lisp_add_del_locator_reply) \
_(lisp_add_del_local_eid_reply) \
+_(lisp_add_del_remote_mapping_reply) \
+_(lisp_add_del_adjacency_reply) \
_(lisp_gpe_add_del_fwd_entry_reply) \
_(lisp_add_del_map_resolver_reply) \
_(lisp_gpe_enable_disable_reply) \
_(lisp_gpe_add_del_iface_reply) \
_(lisp_enable_disable_reply) \
_(lisp_pitr_set_locator_set_reply) \
+_(lisp_add_del_map_request_itr_rlocs_reply) \
+_(lisp_eid_table_add_del_map_reply) \
_(vxlan_gpe_add_del_tunnel_reply) \
-_(af_packet_create_reply) \
_(af_packet_delete_reply) \
-_(policer_add_del_reply) \
+_(policer_classify_set_interface_reply) \
_(netmap_create_reply) \
-_(netmap_delete_reply)
+_(netmap_delete_reply) \
+_(ipfix_enable_reply) \
+_(pg_capture_reply) \
+_(pg_enable_disable_reply)
#define _(n) \
static void vl_api_##n##_t_handler \
foreach_standard_reply_retval_handler;
#undef _
-/*
+/*
* Table of message reply handlers, must include boilerplate handlers
* we just generated
*/
_(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
_(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
_(CONTROL_PING_REPLY, control_ping_reply) \
+_(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
_(CLI_REPLY, cli_reply) \
_(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
sw_interface_add_del_address_reply) \
_(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
_(SHOW_VERSION_REPLY, show_version_reply) \
_(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
-_(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
+_(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
+_(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
_(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
_(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
_(IP4_ARP_EVENT, ip4_arp_event) \
_(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
_(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
_(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
+_(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
+_(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
_(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
_(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
_(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
_(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
_(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
+_(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
_(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
_(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
+_(LISP_LOCATOR_DETAILS, lisp_locator_details) \
_(LISP_LOCAL_EID_TABLE_DETAILS, lisp_local_eid_table_details) \
+_(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
_(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
_(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
-_(LISP_ENABLE_DISABLE_STATUS_DETAILS, \
- lisp_enable_disable_status_details) \
+_(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
+_(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
+ lisp_add_del_map_request_itr_rlocs_reply) \
+_(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
+ lisp_get_map_request_itr_rlocs_reply) \
+_(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
_(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
_(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
_(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
_(POLICER_DETAILS, policer_details) \
+_(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)
+_(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) \
+_(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
+_(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
+_(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
+_(CLASSIFY_SESSION_DETAILS, classify_session_details) \
+_(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
+_(IPFIX_DETAILS, ipfix_details) \
+_(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
+_(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
+_(PG_CAPTURE_REPLY, pg_capture_reply) \
+_(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply)
/* M: construct, but don't yet send a message */
return -99; \
} while(0);
-typedef struct {
- u8 * name;
- u32 value;
-} name_sort_t;
-
-
-#define STR_VTR_OP_CASE(op) \
+/* W2: wait for results, with timeout */
+#define W2(body) \
+do { \
+ timeout = vat_time_now (vam) + 1.0; \
+ \
+ while (vat_time_now (vam) < timeout) { \
+ if (vam->result_ready == 1) { \
+ (body); \
+ return (vam->retval); \
+ } \
+ } \
+ return -99; \
+} while(0);
+
+/* W_L: wait for results, with timeout */
+#define W_L(body) \
+do { \
+ timeout = vat_time_now (vam) + 1.0; \
+ \
+ while (vat_time_now (vam) < timeout) { \
+ if (vam->result_ready == 1) { \
+ (body); \
+ return (vam->retval); \
+ } \
+ } \
+ vam->noprint_msg = 0; \
+ return -99; \
+} while(0);
+
+typedef struct {
+ u8 * name;
+ u32 value;
+} name_sort_t;
+
+
+#define STR_VTR_OP_CASE(op) \
case L2_VTR_ ## op: \
return "" # op;
fformat (vam->ofp,
" vlan-tag-rewrite - op: %-14s [ dot1q: %d "
"tag1: %d tag2: %d ]\n",
- str_vtr_op(sub->vtr_op), sub->vtr_push_dot1q,
+ str_vtr_op(sub->vtr_op), sub->vtr_push_dot1q,
sub->vtr_tag1, sub->vtr_tag2);
}
}
return -99;
}
- hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
+ hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
({
vec_add2 (nses, ns, 1);
ns->name = (u8 *)(p->key);
if (vec_len(i->buffer) == 0)
return -1;
- if (vam->exec_mode == 0 && unformat (i, "mode")) {
+ if (vam->exec_mode == 0 && unformat (i, "mode")) {
vam->exec_mode = 1;
return 0;
}
- if (vam->exec_mode == 1 &&
+ if (vam->exec_mode == 1 &&
(unformat (i, "exit") || unformat (i, "quit"))) {
vam->exec_mode = 0;
return 0;
}
-
+
M(CLI_REQUEST, cli_request);
- /*
+ /*
* Copy cmd into shared memory.
* In order for the CLI command to work, it
* must be a vector ending in \n, not a C-string ending
fformat (vam->ofp, "%s", vam->shmem_result);
pthread_mutex_lock (&am->vlib_rp->mutex);
oldheap = svm_push_data_heap (am->vlib_rp);
-
+
free_me = (u8 *)vam->shmem_result;
vec_free (free_me);
sw_interface_subif_t * sub = NULL;
/* Toss the old name table */
- hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
+ hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
({
vec_add2 (nses, ns, 1);
ns->name = (u8 *)(p->key);
vec_free (vam->sw_if_subif_table);
/* recreate the interface name hash table */
- vam->sw_if_index_by_interface_name
+ vam->sw_if_index_by_interface_name
= hash_create_string (0, sizeof(uword));
/* Get list of ethernets */
strncpy ((char *) mp->name_filter, "lo", sizeof(mp->name_filter)-1);
S;
+
+ /* and vxlan-gpe tunnel interfaces */
+ M(SW_INTERFACE_DUMP, sw_interface_dump);
+ mp->name_filter_valid = 1;
+ strncpy ((char *) mp->name_filter, "vxlan_gpe", sizeof(mp->name_filter)-1);
+ S;
+
/* and vxlan tunnel interfaces */
M(SW_INTERFACE_DUMP, sw_interface_dump);
mp->name_filter_valid = 1;
u32 sw_if_index;
u8 sw_if_index_set = 0;
u8 admin_up = 0, link_up = 0;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "admin-up"))
u8 v6_address_set = 0;
ip4_address_t v4address;
ip6_address_t v6address;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "del-all"))
sw_if_index_set = 1;
else if (unformat (i, "sw_if_index %d", &sw_if_index))
sw_if_index_set = 1;
- else if (unformat (i, "%U/%d",
- unformat_ip4_address, &v4address,
+ else if (unformat (i, "%U/%d",
+ unformat_ip4_address, &v4address,
&address_length))
v4_address_set = 1;
- else if (unformat (i, "%U/%d",
- unformat_ip6_address, &v6address,
+ else if (unformat (i, "%U/%d",
+ unformat_ip6_address, &v6address,
&address_length))
v6_address_set = 1;
else
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))
u32 sw_if_index = 0;
u8 sw_if_index_set = 0;
u8 is_enable = 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))
u32 tx_sw_if_index;
u8 tx_sw_if_index_set = 0;
u8 enable = 1;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
- rx_sw_if_index_set = 1;
+ rx_sw_if_index_set = 1;
else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
tx_sw_if_index_set = 1;
else if (unformat (i, "rx")) {
break;
} else if (unformat (i, "enable"))
enable = 1;
- else if (unformat (i, "disable"))
+ else if (unformat (i, "disable"))
enable = 0;
else
break;
errmsg ("missing tx interface name or tx_sw_if_index\n");
return -99;
}
-
+
M(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
mp->rx_sw_if_index = ntohl(rx_sw_if_index);
u8 bvi = 0;
u32 shg = 0;
u8 enable = 1;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
- rx_sw_if_index_set = 1;
+ rx_sw_if_index_set = 1;
else if (unformat (i, "bd_id %d", &bd_id))
bd_id_set = 1;
else if (unformat (i, "%U", unformat_sw_if_index, vam,
&rx_sw_if_index))
rx_sw_if_index_set = 1;
- else if (unformat (i, "shg %d", &shg))
+ else if (unformat (i, "shg %d", &shg))
;
else if (unformat (i, "bvi"))
bvi = 1;
else if (unformat (i, "enable"))
enable = 1;
- else if (unformat (i, "disable"))
+ else if (unformat (i, "disable"))
enable = 0;
else
break;
errmsg ("missing bridge domain\n");
return -99;
}
-
+
M(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
mp->rx_sw_if_index = ntohl(rx_sw_if_index);
u8 is_add = 1;
u8 static_mac = 0;
u8 filter_mac = 0;
+ u8 bvi_mac = 0;
+ int count = 1;
+ f64 before = 0;
+ int j;
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
else if (unformat (i, "bd_id %d", &bd_id))
bd_id_set = 1;
else if (unformat (i, "sw_if_index %d", &sw_if_index))
- sw_if_index_set = 1;
+ sw_if_index_set = 1;
else if (unformat (i, "sw_if")) {
if (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;
+ if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
+ sw_if_index_set = 1;
} else
break;
} else if (unformat (i, "static"))
- static_mac = 1;
+ static_mac = 1;
else if (unformat (i, "filter")) {
- filter_mac = 1;
- static_mac = 1;
+ filter_mac = 1;
+ static_mac = 1;
+ } else if (unformat (i, "bvi")) {
+ bvi_mac = 1;
+ static_mac = 1;
} else if (unformat (i, "del"))
- is_add = 0;
+ is_add = 0;
+ else if (unformat (i, "count %d", &count))
+ ;
else
- break;
+ break;
}
if (mac_set == 0) {
return -99;
}
- M(L2FIB_ADD_DEL, l2fib_add_del);
+ if (count > 1) {
+ /* Turn on async mode */
+ vam->async_mode = 1;
+ vam->async_errors = 0;
+ before = vat_time_now(vam);
+ }
- mp->mac = mac;
- mp->bd_id = ntohl(bd_id);
- mp->is_add = is_add;
+ for (j = 0; j < count; j++) {
+ M(L2FIB_ADD_DEL, l2fib_add_del);
- if (is_add) {
- mp->sw_if_index = ntohl(sw_if_index);
- mp->static_mac = static_mac;
- mp->filter_mac = filter_mac;
+ mp->mac = mac;
+ mp->bd_id = ntohl(bd_id);
+ mp->is_add = is_add;
+
+ if (is_add) {
+ mp->sw_if_index = ntohl(sw_if_index);
+ mp->static_mac = static_mac;
+ mp->filter_mac = filter_mac;
+ mp->bvi_mac = bvi_mac;
+ }
+ increment_mac_address (&mac);
+ /* send it... */
+ S;
}
-
- S; W;
- /* NOTREACHED */
- return 0;
+
+ 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);
+
+ 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_l2_flags (vat_main_t * vam)
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "sw_if_index %d", &sw_if_index))
- sw_if_index_set = 1;
+ sw_if_index_set = 1;
else if (unformat (i, "sw_if")) {
if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
ip4_address_t v4addr;
ip6_address_t v6addr;
u8 macaddr[6];
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
u8 * tap_name;
memset (mac_address, 0, sizeof (mac_address));
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
errmsg ("tap name too long\n");
}
vec_add1 (tap_name, 0);
-
+
/* Construct the API message */
M(TAP_CONNECT, tap_connect);
u8 sw_if_index_set = 0;
memset (mac_address, 0, sizeof (mac_address));
-
+
/* 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))
errmsg ("tap name too long\n");
}
vec_add1 (tap_name, 0);
-
+
/* Construct the API message */
M(TAP_MODIFY, tap_modify);
errmsg ("missing vpp interface name");
return -99;
}
-
+
/* Construct the API message */
M(TAP_DELETE, tap_delete);
unformat_input_t * i = vam->input;
vl_api_ip_add_del_route_t *mp;
f64 timeout;
- u32 sw_if_index = 0, vrf_id = 0;
+ u32 sw_if_index = ~0, vrf_id = 0;
u8 sw_if_index_set = 0;
u8 is_ipv6 = 0;
u8 is_local = 0, is_drop = 0;
u32 random_seed = 0xdeaddabe;
u32 classify_table_index = ~0;
u8 is_classify = 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))
else if (unformat (i, "/%d", &dst_address_length)) {
address_length_set = 1;
}
-
- else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
+
+ else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
&v4_next_hop_address)) {
next_hop_set = 1;
}
- else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
+ else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
&v6_next_hop_address)) {
next_hop_set = 1;
}
errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
return -99;
}
-
+
if (!next_hop_set && !is_drop && !is_local && !is_classify) {
errmsg ("next hop / local / drop / classify not set\n");
return -99;
errmsg ("missing address length\n");
return -99;
}
-
+
/* Generate a pile of unique, random routes */
if (random_add_del) {
u32 this_random_address;
for (j = 0; j <= count; j++) {
do {
this_random_address = random_u32 (&random_seed);
- this_random_address =
+ this_random_address =
clib_host_to_net_u32 (this_random_address);
} while (hash_get (random_hash, this_random_address));
vec_add1 (random_vector, this_random_address);
for (j = 0; j < count; j++) {
/* Construct the API message */
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);
if (resolve_attempts > 0) {
mp->resolve_if_needed = 1;
}
mp->create_vrf_if_needed = create_vrf_if_needed;
-
+
mp->is_add = is_add;
mp->is_drop = is_drop;
mp->is_ipv6 = is_ipv6;
if (is_ipv6){
clib_memcpy (mp->dst_address, &v6_dst_address, sizeof (v6_dst_address));
if (next_hop_set)
- clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
+ clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
sizeof (v6_next_hop_address));
increment_v6_address (&v6_dst_address);
} else {
clib_memcpy (mp->dst_address, &v4_dst_address, sizeof (v4_dst_address));
if (next_hop_set)
- clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
+ clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
sizeof (v4_next_hop_address));
if (random_add_del)
v4_dst_address.as_u32 = random_vector[j+1];
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "vrf %d", &vrf_id))
;
- else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
+ else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
unformat_ip4_address, &hi))
range_set = 1;
else if (unformat (i, "del"))
return -99;
}
}
-
+
if (range_set == 0) {
errmsg ("address range not set\n");
return -99;
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
return -99;
}
}
-
+
M(MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
mp->rx_vrf_id = ntohl(rx_vrf_id);
errmsg ("missing encap label stack\n");
return -99;
}
-
- M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
+
+ M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
sizeof (u32) * vec_len (labels));
mp->vrf_id = ntohl(vrf_id);
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))
;
return -99;
}
}
-
+
M(MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
mp->inner_vrf_id = ntohl(inner_vrf_id);
u8 l2_only = 0;
u32 tx_sw_if_index;
int tx_sw_if_index_set = 0;
-
+
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "vrf %d", &inner_vrf_id))
;
else if (unformat (i, "adj %U/%d", unformat_ip4_address,
&intfc_address, &tmp))
intfc_address_length = tmp;
- else if (unformat (i, "%U",
+ else if (unformat (i, "%U",
unformat_sw_if_index, vam, &tx_sw_if_index))
tx_sw_if_index_set = 1;
else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
tx_sw_if_index_set = 1;
- else if (unformat (i, "dst %U", unformat_ethernet_address,
+ else if (unformat (i, "dst %U", unformat_ethernet_address,
dst_mac_address))
dst_set = 1;
else if (unformat (i, "l2-only"))
errmsg ("tx-intfc not set\n");
return -99;
}
-
+
M(MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
mp->vrf_id = ntohl(inner_vrf_id);
u8 is_add = 1;
u32 resolve_attempts = 5;
u8 resolve_if_needed = 1;
-
+
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
;
return -99;
}
}
-
+
if (!adj_address_set) {
errmsg ("adjacency address/mask not set\n");
return -99;
errmsg ("ip4 next hop address (in outer fib) not set\n");
return -99;
}
-
+
M(MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
-
+
mp->inner_vrf_id = ntohl(inner_vrf_id);
mp->outer_vrf_id = ntohl(outer_vrf_id);
mp->resolve_attempts = ntohl(resolve_attempts);
mp->l2_only = l2_only;
clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
mp->adj_address_length = adj_address_length;
- clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
+ clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
sizeof (next_hop_address));
S; W;
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
u8 v6_address_set = 0;
ip4_address_t v4address;
ip6_address_t v6address;
-
+
memset (mac_address, 0, sizeof (mac_address));
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
+ if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
mac_set = 1;
}
else if (unformat (i, "del"))
is_add = 0;
- else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
+ else 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;
is_static = 1;
else if (unformat (i, "vrf %d", &vrf_id))
;
- else if (unformat (i, "dst %U",
+ else if (unformat (i, "dst %U",
unformat_ip4_address, &v4address))
v4_address_set = 1;
- else if (unformat (i, "dst %U",
+ else if (unformat (i, "dst %U",
unformat_ip6_address, &v6address))
v6_address_set = 1;
else {
return -99;
}
if (!v4_address_set && !v6_address_set) {
- errmsg ("no addresses set\n");
+ errmsg ("no address set\n");
return -99;
}
errmsg ("missing vrf id\n");
return -99;
}
-
+
M(RESET_VRF, reset_vrf);
mp->vrf_id = ntohl(vrf_id);
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
mp->sw_if_index = ntohl(sw_if_index);
mp->sub_id = ntohl(sub_id);
-
+
#define _(a) mp->a = a;
foreach_create_subif_bit;
#undef _
-
+
mp->outer_vlan_id = ntohs (outer_vlan_id);
mp->inner_vlan_id = ntohs (inner_vlan_id);
ip4_address_t src, dst;
u8 src_set = 0;
u8 dst_set = 0;
-
+
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "vrf %d", &vrf_id))
;
return -99;
}
}
-
+
if (src_set == 0) {
errmsg ("missing src addr\n");
return -99;
errmsg ("missing vrf id\n");
return -99;
}
-
+
M(RESET_FIB, reset_fib);
mp->vrf_id = ntohl(vrf_id);
u8 v6_src_address_set = 0;
ip4_address_t v4srcaddress;
ip6_address_t v6srcaddress;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "del"))
;
else if (unformat (i, "insert-cid %d", &insert_cid))
;
- else if (unformat (i, "svr %U",
+ else if (unformat (i, "svr %U",
unformat_ip4_address, &v4address))
v4_address_set = 1;
- else if (unformat (i, "svr %U",
+ else if (unformat (i, "svr %U",
unformat_ip6_address, &v6address))
v6_address_set = 1;
- else if (unformat (i, "src %U",
+ else if (unformat (i, "src %U",
unformat_ip4_address, &v4srcaddress))
v4_src_address_set = 1;
- else if (unformat (i, "src %U",
+ else if (unformat (i, "src %U",
unformat_ip6_address, &v6srcaddress))
v6_src_address_set = 1;
else
u8 v6_src_address_set = 0;
ip4_address_t v4srcaddress;
ip6_address_t v6srcaddress;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "del"))
;
else if (unformat (i, "insert-cid %d", &insert_cid))
;
- else if (unformat (i, "svr %U",
+ else if (unformat (i, "svr %U",
unformat_ip4_address, &v4address))
v4_address_set = 1;
- else if (unformat (i, "svr %U",
+ else if (unformat (i, "svr %U",
unformat_ip6_address, &v6address))
v6_address_set = 1;
- else if (unformat (i, "src %U",
+ else if (unformat (i, "src %U",
unformat_ip4_address, &v4srcaddress))
v4_src_address_set = 1;
- else if (unformat (i, "src %U",
+ else if (unformat (i, "src %U",
unformat_ip6_address, &v6srcaddress))
v6_src_address_set = 1;
else
errmsg ("missing oui\n");
return -99;
}
-
+
M(DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
mp->tbl_id = ntohl(tbl_id);
mp->fib_id = ntohl(fib_id);
mp->is_add = is_add;
mp->want_dhcp_event = disable_event ? 0 : 1;
mp->pid = getpid();
-
+
/* send it... */
S;
errmsg ("missing vrf id\n");
return -99;
}
-
+
M(SET_IP_FLOW_HASH, set_ip_flow_hash);
mp->src = src;
mp->dst = dst;
errmsg ("missing interface name or sw_if_index\n");
return -99;
}
-
+
M(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
mp->sw_if_index = ntohl(sw_if_index);
u32 address_length = 0;
u8 v6_address_set = 0;
ip6_address_t v6address;
-
+
/* 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, "%U/%d",
- unformat_ip6_address, &v6address,
+ else if (unformat (i, "%U/%d",
+ unformat_ip6_address, &v6address,
&address_length))
v6_address_set = 1;
else
u8 is_no = 0;
u32 val_lifetime = 0;
u32 pref_lifetime = 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, "%U/%d",
- unformat_ip6_address, &v6address,
+ else if (unformat (i, "%U/%d",
+ unformat_ip6_address, &v6address,
&address_length))
v6_address_set = 1;
else if (unformat (i, "val_life %d", &val_lifetime))
else {
clib_warning ("parse error '%U'", format_unformat_error, i);
return -99;
- }
+ }
}
if (sw_if_index_set == 0) {
f64 timeout;
u32 sw_if_index;
u8 sw_if_index_set = 0;
- u8 surpress = 0;
+ u8 suppress = 0;
u8 managed = 0;
u8 other = 0;
u8 ll_option = 0;
u32 initial_count = 0;
u32 initial_interval = 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))
;
else if (unformat (i, "interval %d", &initial_interval))
;
- else if (unformat (i, "surpress"))
- surpress = 1;
+ else if (unformat (i, "suppress") || unformat (i, "surpress"))
+ suppress = 1;
else if (unformat (i, "managed"))
managed = 1;
else if (unformat (i, "other"))
else {
clib_warning ("parse error '%U'", format_unformat_error, i);
return -99;
- }
+ }
}
if (sw_if_index_set == 0) {
mp->lifetime = ntohl(lifetime);
mp->initial_count = ntohl(initial_count);
mp->initial_interval = ntohl(initial_interval);
- mp->surpress = surpress;
+ mp->suppress = suppress;
mp->managed = managed;
mp->other = other;
mp->ll_option = ll_option;
errmsg ("missing limit value\n");
return -99;
}
-
+
M(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
mp->arp_neighbor_limit = ntohl(arp_nbr_limit);
u32 tx_sw_if_index;
u8 tx_sw_if_index_set = 0;
u8 is_add = 1;
-
+
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
- rx_sw_if_index_set = 1;
+ rx_sw_if_index_set = 1;
else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
tx_sw_if_index_set = 1;
else if (unformat (i, "rx")) {
errmsg ("missing tx interface name or tx_sw_if_index\n");
return -99;
}
-
+
M(L2_PATCH_ADD_DEL, l2_patch_add_del);
mp->rx_sw_if_index = ntohl(rx_sw_if_index);
u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
int has_pow_option = 0;
int has_ppc_option = 0;
-
+
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
- "trace-tsp %d node-id 0x%x app-data 0x%x",
+ "trace-tsp %d node-id 0x%x app-data 0x%x",
&id, &trace_type, &trace_option_elts, &trace_tsp,
&node_id, &app_data))
;
mp->pow_enable = has_pow_option;
mp->trace_tsp = trace_tsp;
mp->node_id = htonl(node_id);
-
+
S; W;
-
+
return(0);
-
+
}
static int api_trace_profile_apply (vat_main_t *vam)
{
int is_none = 0;
u32 vrf_id = 0;
u32 id = 0;
-
+
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "%U/%d",
mp->enable = 0;
else
mp->enable = 1;
-
+
S; W;
return 0;
{
vl_api_trace_profile_del_t *mp;
f64 timeout;
-
+
M(TRACE_PROFILE_DEL, trace_profile_del);
S; W;
return 0;
;
else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
src_address_set = 1;
- else if (unformat (i, "dst %U/%d",
+ else if (unformat (i, "dst %U/%d",
unformat_ip6_address, &dst_address,
&dst_mask_width))
dst_address_set = 1;
goto pl_index_range_error;
flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3*(pl_index - 1));
}
- else
+ else
break;
}
return -99;
}
- M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
- vec_len(segments) * sizeof (ip6_address_t)
+ M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
+ vec_len(segments) * sizeof (ip6_address_t)
+ vec_len(tags) * sizeof (ip6_address_t));
clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
mp->n_segments = vec_len (segments);
mp->n_tags = vec_len (tags);
mp->is_add = is_del == 0;
- clib_memcpy (mp->segs_and_tags, segments,
+ clib_memcpy (mp->segs_and_tags, segments,
vec_len(segments)* sizeof (ip6_address_t));
clib_memcpy (mp->segs_and_tags + vec_len(segments)*sizeof (ip6_address_t),
tags, vec_len(tags)* sizeof (ip6_address_t));
vec_free (segments);
vec_free (tags);
-
+
S; W;
/* NOTREACHED */
}
u8 * name = 0;
u8 * tunnel_name = 0;
u8 ** tunnel_names = 0;
-
+
int name_set = 0 ;
int tunnel_set = 0;
int j = 0;
if (tunnel_name)
{
vec_add1 (tunnel_names, tunnel_name);
- /* For serializer:
+ /* For serializer:
- length = #bytes to store in serial vector
- +1 = byte to store that length
*/
- tunnel_names_length += (vec_len (tunnel_name) + 1);
+ tunnel_names_length += (vec_len (tunnel_name) + 1);
tunnel_set = 1;
tunnel_name = 0;
}
}
- else
+ else
break;
}
M2(SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
-
+
mp->is_add = !is_del;
vec_free (tunnel_names);
vec_free (tunnel_name);
-
+
S; W;
/* NOTREACHED */
}
multicast_address_set = 1;
else if (unformat (input, "sr-policy %s", &policy_name))
;
- else
+ else
break;
}
vec_free (policy_name);
-
+
S; W;
/* NOTREACHED */
}
u8 * mask = 0;
u8 found_something = 0;
ip4_header_t * ip;
-
+
#define _(a) u8 a=0;
foreach_ip4_proto_field;
#undef _
u8 version = 0;
u8 hdr_length = 0;
-
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "version"))
+ if (unformat (input, "version"))
version = 1;
else if (unformat (input, "hdr_length"))
hdr_length = 1;
dst_address = 1;
else if (unformat (input, "proto"))
protocol = 1;
-
+
#define _(a) else if (unformat (input, #a)) a=1;
foreach_ip4_proto_field
#undef _
else
break;
}
-
+
#define _(a) found_something += a;
foreach_ip4_proto_field;
#undef _
-
+
if (found_something == 0)
return 0;
-
+
vec_validate (mask, sizeof (*ip) - 1);
-
+
ip = (ip4_header_t *) mask;
-
+
#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip4_proto_field;
#undef _
-
+
ip->ip_version_and_header_length = 0;
-
+
if (version)
ip->ip_version_and_header_length |= 0xF0;
-
+
if (hdr_length)
ip->ip_version_and_header_length |= 0x0F;
-
+
*maskp = mask;
return 1;
}
u8 found_something = 0;
ip6_header_t * ip;
u32 ip_version_traffic_class_and_flow_label;
-
+
#define _(a) u8 a=0;
foreach_ip6_proto_field;
#undef _
u8 version = 0;
u8 traffic_class = 0;
u8 flow_label = 0;
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "version"))
+ if (unformat (input, "version"))
version = 1;
else if (unformat (input, "traffic-class"))
traffic_class = 1;
dst_address = 1;
else if (unformat (input, "proto"))
protocol = 1;
-
+
#define _(a) else if (unformat (input, #a)) a=1;
foreach_ip6_proto_field
#undef _
else
break;
}
-
+
#define _(a) found_something += a;
foreach_ip6_proto_field;
#undef _
-
+
if (found_something == 0)
return 0;
-
+
vec_validate (mask, sizeof (*ip) - 1);
-
+
ip = (ip6_header_t *) mask;
-
+
#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip6_proto_field;
#undef _
-
+
ip_version_traffic_class_and_flow_label = 0;
-
+
if (version)
ip_version_traffic_class_and_flow_label |= 0xF0000000;
if (flow_label)
ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
- ip->ip_version_traffic_class_and_flow_label =
+ ip->ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
-
+
*maskp = mask;
return 1;
}
if (src)
memset (mask + 6, 0xff, 6);
-
+
if (tag2 || dot1ad)
{
/* inner vlan tag */
mask[14] |= 0xe0;
if (proto)
mask[12] = mask [13] = 0xff;
-
+
*maskp = mask;
return 1;
}
u8 * l2 = 0;
u8 * l3 = 0;
int i;
-
+
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
if (unformat (input, "hex %U", unformat_hex_string, &mask))
;
u32 * miss_next_indexp = va_arg (*args, u32 *);
u32 next_index = 0;
u32 tmp;
-
+
#define _(n,N) \
if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
foreach_l2_next;
#undef _
-
+
if (unformat (input, "%d", &tmp))
- {
- next_index = tmp;
- goto out;
+ {
+ next_index = tmp;
+ goto out;
}
-
+
return 0;
out:
u32 * miss_next_indexp = va_arg (*args, u32 *);
u32 next_index = 0;
u32 tmp;
-
+
#define _(n,N) \
if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
foreach_ip_next;
#undef _
-
+
if (unformat (input, "%d", &tmp))
- {
- next_index = tmp;
- goto out;
+ {
+ next_index = tmp;
+ goto out;
}
-
+
return 0;
out:
return 1;
}
+uword unformat_policer_precolor (unformat_input_t * input, va_list * args)
+{
+ u32 * r = va_arg (*args, u32 *);
+
+ if (unformat (input, "conform-color"))
+ *r = POLICE_CONFORM;
+ else if (unformat (input, "exceed-color"))
+ *r = POLICE_EXCEED;
+ else
+ return 0;
+
+ return 1;
+}
+
static int api_classify_add_del_table (vat_main_t * vam)
{
unformat_input_t * i = vam->input;
;
else if (unformat (i, "table %d", &table_index))
;
- else if (unformat (i, "mask %U", unformat_classify_mask,
+ else if (unformat (i, "mask %U", unformat_classify_mask,
&mask, &skip, &match))
;
else if (unformat (i, "next-table %d", &next_table_index))
else
break;
}
-
+
if (is_add && mask == 0) {
errmsg ("Mask required\n");
return -99;
errmsg ("match count required\n");
return -99;
}
-
+
if (!is_add && table_index == ~0) {
errmsg ("table index required for delete\n");
return -99;
int checksum = 0;
u32 checksum_val;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "version %d", &version_val))
+ if (unformat (input, "version %d", &version_val))
version = 1;
else if (unformat (input, "hdr_length %d", &hdr_length_val))
hdr_length = 1;
else
break;
}
-
+
if (version + hdr_length + src + dst + proto + tos + length + fragment_id
+ ttl + checksum == 0)
return 0;
- /*
+ /*
* Aligned because we use the real comparison functions
*/
vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
-
+
ip = (ip4_header_t *) match;
-
+
/* These are realistically matched in practice */
if (src)
ip->src_address.as_u32 = src_val.as_u32;
if (dst)
ip->dst_address.as_u32 = dst_val.as_u32;
-
+
if (proto)
ip->protocol = proto_val;
-
+
/* These are not, but they're included for completeness */
if (version)
if (hdr_length)
ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
-
+
if (tos)
ip->tos = tos_val;
-
+
if (length)
ip->length = length_val;
-
+
if (ttl)
ip->ttl = ttl_val;
int hop_limit_val;
u32 ip_version_traffic_class_and_flow_label;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "version %d", &version_val))
+ if (unformat (input, "version %d", &version_val))
version = 1;
else if (unformat (input, "traffic_class %d", &traffic_class_val))
traffic_class = 1;
else
break;
}
-
+
if (version + traffic_class + flow_label + src + dst + proto +
payload_length + hop_limit == 0)
return 0;
- /*
+ /*
* Aligned because we use the real comparison functions
*/
vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
-
+
ip = (ip6_header_t *) match;
-
+
if (src)
clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
if (dst)
clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
-
+
if (proto)
ip->protocol = proto_val;
-
+
ip_version_traffic_class_and_flow_label = 0;
if (version)
if (flow_label)
ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
-
- ip->ip_version_traffic_class_and_flow_label =
+
+ ip->ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
if (payload_length)
ip->payload_length = clib_host_to_net_u16 (payload_length_val);
-
+
if (hop_limit)
ip->hop_limit = hop_limit_val;
src = 1;
else if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
dst = 1;
- else if (unformat (input, "proto %U",
+ else if (unformat (input, "proto %U",
unformat_ethernet_type_host_byte_order, &proto_val))
proto = 1;
else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
if (src)
clib_memcpy (match + 6, src_val, 6);
-
+
if (tag2)
{
/* inner vlan tag */
match[13] = proto_val & 0xff;
match[12] = proto_val >> 8;
}
-
+
*matchp = match;
return 1;
}
u8 ** matchp = va_arg (*args, u8 **);
u32 skip_n_vectors = va_arg (*args, u32);
u32 match_n_vectors = va_arg (*args, u32);
-
+
u8 * match = 0;
u8 * l2 = 0;
u8 * l3 = 0;
}
/* Make sure the vector is big enough even if key is all 0's */
- vec_validate_aligned
+ vec_validate_aligned
(match, ((match_n_vectors + skip_n_vectors) * sizeof(u32x4)) - 1,
sizeof(u32x4));
-
+
/* Set size, include skipped vectors*/
_vec_len (match) = (match_n_vectors+skip_n_vectors) * sizeof(u32x4);
u32 skip_n_vectors = 0;
u32 match_n_vectors = 0;
- /*
+ /*
* Warning: you have to supply skip_n and match_n
* because the API client cant simply look at the classify
* table object.
else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
&hit_next_index))
;
+ else if (unformat (i, "policer-hit-next %d", &hit_next_index))
+ ;
+ else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
+ ;
else if (unformat (i, "opaque-index %d", &opaque_index))
;
else if (unformat (i, "skip_n %d", &skip_n_vectors))
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
return 0;
}
-static int api_get_node_index (vat_main_t * vam)
+static int api_ipfix_enable (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_ipfix_enable_t *mp;
+ ip4_address_t collector_address;
+ u8 collector_address_set = 0;
+ u32 collector_port = ~0;
+ ip4_address_t src_address;
+ u8 src_address_set = 0;
+ u32 vrf_id = ~0;
+ u32 path_mtu = ~0;
+ u32 template_interval = ~0;
+ f64 timeout;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "collector_address %U", unformat_ip4_address,
+ &collector_address))
+ collector_address_set = 1;
+ else if (unformat (i, "collector_port %d", &collector_port))
+ ;
+ else if (unformat (i, "src_address %U", unformat_ip4_address,
+ &src_address))
+ src_address_set = 1;
+ else if (unformat (i, "vrf_id %d", &vrf_id))
+ ;
+ else if (unformat (i, "path_mtu %d", &path_mtu))
+ ;
+ else if (unformat (i, "template_interval %d", &template_interval))
+ ;
+ else
+ break;
+ }
+
+ if (collector_address_set == 0) {
+ errmsg ("collector_address required\n");
+ return -99;
+ }
+
+ if (src_address_set == 0) {
+ errmsg ("src_address required\n");
+ return -99;
+ }
+
+ M (IPFIX_ENABLE, ipfix_enable);
+
+ memcpy(mp->collector_address, collector_address.data,
+ sizeof(collector_address.data));
+ mp->collector_port = htons((u16)collector_port);
+ memcpy(mp->src_address, src_address.data,
+ sizeof(src_address.data));
+ mp->vrf_id = htonl(vrf_id);
+ mp->path_mtu = htonl(path_mtu);
+ mp->template_interval = htonl(template_interval);
+
+ S; W;
+ /* NOTREACHED */
+}
+
+static int api_get_node_index (vat_main_t * vam)
{
unformat_input_t * i = vam->input;
vl_api_get_node_index_t * mp;
f64 timeout;
u8 * name = 0;
-
+
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "node %s", &name))
;
M(GET_NODE_INDEX, get_node_index);
clib_memcpy (mp->node_name, name, vec_len(name));
vec_free(name);
-
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static int api_get_next_index (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_get_next_index_t * mp;
+ f64 timeout;
+ u8 * node_name = 0, * next_node_name = 0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "node-name %s", &node_name))
+ ;
+ else if (unformat (i, "next-node-name %s", &next_node_name))
+ break;
+ }
+
+ if (node_name == 0) {
+ errmsg ("node name required\n");
+ return -99;
+ }
+ if (vec_len (node_name) >= ARRAY_LEN(mp->node_name)) {
+ errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
+ return -99;
+ }
+
+ if (next_node_name == 0) {
+ errmsg ("next node name required\n");
+ return -99;
+ }
+ if (vec_len (next_node_name) >= ARRAY_LEN(mp->next_name)) {
+ errmsg ("next node name too long, max %d\n", ARRAY_LEN(mp->next_name));
+ return -99;
+ }
+
+ M(GET_NEXT_INDEX, get_next_index);
+ clib_memcpy (mp->node_name, node_name, vec_len(node_name));
+ clib_memcpy (mp->next_name, next_node_name, vec_len(next_node_name));
+ vec_free(node_name);
+ vec_free(next_node_name);
+
S; W;
/* NOTREACHED */
return 0;
errmsg ("next name too long, max %d\n", ARRAY_LEN(mp->next_name));
return -99;
}
-
+
M(ADD_NODE_NEXT, add_node_next);
clib_memcpy (mp->node_name, name, vec_len(name));
clib_memcpy (mp->next_name, next, vec_len(next));
vec_free(name);
vec_free(next);
-
+
S; W;
/* NOTREACHED */
return 0;
f64 timeout;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "client_address %U", unformat_ip6_address,
+ if (unformat (i, "client_address %U", unformat_ip6_address,
&client_address))
client_address_set = 1;
- else if (unformat (i, "our_address %U", unformat_ip6_address,
+ else if (unformat (i, "our_address %U", unformat_ip6_address,
&our_address))
our_address_set = 1;
else if (unformat (i, "local_session_id %d", &local_session_id))
M(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
- clib_memcpy (mp->client_address, client_address.as_u8,
+ clib_memcpy (mp->client_address, client_address.as_u8,
sizeof (mp->client_address));
- clib_memcpy (mp->our_address, our_address.as_u8,
+ clib_memcpy (mp->our_address, our_address.as_u8,
sizeof (mp->our_address));
-
+
mp->local_session_id = ntohl (local_session_id);
mp->remote_session_id = ntohl (remote_session_id);
mp->local_cookie = clib_host_to_net_u64 (local_cookie);
errmsg ("missing interface name or sw_if_index\n");
return -99;
}
-
+
M(L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
mp->sw_if_index = ntohl(sw_if_index);
errmsg ("l2tp session lookup key unset\n");
return -99;
}
-
+
M(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
mp->key = key;
W;
}
-static uword unformat_vxlan_decap_next
+static uword unformat_vxlan_decap_next
(unformat_input_t * input, va_list * args)
{
u32 * result = va_arg (*args, u32 *);
u32 tmp;
-
+
if (unformat (input, "drop"))
*result = VXLAN_INPUT_NEXT_DROP;
else if (unformat (input, "ip4"))
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
if (unformat (line_input, "del"))
is_add = 0;
- else if (unformat (line_input, "src %U",
+ else if (unformat (line_input, "src %U",
unformat_ip4_address, &src4))
{
ipv4_set = 1;
ipv4_set = 1;
dst_set = 1;
}
- else if (unformat (line_input, "src %U",
+ else if (unformat (line_input, "src %U",
unformat_ip6_address, &src6))
{
ipv6_set = 1;
}
else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
;
- else if (unformat (line_input, "decap-next %U",
+ else if (unformat (line_input, "decap-next %U",
unformat_vxlan_decap_next, &decap_next_index))
;
else if (unformat (line_input, "vni %d", &vni))
if (ipv6_set) {
clib_memcpy(&mp->src_address, &src6, sizeof(src6));
clib_memcpy(&mp->dst_address, &dst6, sizeof(dst6));
- } else {
+ } else {
clib_memcpy(&mp->src_address, &src4, sizeof(src4));
clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
}
fformat(vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
ntohl(mp->sw_if_index),
format_ip46_address, &(mp->src_address[0]),
+ IP46_TYPE_ANY,
format_ip46_address, &(mp->dst_address[0]),
+ IP46_TYPE_ANY,
ntohl(mp->encap_vrf_id),
ntohl(mp->decap_next_index),
ntohl(mp->vni));
clib_memcpy(&mp->src_address, &src4, sizeof(src4));
clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
- mp->outer_table_id = ntohl(outer_fib_id);
+ mp->outer_fib_id = ntohl(outer_fib_id);
mp->is_add = is_add;
S; W;
ntohl(mp->sw_if_index),
format_ip4_address, &mp->src_address,
format_ip4_address, &mp->dst_address,
- ntohl(mp->outer_table_id));
+ ntohl(mp->outer_fib_id));
}
static void vl_api_gre_tunnel_details_t_handler_json
vat_json_object_add_ip4(node, "src_address", ip4);
clib_memcpy(&ip4, &mp->dst_address, sizeof(ip4));
vat_json_object_add_ip4(node, "dst_address", ip4);
- vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_table_id));
+ vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_fib_id));
}
static int api_gre_tunnel_dump (vat_main_t * vam)
return -99;
}
}
-
+
if (sw_if_index_set == 0) {
errmsg ("missing sw_if_index\n");
return -99;
#define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
foreach_vtr_op
#undef _
-
+
else if (unformat (i, "push_dot1q %d", &push_dot1q))
;
else if (unformat (i, "tag1 %d", &tag1))
return -99;
}
}
-
+
if ((sw_if_index_set == 0)||(vtr_op_set == 0)) {
errmsg ("missing vtr operation or sw_if_index\n");
return -99;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
if (unformat (line_input, "del"))
is_add = 0;
- else if (unformat (line_input, "local %U",
+ else if (unformat (line_input, "local %U",
unformat_ip4_address, &local4))
{
local_set = 1;
}
M(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
-
+
if (ipv6_set) {
clib_memcpy(&mp->local, &local6, sizeof(local6));
return 0;
}
+static void vl_api_vxlan_gpe_tunnel_details_t_handler
+(vl_api_vxlan_gpe_tunnel_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+
+ fformat(vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
+ ntohl(mp->sw_if_index),
+ format_ip46_address, &(mp->local[0]),
+ format_ip46_address, &(mp->remote[0]),
+ ntohl(mp->vni),
+ ntohl(mp->protocol),
+ ntohl(mp->encap_vrf_id),
+ ntohl(mp->decap_vrf_id));
+}
+
+static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
+(vl_api_vxlan_gpe_tunnel_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t *node = NULL;
+ struct in_addr ip4;
+ struct in6_addr ip6;
+
+ 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));
+ if (mp->is_ipv6) {
+ clib_memcpy(&ip6, &(mp->local[0]), sizeof(ip6));
+ vat_json_object_add_ip6(node, "local", ip6);
+ clib_memcpy(&ip6, &(mp->remote[0]), sizeof(ip6));
+ vat_json_object_add_ip6(node, "remote", ip6);
+ } else {
+ clib_memcpy(&ip4, &(mp->local[0]), sizeof(ip4));
+ vat_json_object_add_ip4(node, "local", ip4);
+ clib_memcpy(&ip4, &(mp->remote[0]), sizeof(ip4));
+ vat_json_object_add_ip4(node, "remote", ip4);
+ }
+ vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
+ vat_json_object_add_uint(node, "protocol", ntohl(mp->protocol));
+ vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
+ vat_json_object_add_uint(node, "decap_vrf_id", ntohl(mp->decap_vrf_id));
+ vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
+}
+
+static int api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_vxlan_gpe_tunnel_dump_t *mp;
+ f64 timeout;
+ u32 sw_if_index;
+ u8 sw_if_index_set = 0;
+
+ /* Parse args required to build the message */
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "sw_if_index %d", &sw_if_index))
+ sw_if_index_set = 1;
+ else
+ break;
+ }
+
+ if (sw_if_index_set == 0) {
+ sw_if_index = ~0;
+ }
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
+ "sw_if_index", "local", "remote", "vni",
+ "protocol","encap_vrf_id", "decap_vrf_id");
+ }
+
+ /* Get list of vxlan-tunnel interfaces */
+ M(VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
+
+ mp->sw_if_index = htonl(sw_if_index);
+
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ W;
+}
+
u8 * format_l2_fib_mac_address (u8 * s, va_list * args)
{
u8 * a = va_arg (*args, u8 *);
u32 new_show_dev_instance = ~0;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
- if (unformat (line_input, "%U", unformat_sw_if_index, vam,
+ if (unformat (line_input, "%U", unformat_sw_if_index, vam,
&sw_if_index))
;
else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
;
- else if (unformat (line_input, "new_show_dev_instance %d",
+ else if (unformat (line_input, "new_show_dev_instance %d",
&new_show_dev_instance))
;
else
u32 enable_disable = 1;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
- if (unformat (line_input, "address %U",
+ if (unformat (line_input, "address %U",
unformat_ip4_address, &address))
address_set = 1;
else if (unformat (line_input, "del"))
else
break;
}
-
+
if (address_set == 0) {
errmsg ("missing addresses\n");
return -99;
}
-
+
M(WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
mp->enable_disable = enable_disable;
mp->pid = getpid();
mp->address = address.as_u32;
- S; W;
+ S; W;
}
static int api_input_acl_set_interface (vat_main_t * vam)
vl_api_ipsec_sad_add_del_entry_t *mp;
f64 timeout;
u32 sad_id, spi;
- u8 * ck, * ik;
+ u8 * ck = 0, * ik = 0;
u8 is_add = 1;
u8 protocol = IPSEC_PROTOCOL_AH;
vl_api_ipsec_sa_set_key_t *mp;
f64 timeout;
u32 sa_id;
- u8 * ck, * ik;
+ u8 * ck = 0, * ik = 0;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "sa_id %d", &sa_id))
unformat_input_t * i = vam->input;
u8 * name;
u8 name_set = 0;
-
+
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
if (unformat (i, "client %s", &name))
name_set = 1;
- else
+ else
break;
}
else
break;
}
-
+
if (sw_if_index == ~0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
else
break;
}
-
+
if (sw_if_index == ~0) {
errmsg ("missing interface name or sw_if_index\n");
return -99;
W;
}
+/** Used for transferring locators via VPP API */
+typedef CLIB_PACKED(struct
+{
+ u32 sw_if_index; /**< locator sw_if_index */
+ u8 priority; /**< locator priority */
+ u8 weight; /**< locator weight */
+}) ls_locator_t;
+
static int
api_lisp_add_del_locator_set(vat_main_t * vam)
{
u8 is_add = 1;
u8 *locator_set_name = NULL;
u8 locator_set_name_set = 0;
+ ls_locator_t locator, * locators = 0;
+ u32 sw_if_index, priority, weight;
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
is_add = 0;
} else if (unformat(input, "locator-set %s", &locator_set_name)) {
locator_set_name_set = 1;
+ } else if (unformat(input, "sw_if_index %u p %u w %u",
+ &sw_if_index, &priority, &weight)) {
+ locator.sw_if_index = htonl(sw_if_index);
+ locator.priority = priority;
+ locator.weight = weight;
+ vec_add1(locators, locator);
+ } else if (unformat(input, "iface %U p %u w %u", unformat_sw_if_index,
+ vam, &sw_if_index, &priority, &weight)) {
+ locator.sw_if_index = htonl(sw_if_index);
+ locator.priority = priority;
+ locator.weight = weight;
+ vec_add1(locators, locator);
} else
break;
}
if (locator_set_name_set == 0) {
errmsg ("missing locator-set name");
+ vec_free(locators);
return -99;
}
if (vec_len(locator_set_name) > 64) {
errmsg ("locator-set name too long\n");
vec_free(locator_set_name);
+ vec_free(locators);
return -99;
}
vec_add1(locator_set_name, 0);
vec_len(locator_set_name));
vec_free(locator_set_name);
+ mp->locator_num = vec_len (locators);
+ clib_memcpy (mp->locators, locators,
+ (sizeof (ls_locator_t) * vec_len (locators)));
+ vec_free (locators);
+
/* send it... */
S;
u32 sw_if_index = ~0;
u8 sw_if_index_set = 0;
u8 sw_if_index_if_name_set = 0;
- u8 priority = ~0;
+ u32 priority = ~0;
u8 priority_set = 0;
- u8 weight = ~0;
+ u32 weight = ~0;
u8 weight_set = 0;
u8 is_add = 1;
u8 *locator_set_name = NULL;
u8 is_add = 1;
u8 eidv4_set = 0;
u8 eidv6_set = 0;
+ u8 eid_type = (u8)~0;
ip4_address_t eidv4;
ip6_address_t eidv6;
- u8 tmp_eid_lenght = ~0;
+ u8 mac[6] = {0};
+ u32 tmp_eid_lenght = ~0;
u8 eid_lenght = ~0;
u8 *locator_set_name = NULL;
u8 locator_set_name_set = 0;
+ u32 vni = 0;
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
if (unformat(input, "del")) {
is_add = 0;
+ } else if (unformat(input, "vni %d", &vni)) {
+ ;
} else if (unformat(input, "eid %U/%d", unformat_ip4_address,
&eidv4, &tmp_eid_lenght)) {
eid_lenght = tmp_eid_lenght;
eidv4_set = 1;
+ eid_type = 0; /* ipv4 type */
} else if (unformat(input, "eid %U/%d", unformat_ip6_address,
&eidv6, &tmp_eid_lenght)) {
eid_lenght = tmp_eid_lenght;
eidv6_set = 1;
+ eid_type = 1; /* ipv6 type */
+ } else if (unformat(input, "eid %U", unformat_ethernet_address, mac)) {
+ eid_type = 2; /* mac type */
} else if (unformat(input, "locator-set %s", &locator_set_name)) {
locator_set_name_set = 1;
} else
return -99;
}
+ if ((u8)~0 == eid_type) {
+ errmsg ("EID address not set!");
+ vec_free(locator_set_name);
+ return -99;
+ }
+
if (vec_len(locator_set_name) > 64) {
errmsg ("locator-set name too long\n");
vec_free(locator_set_name);
return -99;
}
- if (!eidv4_set && !eidv6_set) {
- errmsg ("eid addresses not set\n");
- vec_free(locator_set_name);
- return -99;
- }
-
if (eidv4_set && eid_lenght > 32) {
errmsg ("eid prefix to big\n");
vec_free(locator_set_name);
M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
mp->is_add = is_add;
- if (eidv6_set) {
- mp->is_ipv6 = 1;
- clib_memcpy(mp->ip_address, &eidv6, sizeof(eidv6));
- } else {
- mp->is_ipv6 = 0;
- clib_memcpy(mp->ip_address, &eidv4, sizeof(eidv4));
+ switch (eid_type) {
+ case 0: /* ipv4 */
+ clib_memcpy (mp->eid, &eidv4, sizeof(eidv4));
+ break;
+ case 1: /* ipv6 */
+ clib_memcpy (mp->eid, &eidv6, sizeof(eidv6));
+ break;
+ case 2: /* mac */
+ clib_memcpy (mp->eid, mac, 6);
+ break;
}
+ mp->eid_type = eid_type;
mp->prefix_len = eid_lenght;
+ mp->vni = clib_host_to_net_u32(vni);
clib_memcpy(mp->locator_set_name, locator_set_name,
vec_len(locator_set_name));
vec_free(locator_set_name);
u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0;
ip4_address_t eidv4, slocv4, dlocv4;
ip6_address_t eidv6, slocv6, dlocv6;
- u8 tmp_eid_lenght = ~0;
+ u32 tmp_eid_lenght = ~0;
u8 eid_lenght = ~0;
/* Parse args required to build the message */
typedef CLIB_PACKED(struct
{
u8 is_ip4; /**< is locator an IPv4 address? */
+ u8 priority; /**< locator priority */
+ u8 weight; /**< locator weight */
u8 addr[16]; /**< IPv4/IPv6 address */
}) rloc_t;
return 0;
}
+static int
+api_show_lisp_pitr (vat_main_t * vam)
+{
+ vl_api_show_lisp_pitr_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s\n",
+ "lisp status:");
+ }
+
+ M(SHOW_LISP_PITR, show_lisp_pitr);
+ /* send it... */
+ S;
+
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
/**
- * Add/del remote mapping from LISP control plane and updates
- * forwarding entries in data-plane accordingly.
+ * Add/delete mapping between vni and vrf
+ */
+static int
+api_lisp_eid_table_add_del_map (vat_main_t * vam)
+{
+ f64 timeout = ~0;
+ unformat_input_t * input = vam->input;
+ vl_api_lisp_eid_table_add_del_map_t *mp;
+ u8 is_add = 1, vni_set = 0, vrf_set = 0;
+ u32 vni, vrf;
+
+ /* Parse args required to build the message */
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "del"))
+ is_add = 0;
+ else if (unformat(input, "vrf %d", &vrf))
+ vrf_set = 1;
+ else if (unformat(input, "vni %d", &vni))
+ vni_set = 1;
+ else
+ break;
+ }
+
+ if (!vni_set || !vrf_set)
+ {
+ errmsg ("missing arguments!");
+ return -99;
+ }
+
+ M(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
+
+ mp->is_add = is_add;
+ mp->vni = htonl (vni);
+ mp->vrf = htonl (vrf);
+
+ /* send */
+ S;
+
+ /* wait for reply */
+ W;
+
+ /* notreached*/
+ return 0;
+}
+
+/**
+ * Add/del remote mapping to/from LISP control plane
*
* @param vam vpp API test context
* @return return code
vl_api_lisp_add_del_remote_mapping_t *mp;
f64 timeout = ~0;
u32 vni = 0;
- u8 seid_set = 0, deid_set = 0;
- ip4_address_t seid4, deid4, rloc4;
- ip6_address_t seid6, deid6, rloc6;
- u32 seid_len = 0, deid_len = 0, len;
- u8 deid_is_ip4 = 0, seid_is_ip4 = 0;
- u8 is_add = 1;
- u32 action = ~0;
- rloc_t * rlocs = 0, rloc;
+ //TODO: seid need remove
+ ip4_address_t seid4, eid4, rloc4;
+ ip6_address_t seid6, eid6, rloc6;
+ u8 eid_mac[6] = {0};
+ u8 seid_mac[6] = {0};
+ u8 eid_type;
+ u32 eid_len = 0, len;
+ u8 is_add = 1, del_all = 0;
+ u32 action = ~0, p, w;
+ rloc_t * rlocs = 0, rloc, * curr_rloc = 0;
+
+ eid_type = (u8)~0;
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
- if (unformat(input, "del")) {
+ if (unformat(input, "del-all")) {
+ del_all = 1;
+ } else if (unformat(input, "del")) {
is_add = 0;
} else if (unformat(input, "add")) {
is_add = 1;
} else if (unformat(input, "deid %U/%d", unformat_ip4_address,
- &deid4, &len)) {
- deid_set = 1;
- deid_is_ip4 = 1;
- deid_len = len;
+ &eid4, &len)) {
+ eid_type = 0; /* ipv4 */
+ if (32 < len) {
+ clib_warning ("Deid prefix length to big, %d!", len);
+ return -99;
+ }
+ eid_len = len;
} else if (unformat(input, "deid %U/%d", unformat_ip6_address,
- &deid6, &len)) {
- deid_set = 1;
- deid_is_ip4 = 0;
- deid_len = len;
+ &eid6, &len)) {
+ eid_type = 1; /* ipv6 */
+ if (128 < len) {
+ clib_warning ("Deid prefix length to big, %d!", len);
+ return -99;
+ }
+ eid_len = len;
+ } else if (unformat(input, "deid %U", unformat_ethernet_address,
+ eid_mac)) {
+ eid_type = 2; /* mac */
+ //TODO: Need remove, but first must be remove from CSIT test
} else if (unformat(input, "seid %U/%d", unformat_ip4_address,
&seid4, &len)) {
- seid_set = 1;
- seid_is_ip4 = 1;
- seid_len = len;
} else if (unformat(input, "seid %U/%d", unformat_ip6_address,
&seid6, &len)) {
- seid_set = 1;
- seid_is_ip4 = 0;
- seid_len = len;
+ ;
+ } else if (unformat(input, "seid %U", unformat_ethernet_address,
+ seid_mac)) {
+ ;
} else if (unformat(input, "vni %d", &vni)) {
;
+ } else if (unformat(input, "p %d w %d", &p, &w)) {
+ if (!curr_rloc) {
+ errmsg ("No RLOC configured for setting priority/weight!");
+ return -99;
+ }
+ curr_rloc->priority = p;
+ curr_rloc->weight = w;
} else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
rloc.is_ip4 = 1;
clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
vec_add1 (rlocs, rloc);
+ curr_rloc = &rlocs[vec_len (rlocs) - 1];
} else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
rloc.is_ip4 = 0;
clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
vec_add1 (rlocs, rloc);
+ curr_rloc = &rlocs[vec_len (rlocs) - 1];
} else if (unformat(input, "action %d", &action)) {
;
} else {
}
}
- if (!seid_set || !deid_set) {
+ if ((u8)~0 == eid_type) {
errmsg ("missing params!");
return -99;
}
- if (seid_is_ip4 != deid_is_ip4) {
- errmsg ("source and destination EIDs are not in " "same IP family!");
- return -99;
- }
-
if (is_add && (~0 == action)
&& 0 == vec_len (rlocs)) {
errmsg ("no action set for negative map-reply!");
M(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
mp->is_add = is_add;
mp->vni = htonl (vni);
- mp->seid_len = seid_len;
mp->action = (u8) action;
- mp->deid_len = deid_len;
- if (seid_is_ip4) {
- mp->eid_is_ip4 = 1;
- clib_memcpy (mp->seid, &seid4, sizeof (seid4));
- } else {
- mp->eid_is_ip4 = 0;
- clib_memcpy (mp->seid, &seid6, sizeof (seid6));
- }
-
- if (deid_is_ip4) {
- mp->eid_is_ip4 = 1;
- clib_memcpy (mp->deid, &deid4, sizeof (deid4));
- } else {
- mp->eid_is_ip4 = 0;
- clib_memcpy (mp->deid, &deid6, sizeof (deid6));
+ mp->eid_len = eid_len;
+ mp->del_all = del_all;
+ mp->eid_type = eid_type;
+
+ switch (mp->eid_type) {
+ case 0:
+ clib_memcpy (mp->eid, &eid4, sizeof (eid4));
+ break;
+ case 1:
+ clib_memcpy (mp->eid, &eid6, sizeof (eid6));
+ break;
+ case 2:
+ clib_memcpy (mp->eid, eid_mac, 6);
+ break;
+ default:
+ errmsg ("unknown EID type %d!", mp->eid_type);
+ return 0;
}
mp->rloc_num = vec_len (rlocs);
return 0;
}
+/**
+ * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
+ * forwarding entries in data-plane accordingly.
+ *
+ * @param vam vpp API test context
+ * @return return code
+ */
+static int
+api_lisp_add_del_adjacency (vat_main_t * vam)
+{
+ unformat_input_t * input = vam->input;
+ 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;
+ u8 is_add = 1;
+
+ seid_type = deid_type = (u8)~0;
+
+ /* Parse args required to build the message */
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat(input, "del")) {
+ is_add = 0;
+ } else if (unformat(input, "add")) {
+ is_add = 1;
+ } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
+ &deid4, &len)) {
+ deid_type = 0; /* ipv4 */
+ deid_len = len;
+ } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
+ &deid6, &len)) {
+ deid_type = 1; /* ipv6 */
+ deid_len = len;
+ } else if (unformat(input, "deid %U", unformat_ethernet_address,
+ deid_mac)) {
+ deid_type = 2; /* mac */
+ } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
+ &seid4, &len)) {
+ seid_type = 0; /* ipv4 */
+ seid_len = len;
+ } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
+ &seid6, &len)) {
+ seid_type = 1; /* ipv6 */
+ seid_len = len;
+ } else if (unformat(input, "seid %U", unformat_ethernet_address,
+ seid_mac)) {
+ seid_type = 2; /* mac */
+ } else if (unformat(input, "vni %d", &vni)) {
+ ;
+ } else {
+ errmsg ("parse error '%U'", format_unformat_error, input);
+ return -99;
+ }
+ }
+
+ if ((u8)~0 == deid_type) {
+ errmsg ("missing params!");
+ return -99;
+ }
+
+ if (seid_type != deid_type) {
+ errmsg ("source and destination 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;
+
+ switch (mp->eid_type) {
+ case 0:
+ clib_memcpy (mp->seid, &seid4, sizeof (seid4));
+ clib_memcpy (mp->deid, &deid4, sizeof (deid4));
+ break;
+ case 1:
+ clib_memcpy (mp->seid, &seid6, sizeof (seid6));
+ clib_memcpy (mp->deid, &deid6, sizeof (deid6));
+ break;
+ case 2:
+ clib_memcpy (mp->seid, seid_mac, 6);
+ clib_memcpy (mp->deid, deid_mac, 6);
+ break;
+ default:
+ errmsg ("unknown EID type %d!", mp->eid_type);
+ return 0;
+ }
+
+ /* send it... */
+ S;
+
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
static int
api_lisp_gpe_add_del_iface(vat_main_t * vam)
{
return 0;
}
+/**
+ * Add/del map request itr rlocs from LISP control plane and updates
+ *
+ * @param vam vpp API test context
+ * @return return code
+ */
static int
-api_lisp_locator_set_dump(vat_main_t *vam)
+api_lisp_add_del_map_request_itr_rlocs(vat_main_t * vam)
{
- vl_api_lisp_locator_set_dump_t *mp;
+ unformat_input_t * input = vam->input;
+ vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
f64 timeout = ~0;
+ u8 *locator_set_name = 0;
+ u8 locator_set_name_set = 0;
+ u8 is_add = 1;
- if (!vam->json_output) {
- fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n",
- "Locator-set", "Locator", "Priority", "Weight");
+ /* Parse args required to build the message */
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat(input, "del")) {
+ is_add = 0;
+ } else if (unformat(input, "%_%v%_", &locator_set_name)) {
+ locator_set_name_set = 1;
+ } else {
+ clib_warning ("parse error '%U'", format_unformat_error, input);
+ return -99;
+ }
}
- M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
+ if (is_add && !locator_set_name_set) {
+ errmsg ("itr-rloc is not set!");
+ return -99;
+ }
+
+ if (is_add && vec_len(locator_set_name) > 64) {
+ errmsg ("itr-rloc locator-set name too long\n");
+ vec_free(locator_set_name);
+ return -99;
+ }
+
+ M(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
+ mp->is_add = is_add;
+ if (is_add) {
+ clib_memcpy (mp->locator_set_name , locator_set_name,
+ vec_len(locator_set_name));
+ } else {
+ memset(mp->locator_set_name, 0, sizeof(mp->locator_set_name));
+ }
+ vec_free (locator_set_name);
+
/* 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;
}
static int
-api_lisp_local_eid_table_dump(vat_main_t *vam)
+lisp_locator_dump_send_msg(vat_main_t * vam, u32 locator_set_index, u8 filter)
{
- vl_api_lisp_local_eid_table_dump_t *mp;
+ vl_api_lisp_locator_dump_t *mp;
f64 timeout = ~0;
- if (!vam->json_output) {
- fformat(vam->ofp, "%=20s%=30s\n",
- "Locator-set", "Eid");
- }
+ M(LISP_LOCATOR_DUMP, lisp_locator_dump);
+
+ mp->locator_set_index = htonl(locator_set_index);
+ mp->filter = filter;
- M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
/* send it... */
S;
/* Use a control ping for synchronization */
{
- vl_api_control_ping_t * mp;
- M(CONTROL_PING, control_ping);
- S;
+ vl_api_noprint_control_ping_t * mp;
+ M(NOPRINT_CONTROL_PING, noprint_control_ping);
+ S;
}
/* Wait for a reply... */
W;
+}
- /* NOTREACHED */
- return 0;
+static int
+print_locator_in_locator_set(vat_main_t * vam, u8 filter)
+{
+ locator_set_msg_t * ls;
+ locator_msg_t * loc;
+ u8 * tmp_str = 0;
+ int i = 0, ret = 0;
+
+ vec_foreach(ls, vam->locator_set_msg) {
+ ret = lisp_locator_dump_send_msg(vam, ls->locator_set_index, filter);
+ if (ret) {
+ vec_free(ls->locator_set_name);
+ vec_free(vam->locator_msg);
+ vec_free(vam->locator_set_msg);
+ return ret;
+ }
+
+ tmp_str = format(0, "%=20s%=16d%s", ls->locator_set_name,
+ ls->locator_set_index,
+ vec_len(vam->locator_msg) ? "" : "\n");
+ i = 0;
+ vec_foreach(loc, vam->locator_msg) {
+ if (i) {
+ tmp_str = format(tmp_str, "%=37s", " ");
+ }
+ if (loc->local) {
+ tmp_str = format(tmp_str, "%=16d%=16d%=16d\n",
+ loc->sw_if_index,
+ loc->priority,
+ loc->weight);
+ } else {
+ tmp_str = format(tmp_str, "%=16U%=16d%=16d\n",
+ loc->is_ipv6 ? format_ip6_address :
+ format_ip4_address,
+ loc->ip_address,
+ loc->priority,
+ loc->weight);
+ }
+ i++;
+ }
+
+ fformat(vam->ofp, "%s", tmp_str);
+ vec_free(tmp_str);
+ vec_free(ls->locator_set_name);
+ vec_free(vam->locator_msg);
+ }
+
+ vec_free(vam->locator_set_msg);
+
+ return ret;
}
static int
-api_lisp_gpe_tunnel_dump(vat_main_t *vam)
+json_locator_in_locator_set(vat_main_t * vam, u8 filter)
{
- vl_api_lisp_gpe_tunnel_dump_t *mp;
- f64 timeout = ~0;
+ locator_set_msg_t * ls;
+ locator_msg_t * loc;
+ vat_json_node_t * node = NULL;
+ vat_json_node_t * locator_array;
+ vat_json_node_t * locator;
+ struct in6_addr ip6;
+ struct in_addr ip4;
+ int ret = 0;
- if (!vam->json_output) {
- fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
- "%=16s%=16s%=16s%=16s%=16s\n",
- "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
- "Decap next", "Lisp version", "Flags", "Next protocol",
- "ver_res", "res", "iid");
+ if (!vec_len(vam->locator_set_msg)) {
+ /* just print [] */
+ vat_json_init_array(&vam->json_tree);
+ vat_json_print(vam->ofp, &vam->json_tree);
+ vam->json_tree.type = VAT_JSON_NONE;
+ return ret;
}
- M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
+ if (VAT_JSON_ARRAY != vam->json_tree.type) {
+ ASSERT(VAT_JSON_NONE == vam->json_tree.type);
+ vat_json_init_array(&vam->json_tree);
+ }
+
+ vec_foreach(ls, vam->locator_set_msg) {
+ ret = lisp_locator_dump_send_msg(vam, ls->locator_set_index, filter);
+ if (ret) {
+ vec_free(ls->locator_set_name);
+ vec_free(vam->locator_msg);
+ vec_free(vam->locator_set_msg);
+ vat_json_free(&vam->json_tree);
+ vam->json_tree.type = VAT_JSON_NONE;
+ return ret;
+ }
+
+ node = vat_json_array_add(&vam->json_tree);
+ vat_json_init_object(node);
+
+ vat_json_object_add_uint(node, "locator-set-index",
+ ls->locator_set_index);
+ vat_json_object_add_string_copy(node, "locator-set",
+ ls->locator_set_name);
+ locator_array = vat_json_object_add_list(node, "locator");
+ vec_foreach(loc, vam->locator_msg) {
+ locator = vat_json_array_add(locator_array);
+ vat_json_init_object(locator);
+ if (loc->local) {
+ vat_json_object_add_uint(locator, "locator-index",
+ loc->sw_if_index);
+ } else {
+ if (loc->is_ipv6) {
+ clib_memcpy(&ip6, loc->ip_address, sizeof(ip6));
+ vat_json_object_add_ip6(locator, "locator", ip6);
+ } else {
+ clib_memcpy(&ip4, loc->ip_address, sizeof(ip4));
+ vat_json_object_add_ip4(locator, "locator", ip4);
+ }
+ }
+ vat_json_object_add_uint(locator, "priority", loc->priority);
+ vat_json_object_add_uint(locator, "weight", loc->weight);
+ }
+
+ vec_free(ls->locator_set_name);
+ vec_free(vam->locator_msg);
+ }
+
+ vat_json_print(vam->ofp, &vam->json_tree);
+ vat_json_free(&vam->json_tree);
+ vam->json_tree.type = VAT_JSON_NONE;
+
+ vec_free(vam->locator_set_msg);
+
+ return ret;
+}
+
+static int
+get_locator_set_index_from_msg(vat_main_t * vam, u8 * locator_set,
+ u32 * locator_set_index)
+{
+ locator_set_msg_t * ls;
+ int ret = 0;
+
+ * locator_set_index = ~0;
+
+ if (!vec_len(vam->locator_set_msg)) {
+ return ret;
+ }
+
+ vec_foreach(ls, vam->locator_set_msg) {
+ if (!strcmp((char *) locator_set, (char *) ls->locator_set_name)) {
+ * locator_set_index = ls->locator_set_index;
+ vec_free(vam->locator_set_msg);
+ return ret;
+ }
+ }
+
+ vec_free(vam->locator_set_msg);
+
+ return ret;
+}
+
+static int
+get_locator_set_index(vat_main_t * vam, u8 * locator_set,
+ u32 * locator_set_index)
+{
+ vl_api_lisp_locator_set_dump_t *mp;
+ f64 timeout = ~0;
+
+ M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
/* send it... */
S;
- /* Use a control ping for synchronization */
- {
- vl_api_control_ping_t * mp;
- M(CONTROL_PING, control_ping);
- S;
- }
+ /* Use a control ping for synchronization */
+ {
+ vl_api_noprint_control_ping_t * mp;
+ M(NOPRINT_CONTROL_PING, noprint_control_ping);
+ S;
+ }
+
+ vam->noprint_msg = 1;
/* Wait for a reply... */
- W;
+ W_L({
+ get_locator_set_index_from_msg(vam, locator_set, locator_set_index);
+ vam->noprint_msg = 0;
+ })
/* NOTREACHED */
return 0;
}
+static inline int
+lisp_locator_dump(vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
+ u8 filter)
+{
+ int ret = 0;
+
+ ASSERT(vam);
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s%=16s%=16s\n",
+ "locator", "priority", "weight");
+ }
+
+ if (locator_set) {
+ ret = get_locator_set_index(vam, locator_set, &locator_set_index);
+ }
+
+ if (!ret && ~0 == locator_set_index) {
+ return -99;
+ }
+
+ ret = lisp_locator_dump_send_msg(vam, locator_set_index, filter);
+
+ return ret;
+}
+
static int
-api_lisp_map_resolver_dump(vat_main_t *vam)
+lisp_locator_set_dump(vat_main_t * vam, u8 filter)
{
- vl_api_lisp_map_resolver_dump_t *mp;
+ vl_api_lisp_locator_set_dump_t *mp;
f64 timeout = ~0;
if (!vam->json_output) {
- fformat(vam->ofp, "%=20s\n",
- "Map resolver");
+ fformat(vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
+ "locator-set", "locator-set-index", "locator", "priority",
+ "weight");
}
- M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
+ vam->noprint_msg = 1;
+
+ M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
+
+ mp->filter = filter;
+
/* send it... */
S;
- /* Use a control ping for synchronization */
- {
- vl_api_control_ping_t * mp;
- M(CONTROL_PING, control_ping);
- S;
- }
+ /* Use a control ping for synchronization */
+ {
+ vl_api_noprint_control_ping_t * mp;
+ M(NOPRINT_CONTROL_PING, noprint_control_ping);
+ S;
+ }
+
/* Wait for a reply... */
- W;
+ W_L({
+ if (vam->noprint_msg) {
+ if (!vam->json_output) {
+ print_locator_in_locator_set(vam, filter);
+ } else {
+ json_locator_in_locator_set(vam, filter);
+ }
+ }
+
+ vam->noprint_msg = 0;
+ });
/* NOTREACHED */
return 0;
}
static int
-api_lisp_enable_disable_status_dump(vat_main_t *vam)
+api_lisp_locator_set_dump(vat_main_t *vam)
+{
+ unformat_input_t * input = vam->input;
+ vam->noprint_msg = 0;
+ u32 locator_set_index = ~0;
+ u8 locator_set_index_set = 0;
+ u8 * locator_set = 0;
+ u8 locator_set_set = 0;
+ u8 filter = 0;
+ int ret = 0;
+
+ /* Parse args required to build the message */
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat(input, "locator-set-index %u", &locator_set_index)) {
+ locator_set_index_set = 1;
+ } else if (unformat(input, "locator-set %s", &locator_set)) {
+ locator_set_set = 1;
+ } else if (unformat(input, "local")) {
+ filter = 1;
+ } else if (unformat(input, "remote")) {
+ filter = 2;
+ } else {
+ break;
+ }
+ }
+
+ if (locator_set_index_set && locator_set_set) {
+ errmsg ("use only input parameter!\n");
+ return -99;
+ }
+
+ if (locator_set_index_set || locator_set_set) {
+ ret = lisp_locator_dump(vam, locator_set_index, locator_set, filter);
+ } else {
+ ret = lisp_locator_set_dump(vam, filter);
+ }
+
+ vec_free(locator_set);
+
+ return ret;
+}
+
+static int
+api_lisp_eid_table_map_dump(vat_main_t *vam)
{
- vl_api_lisp_enable_disable_status_dump_t *mp;
+ vl_api_lisp_eid_table_map_dump_t *mp;
f64 timeout = ~0;
if (!vam->json_output) {
- fformat(vam->ofp, "%=20s\n",
- "lisp status:");
+ fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
}
- M(LISP_ENABLE_DISABLE_STATUS_DUMP,
- lisp_enable_disable_status_dump);
+ M(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
+
/* send it... */
S;
}
static int
-api_af_packet_create (vat_main_t * vam)
+api_lisp_local_eid_table_dump(vat_main_t *vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_lisp_local_eid_table_dump_t *mp;
+ f64 timeout = ~0;
+ struct in_addr ip4;
+ struct in6_addr ip6;
+ u8 mac[6];
+ u8 eid_type = ~0, eid_set = 0;
+ u32 prefix_length = ~0, t, vni = 0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t)) {
+ eid_set = 1;
+ eid_type = 0;
+ prefix_length = t;
+ } else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t)) {
+ eid_set = 1;
+ eid_type = 1;
+ prefix_length = t;
+ } else if (unformat (i, "eid %U", unformat_ethernet_address, mac)) {
+ eid_set = 1;
+ eid_type = 2;
+ } else if (unformat (i, "vni %d", &t))
+ vni = t;
+ else {
+ errmsg ("parse error '%U'", format_unformat_error, i);
+ return -99;
+ }
+ }
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s%=30s\n",
+ "Locator-set", "Eid");
+ }
+
+ M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
+
+ if (eid_set) {
+ mp->eid_set = 1;
+ mp->vni = htonl (vni);
+ mp->eid_type = eid_type;
+ switch (eid_type) {
+ case 0:
+ mp->prefix_length = prefix_length;
+ clib_memcpy (mp->eid, &ip4, sizeof (ip4));
+ break;
+ case 1:
+ mp->prefix_length = prefix_length;
+ clib_memcpy (mp->eid, &ip6, sizeof (ip6));
+ break;
+ case 2:
+ clib_memcpy (mp->eid, mac, sizeof (mac));
+ break;
+ default:
+ errmsg ("unknown EID type %d!", eid_type);
+ return -99;
+ }
+ }
+
+ /* send it... */
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_lisp_gpe_tunnel_dump(vat_main_t *vam)
+{
+ vl_api_lisp_gpe_tunnel_dump_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
+ "%=16s%=16s%=16s%=16s%=16s\n",
+ "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
+ "Decap next", "Lisp version", "Flags", "Next protocol",
+ "ver_res", "res", "iid");
+ }
+
+ M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
+ /* send it... */
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_lisp_map_resolver_dump(vat_main_t *vam)
+{
+ vl_api_lisp_map_resolver_dump_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s\n",
+ "Map resolver");
+ }
+
+ M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
+ /* send it... */
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_show_lisp_status(vat_main_t *vam)
+{
+ vl_api_show_lisp_status_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%-20s%-16s\n",
+ "lisp status", "locator-set");
+ }
+
+ M(SHOW_LISP_STATUS, show_lisp_status);
+ /* send it... */
+ S;
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_lisp_get_map_request_itr_rlocs(vat_main_t *vam)
+{
+ vl_api_lisp_get_map_request_itr_rlocs_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat(vam->ofp, "%=20s\n",
+ "itr-rlocs:");
+ }
+
+ M(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
+ /* send it... */
+ S;
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_af_packet_create (vat_main_t * vam)
{
unformat_input_t * i = vam->input;
vl_api_af_packet_create_t * mp;
return -99;
}
- if (vec_len (host_if_name) > 64) {
- errmsg ("host-interface name too long");
- return -99;
+ if (vec_len (host_if_name) > 64) {
+ errmsg ("host-interface name too long");
+ return -99;
+ }
+
+ M(AF_PACKET_CREATE, af_packet_create);
+
+ clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
+ clib_memcpy (mp->hw_addr, hw_addr, 6);
+ mp->use_random_hw_addr = random_hw_addr;
+ vec_free (host_if_name);
+
+ S; W2(fprintf(vam->ofp," new sw_if_index = %d ", vam->sw_if_index));
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_af_packet_delete (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_af_packet_delete_t * mp;
+ f64 timeout;
+ u8 * host_if_name = 0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "name %s", &host_if_name))
+ vec_add1 (host_if_name, 0);
+ else
+ break;
+ }
+
+ if (!vec_len (host_if_name)) {
+ errmsg ("host-interface name must be specified");
+ return -99;
+ }
+
+ if (vec_len (host_if_name) > 64) {
+ errmsg ("host-interface name too long");
+ return -99;
+ }
+
+ M(AF_PACKET_DELETE, af_packet_delete);
+
+ clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
+ vec_free (host_if_name);
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_policer_add_del (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_policer_add_del_t * mp;
+ f64 timeout;
+ u8 is_add = 1;
+ u8 * name = 0;
+ u32 cir = 0;
+ u32 eir = 0;
+ u64 cb = 0;
+ u64 eb = 0;
+ u8 rate_type = 0;
+ u8 round_type = 0;
+ u8 type = 0;
+ u8 color_aware = 0;
+ sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "del"))
+ is_add = 0;
+ else if (unformat (i, "name %s", &name))
+ vec_add1 (name, 0);
+ else if (unformat (i, "cir %u", &cir))
+ ;
+ else if (unformat (i, "eir %u", &eir))
+ ;
+ else if (unformat (i, "cb %u", &cb))
+ ;
+ else if (unformat (i, "eb %u", &eb))
+ ;
+ else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
+ &rate_type))
+ ;
+ else if (unformat (i, "round_type %U", unformat_policer_round_type,
+ &round_type))
+ ;
+ else if (unformat (i, "type %U", unformat_policer_type, &type))
+ ;
+ else if (unformat (i, "conform_action %U", unformat_policer_action_type,
+ &conform_action))
+ ;
+ else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
+ &exceed_action))
+ ;
+ else if (unformat (i, "violate_action %U", unformat_policer_action_type,
+ &violate_action))
+ ;
+ else if (unformat (i, "color-aware"))
+ color_aware = 1;
+ else
+ break;
+ }
+
+ if (!vec_len (name)) {
+ errmsg ("policer name must be specified");
+ return -99;
+ }
+
+ if (vec_len (name) > 64) {
+ errmsg ("policer name too long");
+ return -99;
+ }
+
+ M(POLICER_ADD_DEL, policer_add_del);
+
+ clib_memcpy (mp->name, name, vec_len (name));
+ vec_free (name);
+ mp->is_add = is_add;
+ mp->cir = cir;
+ mp->eir = eir;
+ mp->cb = cb;
+ mp->eb = eb;
+ mp->rate_type = rate_type;
+ mp->round_type = round_type;
+ mp->type = type;
+ mp->conform_action_type = conform_action.action_type;
+ mp->conform_dscp = conform_action.dscp;
+ mp->exceed_action_type = exceed_action.action_type;
+ mp->exceed_dscp = exceed_action.dscp;
+ mp->violate_action_type = violate_action.action_type;
+ mp->violate_dscp = violate_action.dscp;
+ mp->color_aware = color_aware;
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_policer_dump(vat_main_t *vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_policer_dump_t *mp;
+ f64 timeout = ~0;
+ u8 *match_name = 0;
+ u8 match_name_valid = 0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "name %s", &match_name)) {
+ vec_add1 (match_name, 0);
+ match_name_valid = 1;
+ } else
+ break;
+ }
+
+ M(POLICER_DUMP, policer_dump);
+ mp->match_name_valid = match_name_valid;
+ clib_memcpy (mp->match_name, match_name, vec_len (match_name));
+ vec_free (match_name);
+ /* send it... */
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ /* Wait for a reply... */
+ W;
+
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_policer_classify_set_interface (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_policer_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;
+ u32 l2_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 if (unformat (i, "l2-table %d", &l2_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(POLICER_CLASSIFY_SET_INTERFACE, policer_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->l2_table_index = ntohl(l2_table_index);
+ mp->is_add = is_add;
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_policer_classify_dump(vat_main_t *vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_policer_classify_dump_t *mp;
+ f64 timeout = ~0;
+ u8 type = POLICER_CLASSIFY_N_TABLES;
+
+ if (unformat (i, "type %U", unformat_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(POLICER_CLASSIFY_DUMP, policer_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
+api_netmap_create (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_netmap_create_t * mp;
+ f64 timeout;
+ u8 * if_name = 0;
+ u8 hw_addr[6];
+ u8 random_hw_addr = 1;
+ u8 is_pipe = 0;
+ u8 is_master = 0;
+
+ memset (hw_addr, 0, sizeof (hw_addr));
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "name %s", &if_name))
+ vec_add1 (if_name, 0);
+ else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
+ random_hw_addr = 0;
+ else if (unformat (i, "pipe"))
+ is_pipe = 1;
+ else if (unformat (i, "master"))
+ is_master = 1;
+ else if (unformat (i, "slave"))
+ is_master = 0;
+ else
+ break;
+ }
+
+ if (!vec_len (if_name)) {
+ errmsg ("interface name must be specified");
+ return -99;
+ }
+
+ if (vec_len (if_name) > 64) {
+ errmsg ("interface name too long");
+ return -99;
+ }
+
+ M(NETMAP_CREATE, netmap_create);
+
+ clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
+ clib_memcpy (mp->hw_addr, hw_addr, 6);
+ mp->use_random_hw_addr = random_hw_addr;
+ mp->is_pipe = is_pipe;
+ mp->is_master = is_master;
+ vec_free (if_name);
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static int
+api_netmap_delete (vat_main_t * vam)
+{
+ unformat_input_t * i = vam->input;
+ vl_api_netmap_delete_t * mp;
+ f64 timeout;
+ u8 * if_name = 0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (i, "name %s", &if_name))
+ vec_add1 (if_name, 0);
+ else
+ break;
+ }
+
+ if (!vec_len (if_name)) {
+ errmsg ("interface name must be specified");
+ return -99;
+ }
+
+ if (vec_len (if_name) > 64) {
+ errmsg ("interface name too long");
+ return -99;
+ }
+
+ M(NETMAP_DELETE, netmap_delete);
+
+ clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
+ vec_free (if_name);
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+static void vl_api_mpls_gre_tunnel_details_t_handler
+(vl_api_mpls_gre_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]: 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));
+ }
+}
+
+static void vl_api_mpls_gre_tunnel_details_t_handler_json
+(vl_api_mpls_gre_tunnel_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);
+
+ 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, "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));
+ 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_uint(node, "label_count", len);
+ for (i = 0; i < len; i++) {
+ vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
+ }
+}
+
+static int api_mpls_gre_tunnel_dump (vat_main_t * vam)
+{
+ vl_api_mpls_gre_tunnel_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) {
+ if (!unformat (vam->input, "tunnel_index %d", &index)) {
+ index = -1;
+ break;
+ }
+ }
+
+ fformat(vam->ofp, " tunnel_index %d\n", index);
+
+ M(MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
+ mp->tunnel_index = htonl(index);
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ W;
+}
+
+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);
+
+ 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, "%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)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t *node = NULL;
+ struct in_addr ip4;
+ i32 i;
+ i32 len = ntohl(mp->nlabels);
+
+ 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, "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, "label_count", len);
+ for (i = 0; i < len; i++) {
+ vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
+ }
+}
+
+static int api_mpls_eth_tunnel_dump (vat_main_t * vam)
+{
+ vl_api_mpls_eth_tunnel_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) {
+ if (!unformat (vam->input, "tunnel_index %d", &index)) {
+ index = -1;
+ break;
+ }
+ }
+
+ fformat(vam->ofp, " tunnel_index %d\n", index);
+
+ M(MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
+ mp->tunnel_index = htonl(index);
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+ W;
+}
+
+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, "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");
+}
+
+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;
+ i32 i;
+ i32 len = ntohl(mp->nlabels);
+ struct in_addr ip4;
+
+ 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->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, "label", ntohl(mp->labels[i]));
+ }
+}
+
+static int api_mpls_fib_encap_dump (vat_main_t * vam)
+{
+ vl_api_mpls_fib_encap_dump_t *mp;
+ f64 timeout;
+
+ 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;
+}
+
+static void vl_api_mpls_fib_decap_details_t_handler
+(vl_api_mpls_fib_decap_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+
+ 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));
+}
+
+static void vl_api_mpls_fib_decap_details_t_handler_json
+(vl_api_mpls_fib_decap_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t *node = NULL;
+ struct in_addr ip4;
+
+ 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->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);
+}
+
+static int api_mpls_fib_decap_dump (vat_main_t * vam)
+{
+ vl_api_mpls_fib_decap_dump_t *mp;
+ f64 timeout;
+
+ M(MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
}
+ W;
+}
- M(AF_PACKET_CREATE, af_packet_create);
+int api_classify_table_ids (vat_main_t *vam)
+{
+ vl_api_classify_table_ids_t *mp;
+ f64 timeout;
- clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
- clib_memcpy (mp->hw_addr, hw_addr, 6);
- mp->use_random_hw_addr = random_hw_addr;
- vec_free (host_if_name);
+ /* Construct the API message */
+ M(CLASSIFY_TABLE_IDS, classify_table_ids);
+ mp->context = 0;
S; W;
/* NOTREACHED */
return 0;
}
-static int
-api_af_packet_delete (vat_main_t * vam)
+int api_classify_table_by_interface (vat_main_t *vam)
{
- unformat_input_t * i = vam->input;
- vl_api_af_packet_delete_t * mp;
+ unformat_input_t * input = vam->input;
+ vl_api_classify_table_by_interface_t *mp;
f64 timeout;
- u8 * host_if_name = 0;
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "name %s", &host_if_name))
- vec_add1 (host_if_name, 0);
+ u32 sw_if_index = ~0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
+ ;
+ else if (unformat (input, "sw_if_index %d", &sw_if_index))
+ ;
else
- break;
- }
-
- if (!vec_len (host_if_name)) {
- errmsg ("host-interface name must be specified");
- return -99;
+ break;
}
-
- if (vec_len (host_if_name) > 64) {
- errmsg ("host-interface name too long");
+ if (sw_if_index == ~0) {
+ errmsg ("missing interface name or sw_if_index\n");
return -99;
}
- M(AF_PACKET_DELETE, af_packet_delete);
-
- clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
- vec_free (host_if_name);
+ /* Construct the API message */
+ M(CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
+ mp->context = 0;
+ mp->sw_if_index = ntohl(sw_if_index);
S; W;
/* NOTREACHED */
return 0;
}
-static int
-api_policer_add_del (vat_main_t * vam)
+int api_classify_table_info (vat_main_t *vam)
{
- unformat_input_t * i = vam->input;
- vl_api_policer_add_del_t * mp;
+ unformat_input_t * input = vam->input;
+ vl_api_classify_table_info_t *mp;
f64 timeout;
- u8 is_add = 1;
- u8 * name = 0;
- u32 cir = 0;
- u32 eir = 0;
- u64 cb = 0;
- u64 eb = 0;
- u8 rate_type = 0;
- u8 round_type = 0;
- u8 type = 0;
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "del"))
- is_add = 0;
- else if (unformat (i, "name %s", &name))
- vec_add1 (name, 0);
- else if (unformat (i, "cir %u", &cir))
- ;
- else if (unformat (i, "eir %u", &eir))
- ;
- else if (unformat (i, "cb %u", &cb))
- ;
- else if (unformat (i, "eb %u", &eb))
- ;
- else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
- &rate_type))
- ;
- else if (unformat (i, "round_type %U", unformat_policer_round_type,
- &round_type))
- ;
- else if (unformat (i, "type %U", unformat_policer_type, &type))
+ u32 table_id = ~0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "table_id %d", &table_id))
;
else
- break;
- }
-
- if (!vec_len (name)) {
- errmsg ("policer name must be specified");
- return -99;
+ break;
}
-
- if (vec_len (name) > 64) {
- errmsg ("policer name too long");
+ if (table_id == ~0) {
+ errmsg ("missing table id\n");
return -99;
}
- M(POLICER_ADD_DEL, policer_add_del);
-
- clib_memcpy (mp->name, name, vec_len (name));
- vec_free (name);
- mp->is_add = is_add;
- mp->cir = cir;
- mp->eir = eir;
- mp->cb = cb;
- mp->eb = eb;
- mp->rate_type = rate_type;
- mp->round_type = round_type;
- mp->type = type;
+ /* Construct the API message */
+ M(CLASSIFY_TABLE_INFO, classify_table_info);
+ mp->context = 0;
+ mp->table_id = ntohl(table_id);
S; W;
/* NOTREACHED */
return 0;
}
-static int
-api_policer_dump(vat_main_t *vam)
+int api_classify_session_dump (vat_main_t *vam)
{
- unformat_input_t * i = vam->input;
- vl_api_policer_dump_t *mp;
- f64 timeout = ~0;
- u8 *match_name = 0;
- u8 match_name_valid = 0;
+ unformat_input_t * input = vam->input;
+ vl_api_classify_session_dump_t *mp;
+ f64 timeout;
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "name %s", &match_name)) {
- vec_add1 (match_name, 0);
- match_name_valid = 1;
- } else
+ u32 table_id = ~0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "table_id %d", &table_id))
+ ;
+ else
break;
}
+ if (table_id == ~0) {
+ errmsg ("missing table id\n");
+ return -99;
+ }
- M(POLICER_DUMP, policer_dump);
- mp->match_name_valid = match_name_valid;
- clib_memcpy (mp->match_name, match_name, vec_len (match_name));
- vec_free (match_name);
- /* send it... */
+ /* Construct the API message */
+ M(CLASSIFY_SESSION_DUMP, classify_session_dump);
+ mp->context = 0;
+ mp->table_id = ntohl(table_id);
S;
/* Use a control ping for synchronization */
M(CONTROL_PING, control_ping);
S;
}
- /* Wait for a reply... */
W;
-
/* NOTREACHED */
return 0;
}
-static int
-api_netmap_create (vat_main_t * vam)
+static void vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
{
- unformat_input_t * i = vam->input;
- vl_api_netmap_create_t * mp;
+ vat_main_t * vam = &vat_main;
+
+ fformat(vam->ofp, "collector_address %U, collector_port %d, "
+ "src_address %U, fib_index %u, path_mtu %u, "
+ "template_interval %u\n",
+ format_ip4_address, mp->collector_address,
+ ntohs(mp->collector_port),
+ format_ip4_address, mp->src_address,
+ ntohl(mp->fib_index),
+ ntohl(mp->path_mtu),
+ ntohl(mp->template_interval));
+
+ vam->retval = 0;
+ vam->result_ready = 1;
+}
+
+static void vl_api_ipfix_details_t_handler_json
+(vl_api_ipfix_details_t * mp)
+{
+ vat_main_t * vam = &vat_main;
+ vat_json_node_t node;
+ struct in_addr collector_address;
+ struct in_addr src_address;
+
+ vat_json_init_object(&node);
+ clib_memcpy(&collector_address, &mp->collector_address,
+ sizeof(collector_address));
+ vat_json_object_add_ip4(&node, "collector_address", collector_address);
+ vat_json_object_add_uint(&node, "collector_port",
+ ntohs(mp->collector_port));
+ clib_memcpy(&src_address, &mp->src_address, sizeof(src_address));
+ vat_json_object_add_ip4(&node, "src_address", src_address);
+ vat_json_object_add_uint(&node, "fib_index", ntohl(mp->fib_index));
+ vat_json_object_add_uint(&node, "path_mtu", ntohl(mp->path_mtu));
+ vat_json_object_add_uint(&node, "template_interval",
+ ntohl(mp->template_interval));
+
+ vat_json_print(vam->ofp, &node);
+ vat_json_free(&node);
+ vam->retval = 0;
+ vam->result_ready = 1;
+}
+
+int api_ipfix_dump (vat_main_t *vam)
+{
+ vl_api_ipfix_dump_t *mp;
f64 timeout;
- u8 * if_name = 0;
- u8 hw_addr[6];
- u8 random_hw_addr = 1;
- u8 is_pipe = 0;
- u8 is_master = 0;
- memset (hw_addr, 0, sizeof (hw_addr));
+ /* Construct the API message */
+ M(IPFIX_DUMP, ipfix_dump);
+ mp->context = 0;
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "name %s", &if_name))
- vec_add1 (if_name, 0);
- else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
- random_hw_addr = 0;
- else if (unformat (i, "pipe"))
- is_pipe = 1;
- else if (unformat (i, "master"))
- is_master = 1;
- else if (unformat (i, "slave"))
- is_master = 0;
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+int api_pg_create_interface (vat_main_t *vam)
+{
+ unformat_input_t * input = vam->input;
+ vl_api_pg_create_interface_t *mp;
+ f64 timeout;
+
+ u32 if_id = ~0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "if_id %d", &if_id))
+ ;
else
- break;
+ break;
}
-
- if (!vec_len (if_name)) {
- errmsg ("interface name must be specified");
+ if (if_id == ~0) {
+ errmsg ("missing pg interface index\n");
return -99;
}
- if (vec_len (if_name) > 64) {
- errmsg ("interface name too long");
+ /* Construct the API message */
+ M(PG_CREATE_INTERFACE, pg_create_interface);
+ mp->context = 0;
+ mp->interface_id = ntohl(if_id);
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
+int api_pg_capture (vat_main_t *vam)
+{
+ unformat_input_t * input = vam->input;
+ vl_api_pg_capture_t *mp;
+ f64 timeout;
+
+ u32 if_id = ~0;
+ u8 enable = 1;
+ u32 count = 1;
+ u8 pcap_file_set = 0;
+ u8 * pcap_file = 0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "if_id %d", &if_id))
+ ;
+ else if (unformat (input, "pcap %s", &pcap_file))
+ pcap_file_set = 1;
+ else if (unformat (input, "count %d", &count))
+ ;
+ else if (unformat (input, "disable"))
+ enable = 0;
+ else
+ break;
+ }
+ if (if_id == ~0) {
+ errmsg ("missing pg interface index\n");
return -99;
}
+ if (pcap_file_set>0) {
+ if (vec_len (pcap_file) > 255) {
+ errmsg ("pcap file name is too long\n");
+ return -99;
+ }
+ }
- M(NETMAP_CREATE, netmap_create);
-
- clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
- clib_memcpy (mp->hw_addr, hw_addr, 6);
- mp->use_random_hw_addr = random_hw_addr;
- mp->is_pipe = is_pipe;
- mp->is_master = is_master;
- vec_free (if_name);
+ u32 name_len = vec_len(pcap_file);
+ /* Construct the API message */
+ M(PG_CAPTURE, pg_capture);
+ mp->context = 0;
+ mp->interface_id = ntohl(if_id);
+ mp->is_enabled = enable;
+ mp->count = ntohl(count);
+ mp->pcap_name_length = ntohl(name_len);
+ if (pcap_file_set != 0) {
+ clib_memcpy(mp->pcap_file_name, pcap_file, name_len);
+ }
+ vec_free(pcap_file);
S; W;
/* NOTREACHED */
return 0;
}
-static int
-api_netmap_delete (vat_main_t * vam)
+int api_pg_enable_disable (vat_main_t *vam)
{
- unformat_input_t * i = vam->input;
- vl_api_netmap_delete_t * mp;
+ unformat_input_t * input = vam->input;
+ vl_api_pg_enable_disable_t *mp;
f64 timeout;
- u8 * if_name = 0;
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
- if (unformat (i, "name %s", &if_name))
- vec_add1 (if_name, 0);
+ u8 enable = 1;
+ u8 stream_name_set = 0;
+ u8 * stream_name = 0;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "stream %s", &stream_name))
+ stream_name_set = 1;
+ else if (unformat (input, "disable"))
+ enable = 0;
else
break;
}
- if (!vec_len (if_name)) {
- errmsg ("interface name must be specified");
- return -99;
+ if (stream_name_set>0) {
+ if (vec_len (stream_name) > 255) {
+ errmsg ("stream name too long\n");
+ return -99;
+ }
}
- if (vec_len (if_name) > 64) {
- errmsg ("interface name too long");
- return -99;
+ u32 name_len = vec_len(stream_name);
+ /* Construct the API message */
+ M(PG_ENABLE_DISABLE, pg_enable_disable);
+ mp->context = 0;
+ mp->is_enabled = enable;
+ if (stream_name_set != 0) {
+ mp->stream_name_length = ntohl(name_len);
+ clib_memcpy(mp->stream_name, stream_name, name_len);
}
-
- M(NETMAP_DELETE, netmap_delete);
-
- clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
- vec_free (if_name);
+ vec_free(stream_name);
S; W;
/* NOTREACHED */
fformat(vam->ofp, "Help is available for the following:\n");
- hash_foreach_pair (p, vam->function_by_name,
+ hash_foreach_pair (p, vam->function_by_name,
({
vec_add1 (cmds, (u8 *)(p->key));
}));
value[vec_len(value)-1] = 0;
/* Make sure it's a proper string, one way or the other */
vec_add1 (value, 0);
- (void) clib_macro_set_value (&vam->macro_main,
+ (void) clib_macro_set_value (&vam->macro_main,
(char *)name, (char *)value);
}
else
static int dump_macro_table (vat_main_t * vam)
{
- macro_sort_t * sort_me = 0, * sm;
+ macro_sort_t * sort_me = 0, * sm;
int i;
hash_pair_t * p;
- hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
+ hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
({
vec_add2 (sort_me, sm, 1);
sm->name = (u8 *)(p->key);
sm->value = (u8 *) (p->value[0]);
}));
-
+
vec_sort_with_function (sort_me, macro_sort_cmp);
if (vec_len(sort_me))
}
}
}
-
+
else {
- clib_warning ("parse error '%U'", format_unformat_error,
+ clib_warning ("parse error '%U'", format_unformat_error,
line_input);
return -99;
}
out:
vec_free(node_to_find);
-
+
}
- return 0;
+ return 0;
}
"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") \
_(l2fib_add_del, \
- "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi]\n") \
+ "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
_(l2_flags, \
"sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
_(bridge_flags, \
_(sw_interface_set_unnumbered, \
"<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
_(ip_neighbor_add_del, \
- "<intfc> | sw_if_index <id> dst <ip46-address> mac <mac-addr>") \
+ "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
+ "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
_(reset_vrf, "vrf <id> [ipv6]") \
_(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
_(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
"[nolink] [isno]") \
_(sw_interface_ip6nd_ra_config, \
"<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
- "[life <n>] [count <n>] [interval <n>] [surpress]\n" \
+ "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
"[managed] [other] [ll] [send] [cease] [isno] [def]") \
_(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
_(l2_patch_add_del, \
"[del] mask <mask-value>\n" \
" [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
_(classify_add_del_session, \
- "[hit-next|l2-hit-next|acl-hit-next] <name|nn> table-index <nn>\n" \
- "skip_n <nn> match_n <nn> match [hex] [l2] [l3 [ip4|ip6]]") \
+ "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
+ " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
+ " [l3 [ip4|ip6]]") \
_(classify_set_interface_ip_table, \
"<intfc> | sw_if_index <nn> table <nn>") \
_(classify_set_interface_l2_tables, \
_(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
_(sw_interface_vhost_user_dump, "") \
_(show_version, "") \
-_(vxlan_gpe_add_del_tunnel, \
- "local <ip4-addr> remote <ip4-addr> vni <nn>\n" \
- "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
- "[next-ethernet] [next-nsh]\n") \
+_(vxlan_gpe_add_del_tunnel, \
+ "local <addr> remote <addr> vni <nn>\n" \
+ "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
+ "[next-ethernet] [next-nsh]\n") \
+_(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
_(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
_(interface_name_renumber, \
"<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
_(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
" vrf_id <nn> add | pop | none") \
_(trace_profile_del, "") \
-_(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \
+_(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
+ " sw_if_index <sw_if_index> p <priority> " \
+ "w <weight>] [del]") \
_(lisp_add_del_locator, "locator-set <locator_name> " \
"iface <intf> | sw_if_index <sw_if_index> " \
"p <priority> w <weight> [del]") \
-_(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \
+_(lisp_add_del_local_eid,"vni <vni> eid " \
+ "<ipv4|ipv6>/<prefix> | <L2 address> " \
"locator-set <locator_name> [del]") \
_(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \
"sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \
_(lisp_gpe_enable_disable, "enable|disable") \
_(lisp_enable_disable, "enable|disable") \
_(lisp_gpe_add_del_iface, "up|down") \
-_(lisp_add_del_remote_mapping, "add|del vni <vni> table-id <id> " \
- "deid <dest-eid> seid" \
- " <src-eid> rloc <locator> " \
- "[rloc <loc> ... ]") \
+_(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
+ "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_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
-_(lisp_locator_set_dump, "") \
+_(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
+_(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
+_(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
+ "locator-set <loc-set-name>] [local | remote]")\
_(lisp_local_eid_table_dump, "") \
+_(lisp_eid_table_map_dump, "") \
_(lisp_gpe_tunnel_dump, "") \
_(lisp_map_resolver_dump, "") \
-_(lisp_enable_disable_status_dump, "") \
+_(show_lisp_status, "") \
+_(lisp_get_map_request_itr_rlocs, "") \
+_(show_lisp_pitr, "") \
_(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
_(af_packet_delete, "name <host interface name>") \
_(policer_add_del, "name <policer name> <params> [del]") \
_(policer_dump, "[name <policer name>]") \
+_(policer_classify_set_interface, \
+ "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
+ " [l2-table <nn>] [del]") \
+_(policer_classify_dump, "type [ip4|ip6|l2]") \
_(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
"[master|slave]") \
-_(netmap_delete, "name <interface name>")
+_(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, "") \
+_(classify_table_ids, "") \
+_(classify_table_by_interface, "sw_if_index <sw_if_index>") \
+_(classify_table_info, "table_id <nn>") \
+_(classify_session_dump, "table_id <nn>") \
+_(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
+ "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
+ "[template_interval <nn>]") \
+_(ipfix_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]") \
+_(pg_enable_disable, "[stream <id>] disable")
/* List of command functions, CLI names map directly to functions */
#define foreach_cli_function \
vl_noop_handler, \
vl_api_##n##_t_endian, \
vl_api_##n##_t_print, \
- sizeof(vl_api_##n##_t), 1);
+ sizeof(vl_api_##n##_t), 1);
foreach_vpe_api_reply_msg;
#undef _
vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
- vam->sw_if_index_by_interface_name =
+ vam->sw_if_index_by_interface_name =
hash_create_string (0, sizeof (uword));
- vam->function_by_name =
+ vam->function_by_name =
hash_create_string (0, sizeof(uword));
- vam->help_by_name =
+ vam->help_by_name =
hash_create_string (0, sizeof(uword));
/* API messages we can send */
#undef vl_api_version
#define vl_api_version(n,v) static u32 vpe_api_version = v;
-#include <api/vpe.api.h>
+#include <vpp-api/vpe.api.h>
#undef vl_api_version
-void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
+void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
{
- /*
+ /*
* Send the main API signature in slot 0. This bit of code must
* match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
*/