#include <vnet/cop/cop.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/policer/xlate.h>
+#include <vnet/policer/policer.h>
#include "vat/json_format.h"
+#include <sys/stat.h>
+
#define vl_typedefs /* define message structures */
#include <vpp-api/vpe_all_api_h.h>
#undef vl_typedefs
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;
+}
+
u8 * format_ip4_address (u8 * s, va_list * args)
{
u8 * a = va_arg (*args, u8 *);
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
(vl_api_create_loopback_reply_t * mp)
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)
{
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)
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);
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->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_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;
+}
+
#define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
#define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
#define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
#define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
/*
- * 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
*
_(policer_add_del_reply) \
_(netmap_create_reply) \
_(netmap_delete_reply) \
-_(ipfix_enable_reply)
+_(ipfix_enable_reply) \
+_(pg_capture_reply) \
+_(pg_enable_disable_reply)
#define _(n) \
static void vl_api_##n##_t_handler \
_(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
_(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_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_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) \
_(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
_(CLASSIFY_SESSION_DETAILS, classify_session_details) \
_(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
-_(IPFIX_DETAILS, ipfix_details)
+_(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 */
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) {
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;
- } else if (unformat (i, "bvi")) {
- bvi_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);
+
+ 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;
+ }
- 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;
+ 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;
}
-
- S; W;
- /* NOTREACHED */
- return 0;
+ /* Return the good/bad news */
+ return (vam->retval);
}
static int api_l2_flags (vat_main_t * vam)
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;
+}
+
static int api_add_node_next (vat_main_t * vam)
{
unformat_input_t * i = vam->input;
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, "vni %d", &vni)) {
;
} else if (unformat(input, "eid %U/%d", unformat_ip4_address,
&eidv4, &tmp_eid_lenght)) {
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/delete mapping between vni and vrf
*/
return 0;
}
+static int
+api_lisp_eid_table_map_dump(vat_main_t *vam)
+{
+ vl_api_lisp_eid_table_map_dump_t *mp;
+ f64 timeout = ~0;
+
+ if (!vam->json_output) {
+ fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
+ }
+
+ M(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_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_local_eid_table_dump(vat_main_t *vam)
{
f64 timeout = ~0;
if (!vam->json_output) {
- fformat(vam->ofp, "%=20s\n",
- "lisp status:");
+ fformat(vam->ofp, "%-20s%-16s\n",
+ "lisp status", "locator-set");
}
M(LISP_ENABLE_DISABLE_STATUS_DUMP,
u8 rate_type = 0;
u8 round_type = 0;
u8 type = 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"))
;
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
break;
}
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;
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;
+ }
+ if (if_id == ~0) {
+ errmsg ("missing pg interface index\n");
+ return -99;
+ }
+
+ /* 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;
+ }
+ }
+
+ 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;
+}
+
+int api_pg_enable_disable (vat_main_t *vam)
+{
+ unformat_input_t * input = vam->input;
+ vl_api_pg_enable_disable_t *mp;
+ f64 timeout;
+
+ 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 (stream_name_set>0) {
+ if (vec_len (stream_name) > 255) {
+ errmsg ("stream name too long\n");
+ 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);
+ }
+ vec_free(stream_name);
+
+ S; W;
+ /* NOTREACHED */
+ return 0;
+}
+
static int q_or_quit (vat_main_t * vam)
{
longjmp (vam->jump_buf, 1);
"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, \
_(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
_(lisp_locator_set_dump, "") \
_(lisp_local_eid_table_dump, "") \
+_(lisp_eid_table_map_dump, "") \
_(lisp_gpe_tunnel_dump, "") \
_(lisp_map_resolver_dump, "") \
_(lisp_enable_disable_status_dump, "") \
_(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]") \
_(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
"src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
"[template_interval <nn>]") \
-_(ipfix_dump, "")
+_(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 \
Code Review / vpp.git / blobdiff