2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/l2tp/l2tp.h>
31 #include <vnet/vxlan/vxlan.h>
32 #include <vnet/geneve/geneve.h>
33 #include <vnet/gre/gre.h>
34 #include <vnet/vxlan-gpe/vxlan_gpe.h>
35 #include <vnet/lisp-gpe/lisp_gpe.h>
37 #include <vpp/api/vpe_msg_enum.h>
38 #include <vnet/l2/l2_classify.h>
39 #include <vnet/l2/l2_vtr.h>
40 #include <vnet/classify/in_out_acl.h>
41 #include <vnet/classify/policer_classify.h>
42 #include <vnet/classify/flow_classify.h>
43 #include <vnet/mpls/mpls.h>
44 #include <vnet/ipsec/ipsec.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/span/span.h>
51 #include <vnet/policer/policer.h>
52 #include <vnet/policer/police.h>
53 #include <vnet/mfib/mfib_types.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
57 #include <vnet/ip/ip_types_api.h>
58 #include "vat/json_format.h"
59 #include <vnet/ip/ip_types_api.h>
60 #include <vnet/ethernet/ethernet_types_api.h>
65 #define vl_typedefs /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* declare message handlers for each api */
71 #define vl_endianfun /* define message structures */
72 #include <vpp/api/vpe_all_api_h.h>
75 /* instantiate all the print functions we know about */
76 #if VPP_API_TEST_BUILTIN == 0
77 #define vl_print(handle, ...)
79 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
82 #include <vpp/api/vpe_all_api_h.h>
85 #define __plugin_msg_base 0
86 #include <vlibapi/vat_helper_macros.h>
88 #include <vnet/format_fns.h>
90 void vl_api_set_elog_main (elog_main_t * m);
91 int vl_api_set_elog_trace_api_messages (int enable);
93 #if VPP_API_TEST_BUILTIN == 0
103 vat_socket_connect (vat_main_t * vam)
106 vam->socket_client_main = &socket_client_main;
107 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
109 0 /* default socket rx, tx buffer */ )))
111 /* vpp expects the client index in network order */
112 vam->my_client_index = htonl (socket_client_main.client_index);
115 #else /* vpp built-in case, we don't do sockets... */
117 vat_socket_connect (vat_main_t * vam)
123 vl_socket_client_read (int wait)
129 vl_socket_client_write ()
135 vl_socket_client_msg_alloc (int nbytes)
143 vat_time_now (vat_main_t * vam)
145 #if VPP_API_TEST_BUILTIN
146 return vlib_time_now (vam->vlib_main);
148 return clib_time_now (&vam->clib_time);
153 errmsg (char *fmt, ...)
155 vat_main_t *vam = &vat_main;
160 s = va_format (0, fmt, &va);
165 #if VPP_API_TEST_BUILTIN
166 vlib_cli_output (vam->vlib_main, (char *) s);
169 if (vam->ifp != stdin)
170 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
171 vam->input_line_number);
173 fformat (vam->ofp, "%s\n", (char *) s);
181 #if VPP_API_TEST_BUILTIN == 0
183 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
185 vat_main_t *vam = va_arg (*args, vat_main_t *);
186 u32 *result = va_arg (*args, u32 *);
190 if (!unformat (input, "%s", &if_name))
193 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
201 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
206 /* Parse an IP4 address %d.%d.%d.%d. */
208 unformat_ip4_address (unformat_input_t * input, va_list * args)
210 u8 *result = va_arg (*args, u8 *);
213 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
216 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
228 unformat_ethernet_address (unformat_input_t * input, va_list * args)
230 u8 *result = va_arg (*args, u8 *);
233 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
234 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
238 for (i = 0; i < 6; i++)
239 if (a[i] >= (1 << 8))
242 for (i = 0; i < 6; i++)
248 /* Returns ethernet type as an int in host byte order. */
250 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
253 u16 *result = va_arg (*args, u16 *);
257 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
259 if (type >= (1 << 16))
267 /* Parse an IP6 address. */
269 unformat_ip6_address (unformat_input_t * input, va_list * args)
271 ip6_address_t *result = va_arg (*args, ip6_address_t *);
273 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
274 uword c, n_colon, double_colon_index;
276 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
277 double_colon_index = ARRAY_LEN (hex_quads);
278 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
281 if (c >= '0' && c <= '9')
283 else if (c >= 'a' && c <= 'f')
284 hex_digit = c + 10 - 'a';
285 else if (c >= 'A' && c <= 'F')
286 hex_digit = c + 10 - 'A';
287 else if (c == ':' && n_colon < 2)
291 unformat_put_input (input);
295 /* Too many hex quads. */
296 if (n_hex_quads >= ARRAY_LEN (hex_quads))
301 hex_quad = (hex_quad << 4) | hex_digit;
303 /* Hex quad must fit in 16 bits. */
304 if (n_hex_digits >= 4)
311 /* Save position of :: */
314 /* More than one :: ? */
315 if (double_colon_index < ARRAY_LEN (hex_quads))
317 double_colon_index = n_hex_quads;
320 if (n_colon > 0 && n_hex_digits > 0)
322 hex_quads[n_hex_quads++] = hex_quad;
328 if (n_hex_digits > 0)
329 hex_quads[n_hex_quads++] = hex_quad;
334 /* Expand :: to appropriate number of zero hex quads. */
335 if (double_colon_index < ARRAY_LEN (hex_quads))
337 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
339 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
340 hex_quads[n_zero + i] = hex_quads[i];
342 for (i = 0; i < n_zero; i++)
343 hex_quads[double_colon_index + i] = 0;
345 n_hex_quads = ARRAY_LEN (hex_quads);
348 /* Too few hex quads given. */
349 if (n_hex_quads < ARRAY_LEN (hex_quads))
352 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
353 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
360 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
362 u32 *r = va_arg (*args, u32 *);
365 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
366 foreach_ipsec_policy_action
374 format_ipsec_crypto_alg (u8 * s, va_list * args)
376 u32 i = va_arg (*args, u32);
381 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
382 foreach_ipsec_crypto_alg
385 return format (s, "unknown");
387 return format (s, "%s", t);
391 format_ipsec_integ_alg (u8 * s, va_list * args)
393 u32 i = va_arg (*args, u32);
398 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
399 foreach_ipsec_integ_alg
402 return format (s, "unknown");
404 return format (s, "%s", t);
407 #else /* VPP_API_TEST_BUILTIN == 1 */
409 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
411 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
412 vnet_main_t *vnm = vnet_get_main ();
413 u32 *result = va_arg (*args, u32 *);
415 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
419 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
421 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
422 vnet_main_t *vnm = vnet_get_main ();
423 u32 *result = va_arg (*args, u32 *);
425 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
428 #endif /* VPP_API_TEST_BUILTIN */
431 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
433 u32 *r = va_arg (*args, u32 *);
436 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
437 foreach_ipsec_crypto_alg
445 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
447 u32 *r = va_arg (*args, u32 *);
450 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
451 foreach_ipsec_integ_alg
459 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
461 u8 *r = va_arg (*args, u8 *);
463 if (unformat (input, "kbps"))
464 *r = SSE2_QOS_RATE_KBPS;
465 else if (unformat (input, "pps"))
466 *r = SSE2_QOS_RATE_PPS;
473 unformat_policer_round_type (unformat_input_t * input, va_list * args)
475 u8 *r = va_arg (*args, u8 *);
477 if (unformat (input, "closest"))
478 *r = SSE2_QOS_ROUND_TO_CLOSEST;
479 else if (unformat (input, "up"))
480 *r = SSE2_QOS_ROUND_TO_UP;
481 else if (unformat (input, "down"))
482 *r = SSE2_QOS_ROUND_TO_DOWN;
489 unformat_policer_type (unformat_input_t * input, va_list * args)
491 u8 *r = va_arg (*args, u8 *);
493 if (unformat (input, "1r2c"))
494 *r = SSE2_QOS_POLICER_TYPE_1R2C;
495 else if (unformat (input, "1r3c"))
496 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
497 else if (unformat (input, "2r3c-2698"))
498 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
499 else if (unformat (input, "2r3c-4115"))
500 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
501 else if (unformat (input, "2r3c-mef5cf1"))
502 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
509 unformat_dscp (unformat_input_t * input, va_list * va)
511 u8 *r = va_arg (*va, u8 *);
514 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
523 unformat_policer_action_type (unformat_input_t * input, va_list * va)
525 sse2_qos_pol_action_params_st *a
526 = va_arg (*va, sse2_qos_pol_action_params_st *);
528 if (unformat (input, "drop"))
529 a->action_type = SSE2_QOS_ACTION_DROP;
530 else if (unformat (input, "transmit"))
531 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
532 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
533 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
540 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
542 u32 *r = va_arg (*va, u32 *);
545 if (unformat (input, "ip4"))
546 tid = POLICER_CLASSIFY_TABLE_IP4;
547 else if (unformat (input, "ip6"))
548 tid = POLICER_CLASSIFY_TABLE_IP6;
549 else if (unformat (input, "l2"))
550 tid = POLICER_CLASSIFY_TABLE_L2;
559 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
561 u32 *r = va_arg (*va, u32 *);
564 if (unformat (input, "ip4"))
565 tid = FLOW_CLASSIFY_TABLE_IP4;
566 else if (unformat (input, "ip6"))
567 tid = FLOW_CLASSIFY_TABLE_IP6;
575 #if (VPP_API_TEST_BUILTIN==0)
577 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
578 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
579 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
580 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
583 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
585 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
586 mfib_itf_attribute_t attr;
589 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
591 if (unformat (input, mfib_itf_flag_long_names[attr]))
592 *iflags |= (1 << attr);
594 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
596 if (unformat (input, mfib_itf_flag_names[attr]))
597 *iflags |= (1 << attr);
600 return (old == *iflags ? 0 : 1);
604 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
606 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
607 mfib_entry_attribute_t attr;
610 FOR_EACH_MFIB_ATTRIBUTE (attr)
612 if (unformat (input, mfib_flag_long_names[attr]))
613 *eflags |= (1 << attr);
615 FOR_EACH_MFIB_ATTRIBUTE (attr)
617 if (unformat (input, mfib_flag_names[attr]))
618 *eflags |= (1 << attr);
621 return (old == *eflags ? 0 : 1);
625 format_ip4_address (u8 * s, va_list * args)
627 u8 *a = va_arg (*args, u8 *);
628 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
632 format_ip6_address (u8 * s, va_list * args)
634 ip6_address_t *a = va_arg (*args, ip6_address_t *);
635 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
637 i_max_n_zero = ARRAY_LEN (a->as_u16);
639 i_first_zero = i_max_n_zero;
641 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
643 u32 is_zero = a->as_u16[i] == 0;
644 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
650 if ((!is_zero && n_zeros > max_n_zeros)
651 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
653 i_max_n_zero = i_first_zero;
654 max_n_zeros = n_zeros;
655 i_first_zero = ARRAY_LEN (a->as_u16);
660 last_double_colon = 0;
661 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
663 if (i == i_max_n_zero && max_n_zeros > 1)
665 s = format (s, "::");
666 i += max_n_zeros - 1;
667 last_double_colon = 1;
671 s = format (s, "%s%x",
672 (last_double_colon || i == 0) ? "" : ":",
673 clib_net_to_host_u16 (a->as_u16[i]));
674 last_double_colon = 0;
681 /* Format an IP46 address. */
683 format_ip46_address (u8 * s, va_list * args)
685 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
686 ip46_type_t type = va_arg (*args, ip46_type_t);
692 is_ip4 = ip46_address_is_ip4 (ip46);
703 format (s, "%U", format_ip4_address, &ip46->ip4) :
704 format (s, "%U", format_ip6_address, &ip46->ip6);
708 format_ethernet_address (u8 * s, va_list * args)
710 u8 *a = va_arg (*args, u8 *);
712 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
713 a[0], a[1], a[2], a[3], a[4], a[5]);
718 increment_v4_address (vl_api_ip4_address_t * i)
720 ip4_address_t *a = (ip4_address_t *) i;
723 v = ntohl (a->as_u32) + 1;
724 a->as_u32 = ntohl (v);
728 increment_v6_address (vl_api_ip6_address_t * i)
730 ip6_address_t *a = (ip6_address_t *) i;
733 v0 = clib_net_to_host_u64 (a->as_u64[0]);
734 v1 = clib_net_to_host_u64 (a->as_u64[1]);
739 a->as_u64[0] = clib_net_to_host_u64 (v0);
740 a->as_u64[1] = clib_net_to_host_u64 (v1);
744 increment_address (vl_api_address_t * a)
746 if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
747 increment_v4_address (&a->un.ip4);
748 else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
749 increment_v6_address (&a->un.ip6);
753 set_ip4_address (vl_api_address_t * a, u32 v)
755 if (a->af == ADDRESS_IP4)
757 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
763 increment_mac_address (u8 * mac)
765 u64 tmp = *((u64 *) mac);
766 tmp = clib_net_to_host_u64 (tmp);
767 tmp += 1 << 16; /* skip unused (least significant) octets */
768 tmp = clib_host_to_net_u64 (tmp);
770 clib_memcpy (mac, &tmp, 6);
774 vat_json_object_add_address (vat_json_node_t * node,
775 const char *str, const vl_api_address_t * addr)
777 if (ADDRESS_IP6 == addr->af)
781 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
782 vat_json_object_add_ip6 (node, str, ip6);
788 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
789 vat_json_object_add_ip4 (node, str, ip4);
794 vat_json_object_add_prefix (vat_json_node_t * node,
795 const vl_api_prefix_t * prefix)
797 vat_json_object_add_uint (node, "len", prefix->len);
798 vat_json_object_add_address (node, "address", &prefix->address);
801 static void vl_api_create_loopback_reply_t_handler
802 (vl_api_create_loopback_reply_t * mp)
804 vat_main_t *vam = &vat_main;
805 i32 retval = ntohl (mp->retval);
807 vam->retval = retval;
808 vam->regenerate_interface_table = 1;
809 vam->sw_if_index = ntohl (mp->sw_if_index);
810 vam->result_ready = 1;
813 static void vl_api_create_loopback_reply_t_handler_json
814 (vl_api_create_loopback_reply_t * mp)
816 vat_main_t *vam = &vat_main;
817 vat_json_node_t node;
819 vat_json_init_object (&node);
820 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
821 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
823 vat_json_print (vam->ofp, &node);
824 vat_json_free (&node);
825 vam->retval = ntohl (mp->retval);
826 vam->result_ready = 1;
829 static void vl_api_create_loopback_instance_reply_t_handler
830 (vl_api_create_loopback_instance_reply_t * mp)
832 vat_main_t *vam = &vat_main;
833 i32 retval = ntohl (mp->retval);
835 vam->retval = retval;
836 vam->regenerate_interface_table = 1;
837 vam->sw_if_index = ntohl (mp->sw_if_index);
838 vam->result_ready = 1;
841 static void vl_api_create_loopback_instance_reply_t_handler_json
842 (vl_api_create_loopback_instance_reply_t * mp)
844 vat_main_t *vam = &vat_main;
845 vat_json_node_t node;
847 vat_json_init_object (&node);
848 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
849 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
851 vat_json_print (vam->ofp, &node);
852 vat_json_free (&node);
853 vam->retval = ntohl (mp->retval);
854 vam->result_ready = 1;
857 static void vl_api_af_packet_create_reply_t_handler
858 (vl_api_af_packet_create_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 i32 retval = ntohl (mp->retval);
863 vam->retval = retval;
864 vam->regenerate_interface_table = 1;
865 vam->sw_if_index = ntohl (mp->sw_if_index);
866 vam->result_ready = 1;
869 static void vl_api_af_packet_create_reply_t_handler_json
870 (vl_api_af_packet_create_reply_t * mp)
872 vat_main_t *vam = &vat_main;
873 vat_json_node_t node;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
879 vat_json_print (vam->ofp, &node);
880 vat_json_free (&node);
882 vam->retval = ntohl (mp->retval);
883 vam->result_ready = 1;
886 static void vl_api_create_vlan_subif_reply_t_handler
887 (vl_api_create_vlan_subif_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 i32 retval = ntohl (mp->retval);
892 vam->retval = retval;
893 vam->regenerate_interface_table = 1;
894 vam->sw_if_index = ntohl (mp->sw_if_index);
895 vam->result_ready = 1;
898 static void vl_api_create_vlan_subif_reply_t_handler_json
899 (vl_api_create_vlan_subif_reply_t * mp)
901 vat_main_t *vam = &vat_main;
902 vat_json_node_t node;
904 vat_json_init_object (&node);
905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
906 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
908 vat_json_print (vam->ofp, &node);
909 vat_json_free (&node);
911 vam->retval = ntohl (mp->retval);
912 vam->result_ready = 1;
915 static void vl_api_create_subif_reply_t_handler
916 (vl_api_create_subif_reply_t * mp)
918 vat_main_t *vam = &vat_main;
919 i32 retval = ntohl (mp->retval);
921 vam->retval = retval;
922 vam->regenerate_interface_table = 1;
923 vam->sw_if_index = ntohl (mp->sw_if_index);
924 vam->result_ready = 1;
927 static void vl_api_create_subif_reply_t_handler_json
928 (vl_api_create_subif_reply_t * mp)
930 vat_main_t *vam = &vat_main;
931 vat_json_node_t node;
933 vat_json_init_object (&node);
934 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
935 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
937 vat_json_print (vam->ofp, &node);
938 vat_json_free (&node);
940 vam->retval = ntohl (mp->retval);
941 vam->result_ready = 1;
944 static void vl_api_interface_name_renumber_reply_t_handler
945 (vl_api_interface_name_renumber_reply_t * mp)
947 vat_main_t *vam = &vat_main;
948 i32 retval = ntohl (mp->retval);
950 vam->retval = retval;
951 vam->regenerate_interface_table = 1;
952 vam->result_ready = 1;
955 static void vl_api_interface_name_renumber_reply_t_handler_json
956 (vl_api_interface_name_renumber_reply_t * mp)
958 vat_main_t *vam = &vat_main;
959 vat_json_node_t node;
961 vat_json_init_object (&node);
962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
964 vat_json_print (vam->ofp, &node);
965 vat_json_free (&node);
967 vam->retval = ntohl (mp->retval);
968 vam->result_ready = 1;
972 * Special-case: build the interface table, maintain
973 * the next loopback sw_if_index vbl.
975 static void vl_api_sw_interface_details_t_handler
976 (vl_api_sw_interface_details_t * mp)
978 vat_main_t *vam = &vat_main;
979 u8 *s = format (0, "%s%c", mp->interface_name, 0);
981 hash_set_mem (vam->sw_if_index_by_interface_name, s,
982 ntohl (mp->sw_if_index));
984 /* In sub interface case, fill the sub interface table entry */
985 if (mp->sw_if_index != mp->sup_sw_if_index)
987 sw_interface_subif_t *sub = NULL;
989 vec_add2 (vam->sw_if_subif_table, sub, 1);
991 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
992 strncpy ((char *) sub->interface_name, (char *) s,
993 vec_len (sub->interface_name));
994 sub->sw_if_index = ntohl (mp->sw_if_index);
995 sub->sub_id = ntohl (mp->sub_id);
997 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
999 sub->sub_number_of_tags = mp->sub_number_of_tags;
1000 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1001 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1003 /* vlan tag rewrite */
1004 sub->vtr_op = ntohl (mp->vtr_op);
1005 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1006 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1007 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1011 static void vl_api_sw_interface_details_t_handler_json
1012 (vl_api_sw_interface_details_t * mp)
1014 vat_main_t *vam = &vat_main;
1015 vat_json_node_t *node = NULL;
1017 if (VAT_JSON_ARRAY != vam->json_tree.type)
1019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1020 vat_json_init_array (&vam->json_tree);
1022 node = vat_json_array_add (&vam->json_tree);
1024 vat_json_init_object (node);
1025 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1026 vat_json_object_add_uint (node, "sup_sw_if_index",
1027 ntohl (mp->sup_sw_if_index));
1028 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1029 sizeof (mp->l2_address));
1030 vat_json_object_add_string_copy (node, "interface_name",
1031 mp->interface_name);
1032 vat_json_object_add_string_copy (node, "interface_dev_type",
1033 mp->interface_dev_type);
1034 vat_json_object_add_uint (node, "flags", mp->flags);
1035 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1036 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1037 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1038 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1039 vat_json_object_add_uint (node, "sub_number_of_tags",
1040 mp->sub_number_of_tags);
1041 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1042 ntohs (mp->sub_outer_vlan_id));
1043 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1044 ntohs (mp->sub_inner_vlan_id));
1045 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1046 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1047 vat_json_object_add_uint (node, "vtr_push_dot1q",
1048 ntohl (mp->vtr_push_dot1q));
1049 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1050 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1051 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1053 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1055 format_ethernet_address,
1057 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1059 format_ethernet_address,
1061 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1062 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1066 #if VPP_API_TEST_BUILTIN == 0
1067 static void vl_api_sw_interface_event_t_handler
1068 (vl_api_sw_interface_event_t * mp)
1070 vat_main_t *vam = &vat_main;
1071 if (vam->interface_event_display)
1072 errmsg ("interface flags: sw_if_index %d %s %s",
1073 ntohl (mp->sw_if_index),
1074 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1075 "admin-up" : "admin-down",
1076 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1077 "link-up" : "link-down");
1081 __clib_unused static void
1082 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1084 /* JSON output not supported */
1088 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1090 vat_main_t *vam = &vat_main;
1091 i32 retval = ntohl (mp->retval);
1093 vam->retval = retval;
1094 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1095 vam->result_ready = 1;
1099 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1101 vat_main_t *vam = &vat_main;
1102 vat_json_node_t node;
1106 vat_json_init_object (&node);
1107 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1108 vat_json_object_add_uint (&node, "reply_in_shmem",
1109 ntohl (mp->reply_in_shmem));
1110 /* Toss the shared-memory original... */
1111 oldheap = vl_msg_push_heap ();
1113 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1116 vl_msg_pop_heap (oldheap);
1118 vat_json_print (vam->ofp, &node);
1119 vat_json_free (&node);
1121 vam->retval = ntohl (mp->retval);
1122 vam->result_ready = 1;
1126 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1128 vat_main_t *vam = &vat_main;
1129 i32 retval = ntohl (mp->retval);
1130 u32 length = vl_api_string_len (&mp->reply);
1132 vec_reset_length (vam->cmd_reply);
1134 vam->retval = retval;
1137 vec_validate (vam->cmd_reply, length);
1138 clib_memcpy ((char *) (vam->cmd_reply),
1139 vl_api_from_api_string (&mp->reply), length);
1140 vam->cmd_reply[length] = 0;
1142 vam->result_ready = 1;
1146 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1148 vat_main_t *vam = &vat_main;
1149 vat_json_node_t node;
1151 vec_reset_length (vam->cmd_reply);
1153 vat_json_init_object (&node);
1154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1155 vat_json_object_add_string_copy (&node, "reply",
1156 vl_api_from_api_string (&mp->reply));
1158 vat_json_print (vam->ofp, &node);
1159 vat_json_free (&node);
1161 vam->retval = ntohl (mp->retval);
1162 vam->result_ready = 1;
1165 static void vl_api_classify_add_del_table_reply_t_handler
1166 (vl_api_classify_add_del_table_reply_t * mp)
1168 vat_main_t *vam = &vat_main;
1169 i32 retval = ntohl (mp->retval);
1170 if (vam->async_mode)
1172 vam->async_errors += (retval < 0);
1176 vam->retval = retval;
1178 ((mp->new_table_index != 0xFFFFFFFF) ||
1179 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1180 (mp->match_n_vectors != 0xFFFFFFFF)))
1182 * Note: this is just barely thread-safe, depends on
1183 * the main thread spinning waiting for an answer...
1185 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1186 ntohl (mp->new_table_index),
1187 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1188 vam->result_ready = 1;
1192 static void vl_api_classify_add_del_table_reply_t_handler_json
1193 (vl_api_classify_add_del_table_reply_t * mp)
1195 vat_main_t *vam = &vat_main;
1196 vat_json_node_t node;
1198 vat_json_init_object (&node);
1199 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1200 vat_json_object_add_uint (&node, "new_table_index",
1201 ntohl (mp->new_table_index));
1202 vat_json_object_add_uint (&node, "skip_n_vectors",
1203 ntohl (mp->skip_n_vectors));
1204 vat_json_object_add_uint (&node, "match_n_vectors",
1205 ntohl (mp->match_n_vectors));
1207 vat_json_print (vam->ofp, &node);
1208 vat_json_free (&node);
1210 vam->retval = ntohl (mp->retval);
1211 vam->result_ready = 1;
1214 static void vl_api_get_node_index_reply_t_handler
1215 (vl_api_get_node_index_reply_t * mp)
1217 vat_main_t *vam = &vat_main;
1218 i32 retval = ntohl (mp->retval);
1219 if (vam->async_mode)
1221 vam->async_errors += (retval < 0);
1225 vam->retval = retval;
1227 errmsg ("node index %d", ntohl (mp->node_index));
1228 vam->result_ready = 1;
1232 static void vl_api_get_node_index_reply_t_handler_json
1233 (vl_api_get_node_index_reply_t * mp)
1235 vat_main_t *vam = &vat_main;
1236 vat_json_node_t node;
1238 vat_json_init_object (&node);
1239 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1240 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1242 vat_json_print (vam->ofp, &node);
1243 vat_json_free (&node);
1245 vam->retval = ntohl (mp->retval);
1246 vam->result_ready = 1;
1249 static void vl_api_get_next_index_reply_t_handler
1250 (vl_api_get_next_index_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1254 if (vam->async_mode)
1256 vam->async_errors += (retval < 0);
1260 vam->retval = retval;
1262 errmsg ("next node index %d", ntohl (mp->next_index));
1263 vam->result_ready = 1;
1267 static void vl_api_get_next_index_reply_t_handler_json
1268 (vl_api_get_next_index_reply_t * mp)
1270 vat_main_t *vam = &vat_main;
1271 vat_json_node_t node;
1273 vat_json_init_object (&node);
1274 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1275 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1277 vat_json_print (vam->ofp, &node);
1278 vat_json_free (&node);
1280 vam->retval = ntohl (mp->retval);
1281 vam->result_ready = 1;
1284 static void vl_api_add_node_next_reply_t_handler
1285 (vl_api_add_node_next_reply_t * mp)
1287 vat_main_t *vam = &vat_main;
1288 i32 retval = ntohl (mp->retval);
1289 if (vam->async_mode)
1291 vam->async_errors += (retval < 0);
1295 vam->retval = retval;
1297 errmsg ("next index %d", ntohl (mp->next_index));
1298 vam->result_ready = 1;
1302 static void vl_api_add_node_next_reply_t_handler_json
1303 (vl_api_add_node_next_reply_t * mp)
1305 vat_main_t *vam = &vat_main;
1306 vat_json_node_t node;
1308 vat_json_init_object (&node);
1309 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1310 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1312 vat_json_print (vam->ofp, &node);
1313 vat_json_free (&node);
1315 vam->retval = ntohl (mp->retval);
1316 vam->result_ready = 1;
1319 static void vl_api_show_version_reply_t_handler
1320 (vl_api_show_version_reply_t * mp)
1322 vat_main_t *vam = &vat_main;
1323 i32 retval = ntohl (mp->retval);
1327 errmsg (" program: %s", mp->program);
1328 errmsg (" version: %s", mp->version);
1329 errmsg (" build date: %s", mp->build_date);
1330 errmsg ("build directory: %s", mp->build_directory);
1332 vam->retval = retval;
1333 vam->result_ready = 1;
1336 static void vl_api_show_version_reply_t_handler_json
1337 (vl_api_show_version_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 vat_json_node_t node;
1342 vat_json_init_object (&node);
1343 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1344 vat_json_object_add_string_copy (&node, "program", mp->program);
1345 vat_json_object_add_string_copy (&node, "version", mp->version);
1346 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1347 vat_json_object_add_string_copy (&node, "build_directory",
1348 mp->build_directory);
1350 vat_json_print (vam->ofp, &node);
1351 vat_json_free (&node);
1353 vam->retval = ntohl (mp->retval);
1354 vam->result_ready = 1;
1357 static void vl_api_show_threads_reply_t_handler
1358 (vl_api_show_threads_reply_t * mp)
1360 vat_main_t *vam = &vat_main;
1361 i32 retval = ntohl (mp->retval);
1365 count = ntohl (mp->count);
1367 for (i = 0; i < count; i++)
1369 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1370 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1371 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1372 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1373 ntohl (mp->thread_data[i].cpu_socket));
1375 vam->retval = retval;
1376 vam->result_ready = 1;
1379 static void vl_api_show_threads_reply_t_handler_json
1380 (vl_api_show_threads_reply_t * mp)
1382 vat_main_t *vam = &vat_main;
1383 vat_json_node_t node;
1384 vl_api_thread_data_t *td;
1385 i32 retval = ntohl (mp->retval);
1389 count = ntohl (mp->count);
1391 vat_json_init_object (&node);
1392 vat_json_object_add_int (&node, "retval", retval);
1393 vat_json_object_add_uint (&node, "count", count);
1395 for (i = 0; i < count; i++)
1397 td = &mp->thread_data[i];
1398 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1399 vat_json_object_add_string_copy (&node, "name", td->name);
1400 vat_json_object_add_string_copy (&node, "type", td->type);
1401 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1402 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1403 vat_json_object_add_int (&node, "core", ntohl (td->id));
1404 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1407 vat_json_print (vam->ofp, &node);
1408 vat_json_free (&node);
1410 vam->retval = retval;
1411 vam->result_ready = 1;
1415 api_show_threads (vat_main_t * vam)
1417 vl_api_show_threads_t *mp;
1421 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1422 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1424 M (SHOW_THREADS, mp);
1432 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1434 u32 n_macs = ntohl (mp->n_macs);
1435 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1436 ntohl (mp->pid), mp->client_index, n_macs);
1438 for (i = 0; i < n_macs; i++)
1440 vl_api_mac_entry_t *mac = &mp->mac[i];
1441 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1442 i + 1, ntohl (mac->sw_if_index),
1443 format_ethernet_address, mac->mac_addr, mac->action);
1450 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1452 /* JSON output not supported */
1455 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1456 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1459 * Special-case: build the bridge domain table, maintain
1460 * the next bd id vbl.
1462 static void vl_api_bridge_domain_details_t_handler
1463 (vl_api_bridge_domain_details_t * mp)
1465 vat_main_t *vam = &vat_main;
1466 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1469 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1470 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1472 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1473 ntohl (mp->bd_id), mp->learn, mp->forward,
1474 mp->flood, ntohl (mp->bvi_sw_if_index),
1475 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1479 vl_api_bridge_domain_sw_if_t *sw_ifs;
1480 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1483 sw_ifs = mp->sw_if_details;
1484 for (i = 0; i < n_sw_ifs; i++)
1490 sw_if_index = ntohl (sw_ifs->sw_if_index);
1493 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1495 if ((u32) p->value[0] == sw_if_index)
1497 sw_if_name = (u8 *)(p->key);
1502 print (vam->ofp, "%7d %3d %s", sw_if_index,
1503 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1504 "sw_if_index not found!");
1511 static void vl_api_bridge_domain_details_t_handler_json
1512 (vl_api_bridge_domain_details_t * mp)
1514 vat_main_t *vam = &vat_main;
1515 vat_json_node_t *node, *array = NULL;
1516 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1518 if (VAT_JSON_ARRAY != vam->json_tree.type)
1520 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1521 vat_json_init_array (&vam->json_tree);
1523 node = vat_json_array_add (&vam->json_tree);
1525 vat_json_init_object (node);
1526 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1527 vat_json_object_add_uint (node, "flood", mp->flood);
1528 vat_json_object_add_uint (node, "forward", mp->forward);
1529 vat_json_object_add_uint (node, "learn", mp->learn);
1530 vat_json_object_add_uint (node, "bvi_sw_if_index",
1531 ntohl (mp->bvi_sw_if_index));
1532 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1533 array = vat_json_object_add (node, "sw_if");
1534 vat_json_init_array (array);
1540 vl_api_bridge_domain_sw_if_t *sw_ifs;
1543 sw_ifs = mp->sw_if_details;
1544 for (i = 0; i < n_sw_ifs; i++)
1546 node = vat_json_array_add (array);
1547 vat_json_init_object (node);
1548 vat_json_object_add_uint (node, "sw_if_index",
1549 ntohl (sw_ifs->sw_if_index));
1550 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1556 static void vl_api_control_ping_reply_t_handler
1557 (vl_api_control_ping_reply_t * mp)
1559 vat_main_t *vam = &vat_main;
1560 i32 retval = ntohl (mp->retval);
1561 if (vam->async_mode)
1563 vam->async_errors += (retval < 0);
1567 vam->retval = retval;
1568 vam->result_ready = 1;
1570 if (vam->socket_client_main)
1571 vam->socket_client_main->control_pings_outstanding--;
1574 static void vl_api_control_ping_reply_t_handler_json
1575 (vl_api_control_ping_reply_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 i32 retval = ntohl (mp->retval);
1580 if (VAT_JSON_NONE != vam->json_tree.type)
1582 vat_json_print (vam->ofp, &vam->json_tree);
1583 vat_json_free (&vam->json_tree);
1584 vam->json_tree.type = VAT_JSON_NONE;
1589 vat_json_init_array (&vam->json_tree);
1590 vat_json_print (vam->ofp, &vam->json_tree);
1591 vam->json_tree.type = VAT_JSON_NONE;
1594 vam->retval = retval;
1595 vam->result_ready = 1;
1599 vl_api_bridge_domain_set_mac_age_reply_t_handler
1600 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1602 vat_main_t *vam = &vat_main;
1603 i32 retval = ntohl (mp->retval);
1604 if (vam->async_mode)
1606 vam->async_errors += (retval < 0);
1610 vam->retval = retval;
1611 vam->result_ready = 1;
1615 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1616 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1618 vat_main_t *vam = &vat_main;
1619 vat_json_node_t node;
1621 vat_json_init_object (&node);
1622 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1624 vat_json_print (vam->ofp, &node);
1625 vat_json_free (&node);
1627 vam->retval = ntohl (mp->retval);
1628 vam->result_ready = 1;
1632 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1634 vat_main_t *vam = &vat_main;
1635 i32 retval = ntohl (mp->retval);
1636 if (vam->async_mode)
1638 vam->async_errors += (retval < 0);
1642 vam->retval = retval;
1643 vam->result_ready = 1;
1647 static void vl_api_l2_flags_reply_t_handler_json
1648 (vl_api_l2_flags_reply_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 vat_json_node_t node;
1653 vat_json_init_object (&node);
1654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1656 ntohl (mp->resulting_feature_bitmap));
1658 vat_json_print (vam->ofp, &node);
1659 vat_json_free (&node);
1661 vam->retval = ntohl (mp->retval);
1662 vam->result_ready = 1;
1665 static void vl_api_bridge_flags_reply_t_handler
1666 (vl_api_bridge_flags_reply_t * mp)
1668 vat_main_t *vam = &vat_main;
1669 i32 retval = ntohl (mp->retval);
1670 if (vam->async_mode)
1672 vam->async_errors += (retval < 0);
1676 vam->retval = retval;
1677 vam->result_ready = 1;
1681 static void vl_api_bridge_flags_reply_t_handler_json
1682 (vl_api_bridge_flags_reply_t * mp)
1684 vat_main_t *vam = &vat_main;
1685 vat_json_node_t node;
1687 vat_json_init_object (&node);
1688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1689 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1690 ntohl (mp->resulting_feature_bitmap));
1692 vat_json_print (vam->ofp, &node);
1693 vat_json_free (&node);
1695 vam->retval = ntohl (mp->retval);
1696 vam->result_ready = 1;
1700 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1702 vat_main_t *vam = &vat_main;
1703 i32 retval = ntohl (mp->retval);
1704 if (vam->async_mode)
1706 vam->async_errors += (retval < 0);
1710 vam->retval = retval;
1711 vam->sw_if_index = ntohl (mp->sw_if_index);
1712 vam->result_ready = 1;
1717 static void vl_api_tap_create_v2_reply_t_handler_json
1718 (vl_api_tap_create_v2_reply_t * mp)
1720 vat_main_t *vam = &vat_main;
1721 vat_json_node_t node;
1723 vat_json_init_object (&node);
1724 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1725 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1727 vat_json_print (vam->ofp, &node);
1728 vat_json_free (&node);
1730 vam->retval = ntohl (mp->retval);
1731 vam->result_ready = 1;
1736 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1738 vat_main_t *vam = &vat_main;
1739 i32 retval = ntohl (mp->retval);
1740 if (vam->async_mode)
1742 vam->async_errors += (retval < 0);
1746 vam->retval = retval;
1747 vam->result_ready = 1;
1751 static void vl_api_tap_delete_v2_reply_t_handler_json
1752 (vl_api_tap_delete_v2_reply_t * mp)
1754 vat_main_t *vam = &vat_main;
1755 vat_json_node_t node;
1757 vat_json_init_object (&node);
1758 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1760 vat_json_print (vam->ofp, &node);
1761 vat_json_free (&node);
1763 vam->retval = ntohl (mp->retval);
1764 vam->result_ready = 1;
1768 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1771 vat_main_t *vam = &vat_main;
1772 i32 retval = ntohl (mp->retval);
1773 if (vam->async_mode)
1775 vam->async_errors += (retval < 0);
1779 vam->retval = retval;
1780 vam->sw_if_index = ntohl (mp->sw_if_index);
1781 vam->result_ready = 1;
1785 static void vl_api_virtio_pci_create_reply_t_handler_json
1786 (vl_api_virtio_pci_create_reply_t * mp)
1788 vat_main_t *vam = &vat_main;
1789 vat_json_node_t node;
1791 vat_json_init_object (&node);
1792 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1793 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1795 vat_json_print (vam->ofp, &node);
1796 vat_json_free (&node);
1798 vam->retval = ntohl (mp->retval);
1799 vam->result_ready = 1;
1804 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1807 vat_main_t *vam = &vat_main;
1808 i32 retval = ntohl (mp->retval);
1809 if (vam->async_mode)
1811 vam->async_errors += (retval < 0);
1815 vam->retval = retval;
1816 vam->result_ready = 1;
1820 static void vl_api_virtio_pci_delete_reply_t_handler_json
1821 (vl_api_virtio_pci_delete_reply_t * mp)
1823 vat_main_t *vam = &vat_main;
1824 vat_json_node_t node;
1826 vat_json_init_object (&node);
1827 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1829 vat_json_print (vam->ofp, &node);
1830 vat_json_free (&node);
1832 vam->retval = ntohl (mp->retval);
1833 vam->result_ready = 1;
1837 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1839 vat_main_t *vam = &vat_main;
1840 i32 retval = ntohl (mp->retval);
1842 if (vam->async_mode)
1844 vam->async_errors += (retval < 0);
1848 vam->retval = retval;
1849 vam->sw_if_index = ntohl (mp->sw_if_index);
1850 vam->result_ready = 1;
1854 static void vl_api_bond_create_reply_t_handler_json
1855 (vl_api_bond_create_reply_t * mp)
1857 vat_main_t *vam = &vat_main;
1858 vat_json_node_t node;
1860 vat_json_init_object (&node);
1861 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1862 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1864 vat_json_print (vam->ofp, &node);
1865 vat_json_free (&node);
1867 vam->retval = ntohl (mp->retval);
1868 vam->result_ready = 1;
1872 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1874 vat_main_t *vam = &vat_main;
1875 i32 retval = ntohl (mp->retval);
1877 if (vam->async_mode)
1879 vam->async_errors += (retval < 0);
1883 vam->retval = retval;
1884 vam->result_ready = 1;
1888 static void vl_api_bond_delete_reply_t_handler_json
1889 (vl_api_bond_delete_reply_t * mp)
1891 vat_main_t *vam = &vat_main;
1892 vat_json_node_t node;
1894 vat_json_init_object (&node);
1895 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1897 vat_json_print (vam->ofp, &node);
1898 vat_json_free (&node);
1900 vam->retval = ntohl (mp->retval);
1901 vam->result_ready = 1;
1905 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1907 vat_main_t *vam = &vat_main;
1908 i32 retval = ntohl (mp->retval);
1910 if (vam->async_mode)
1912 vam->async_errors += (retval < 0);
1916 vam->retval = retval;
1917 vam->result_ready = 1;
1921 static void vl_api_bond_enslave_reply_t_handler_json
1922 (vl_api_bond_enslave_reply_t * mp)
1924 vat_main_t *vam = &vat_main;
1925 vat_json_node_t node;
1927 vat_json_init_object (&node);
1928 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1930 vat_json_print (vam->ofp, &node);
1931 vat_json_free (&node);
1933 vam->retval = ntohl (mp->retval);
1934 vam->result_ready = 1;
1938 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1941 vat_main_t *vam = &vat_main;
1942 i32 retval = ntohl (mp->retval);
1944 if (vam->async_mode)
1946 vam->async_errors += (retval < 0);
1950 vam->retval = retval;
1951 vam->result_ready = 1;
1955 static void vl_api_bond_detach_slave_reply_t_handler_json
1956 (vl_api_bond_detach_slave_reply_t * mp)
1958 vat_main_t *vam = &vat_main;
1959 vat_json_node_t node;
1961 vat_json_init_object (&node);
1962 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1964 vat_json_print (vam->ofp, &node);
1965 vat_json_free (&node);
1967 vam->retval = ntohl (mp->retval);
1968 vam->result_ready = 1;
1972 api_sw_interface_set_bond_weight (vat_main_t * vam)
1974 unformat_input_t *i = vam->input;
1975 vl_api_sw_interface_set_bond_weight_t *mp;
1976 u32 sw_if_index = ~0;
1978 u8 weight_enter = 0;
1981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
1983 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
1985 else if (unformat (i, "sw_if_index %d", &sw_if_index))
1987 else if (unformat (i, "weight %u", &weight))
1993 if (sw_if_index == ~0)
1995 errmsg ("missing interface name or sw_if_index");
1998 if (weight_enter == 0)
2000 errmsg ("missing valid weight");
2004 /* Construct the API message */
2005 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2006 mp->sw_if_index = ntohl (sw_if_index);
2007 mp->weight = ntohl (weight);
2014 static void vl_api_sw_interface_bond_details_t_handler
2015 (vl_api_sw_interface_bond_details_t * mp)
2017 vat_main_t *vam = &vat_main;
2020 "%-16s %-12d %-12U %-13U %-14u %-14u",
2021 mp->interface_name, ntohl (mp->sw_if_index),
2022 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2023 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2026 static void vl_api_sw_interface_bond_details_t_handler_json
2027 (vl_api_sw_interface_bond_details_t * mp)
2029 vat_main_t *vam = &vat_main;
2030 vat_json_node_t *node = NULL;
2032 if (VAT_JSON_ARRAY != vam->json_tree.type)
2034 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2035 vat_json_init_array (&vam->json_tree);
2037 node = vat_json_array_add (&vam->json_tree);
2039 vat_json_init_object (node);
2040 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2041 vat_json_object_add_string_copy (node, "interface_name",
2042 mp->interface_name);
2043 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2044 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2045 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2046 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2050 api_sw_interface_bond_dump (vat_main_t * vam)
2052 vl_api_sw_interface_bond_dump_t *mp;
2053 vl_api_control_ping_t *mp_ping;
2057 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2058 "interface name", "sw_if_index", "mode", "load balance",
2059 "active slaves", "slaves");
2061 /* Get list of bond interfaces */
2062 M (SW_INTERFACE_BOND_DUMP, mp);
2065 /* Use a control ping for synchronization */
2066 MPING (CONTROL_PING, mp_ping);
2073 static void vl_api_sw_interface_slave_details_t_handler
2074 (vl_api_sw_interface_slave_details_t * mp)
2076 vat_main_t *vam = &vat_main;
2079 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2080 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2081 ntohl (mp->weight), mp->is_local_numa);
2084 static void vl_api_sw_interface_slave_details_t_handler_json
2085 (vl_api_sw_interface_slave_details_t * mp)
2087 vat_main_t *vam = &vat_main;
2088 vat_json_node_t *node = NULL;
2090 if (VAT_JSON_ARRAY != vam->json_tree.type)
2092 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2093 vat_json_init_array (&vam->json_tree);
2095 node = vat_json_array_add (&vam->json_tree);
2097 vat_json_init_object (node);
2098 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2099 vat_json_object_add_string_copy (node, "interface_name",
2100 mp->interface_name);
2101 vat_json_object_add_uint (node, "passive", mp->is_passive);
2102 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2103 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2104 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2108 api_sw_interface_slave_dump (vat_main_t * vam)
2110 unformat_input_t *i = vam->input;
2111 vl_api_sw_interface_slave_dump_t *mp;
2112 vl_api_control_ping_t *mp_ping;
2113 u32 sw_if_index = ~0;
2114 u8 sw_if_index_set = 0;
2117 /* Parse args required to build the message */
2118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2120 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2121 sw_if_index_set = 1;
2122 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2123 sw_if_index_set = 1;
2128 if (sw_if_index_set == 0)
2130 errmsg ("missing vpp interface name. ");
2135 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2136 "slave interface name", "sw_if_index", "passive", "long_timeout",
2137 "weight", "local numa");
2139 /* Get list of bond interfaces */
2140 M (SW_INTERFACE_SLAVE_DUMP, mp);
2141 mp->sw_if_index = ntohl (sw_if_index);
2144 /* Use a control ping for synchronization */
2145 MPING (CONTROL_PING, mp_ping);
2152 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2153 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2155 vat_main_t *vam = &vat_main;
2156 i32 retval = ntohl (mp->retval);
2157 if (vam->async_mode)
2159 vam->async_errors += (retval < 0);
2163 vam->retval = retval;
2164 vam->sw_if_index = ntohl (mp->sw_if_index);
2165 vam->result_ready = 1;
2167 vam->regenerate_interface_table = 1;
2170 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2171 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2173 vat_main_t *vam = &vat_main;
2174 vat_json_node_t node;
2176 vat_json_init_object (&node);
2177 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2178 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2179 ntohl (mp->sw_if_index));
2181 vat_json_print (vam->ofp, &node);
2182 vat_json_free (&node);
2184 vam->retval = ntohl (mp->retval);
2185 vam->result_ready = 1;
2188 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2189 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2191 vat_main_t *vam = &vat_main;
2192 i32 retval = ntohl (mp->retval);
2193 if (vam->async_mode)
2195 vam->async_errors += (retval < 0);
2199 vam->retval = retval;
2200 vam->sw_if_index = ntohl (mp->sw_if_index);
2201 vam->result_ready = 1;
2205 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2206 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2208 vat_main_t *vam = &vat_main;
2209 vat_json_node_t node;
2211 vat_json_init_object (&node);
2212 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2213 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2215 vat_json_print (vam->ofp, &node);
2216 vat_json_free (&node);
2218 vam->retval = ntohl (mp->retval);
2219 vam->result_ready = 1;
2222 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2223 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2225 vat_main_t *vam = &vat_main;
2226 i32 retval = ntohl (mp->retval);
2227 if (vam->async_mode)
2229 vam->async_errors += (retval < 0);
2233 vam->retval = retval;
2234 vam->result_ready = 1;
2238 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2239 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2241 vat_main_t *vam = &vat_main;
2242 vat_json_node_t node;
2244 vat_json_init_object (&node);
2245 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2246 vat_json_object_add_uint (&node, "fwd_entry_index",
2247 clib_net_to_host_u32 (mp->fwd_entry_index));
2249 vat_json_print (vam->ofp, &node);
2250 vat_json_free (&node);
2252 vam->retval = ntohl (mp->retval);
2253 vam->result_ready = 1;
2257 format_lisp_transport_protocol (u8 * s, va_list * args)
2259 u32 proto = va_arg (*args, u32);
2264 return format (s, "udp");
2266 return format (s, "api");
2273 static void vl_api_one_get_transport_protocol_reply_t_handler
2274 (vl_api_one_get_transport_protocol_reply_t * mp)
2276 vat_main_t *vam = &vat_main;
2277 i32 retval = ntohl (mp->retval);
2278 if (vam->async_mode)
2280 vam->async_errors += (retval < 0);
2284 u32 proto = mp->protocol;
2285 print (vam->ofp, "Transport protocol: %U",
2286 format_lisp_transport_protocol, proto);
2287 vam->retval = retval;
2288 vam->result_ready = 1;
2292 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2293 (vl_api_one_get_transport_protocol_reply_t * mp)
2295 vat_main_t *vam = &vat_main;
2296 vat_json_node_t node;
2299 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2302 vat_json_init_object (&node);
2303 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2304 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2307 vat_json_print (vam->ofp, &node);
2308 vat_json_free (&node);
2310 vam->retval = ntohl (mp->retval);
2311 vam->result_ready = 1;
2314 static void vl_api_one_add_del_locator_set_reply_t_handler
2315 (vl_api_one_add_del_locator_set_reply_t * mp)
2317 vat_main_t *vam = &vat_main;
2318 i32 retval = ntohl (mp->retval);
2319 if (vam->async_mode)
2321 vam->async_errors += (retval < 0);
2325 vam->retval = retval;
2326 vam->result_ready = 1;
2330 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2331 (vl_api_one_add_del_locator_set_reply_t * mp)
2333 vat_main_t *vam = &vat_main;
2334 vat_json_node_t node;
2336 vat_json_init_object (&node);
2337 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2338 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2340 vat_json_print (vam->ofp, &node);
2341 vat_json_free (&node);
2343 vam->retval = ntohl (mp->retval);
2344 vam->result_ready = 1;
2347 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2348 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2350 vat_main_t *vam = &vat_main;
2351 i32 retval = ntohl (mp->retval);
2352 if (vam->async_mode)
2354 vam->async_errors += (retval < 0);
2358 vam->retval = retval;
2359 vam->sw_if_index = ntohl (mp->sw_if_index);
2360 vam->result_ready = 1;
2362 vam->regenerate_interface_table = 1;
2365 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2366 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2368 vat_main_t *vam = &vat_main;
2369 vat_json_node_t node;
2371 vat_json_init_object (&node);
2372 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2373 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2375 vat_json_print (vam->ofp, &node);
2376 vat_json_free (&node);
2378 vam->retval = ntohl (mp->retval);
2379 vam->result_ready = 1;
2382 static void vl_api_vxlan_offload_rx_reply_t_handler
2383 (vl_api_vxlan_offload_rx_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 i32 retval = ntohl (mp->retval);
2387 if (vam->async_mode)
2389 vam->async_errors += (retval < 0);
2393 vam->retval = retval;
2394 vam->result_ready = 1;
2398 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2399 (vl_api_vxlan_offload_rx_reply_t * mp)
2401 vat_main_t *vam = &vat_main;
2402 vat_json_node_t node;
2404 vat_json_init_object (&node);
2405 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2407 vat_json_print (vam->ofp, &node);
2408 vat_json_free (&node);
2410 vam->retval = ntohl (mp->retval);
2411 vam->result_ready = 1;
2414 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2415 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2417 vat_main_t *vam = &vat_main;
2418 i32 retval = ntohl (mp->retval);
2419 if (vam->async_mode)
2421 vam->async_errors += (retval < 0);
2425 vam->retval = retval;
2426 vam->sw_if_index = ntohl (mp->sw_if_index);
2427 vam->result_ready = 1;
2431 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2432 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2434 vat_main_t *vam = &vat_main;
2435 vat_json_node_t node;
2437 vat_json_init_object (&node);
2438 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2439 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2441 vat_json_print (vam->ofp, &node);
2442 vat_json_free (&node);
2444 vam->retval = ntohl (mp->retval);
2445 vam->result_ready = 1;
2448 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2449 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2451 vat_main_t *vam = &vat_main;
2452 i32 retval = ntohl (mp->retval);
2453 if (vam->async_mode)
2455 vam->async_errors += (retval < 0);
2459 vam->retval = retval;
2460 vam->sw_if_index = ntohl (mp->sw_if_index);
2461 vam->result_ready = 1;
2463 vam->regenerate_interface_table = 1;
2466 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2467 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2469 vat_main_t *vam = &vat_main;
2470 vat_json_node_t node;
2472 vat_json_init_object (&node);
2473 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2474 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2476 vat_json_print (vam->ofp, &node);
2477 vat_json_free (&node);
2479 vam->retval = ntohl (mp->retval);
2480 vam->result_ready = 1;
2483 static void vl_api_gre_tunnel_add_del_reply_t_handler
2484 (vl_api_gre_tunnel_add_del_reply_t * mp)
2486 vat_main_t *vam = &vat_main;
2487 i32 retval = ntohl (mp->retval);
2488 if (vam->async_mode)
2490 vam->async_errors += (retval < 0);
2494 vam->retval = retval;
2495 vam->sw_if_index = ntohl (mp->sw_if_index);
2496 vam->result_ready = 1;
2500 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2501 (vl_api_gre_tunnel_add_del_reply_t * mp)
2503 vat_main_t *vam = &vat_main;
2504 vat_json_node_t node;
2506 vat_json_init_object (&node);
2507 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2508 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2510 vat_json_print (vam->ofp, &node);
2511 vat_json_free (&node);
2513 vam->retval = ntohl (mp->retval);
2514 vam->result_ready = 1;
2517 static void vl_api_create_vhost_user_if_reply_t_handler
2518 (vl_api_create_vhost_user_if_reply_t * mp)
2520 vat_main_t *vam = &vat_main;
2521 i32 retval = ntohl (mp->retval);
2522 if (vam->async_mode)
2524 vam->async_errors += (retval < 0);
2528 vam->retval = retval;
2529 vam->sw_if_index = ntohl (mp->sw_if_index);
2530 vam->result_ready = 1;
2532 vam->regenerate_interface_table = 1;
2535 static void vl_api_create_vhost_user_if_reply_t_handler_json
2536 (vl_api_create_vhost_user_if_reply_t * mp)
2538 vat_main_t *vam = &vat_main;
2539 vat_json_node_t node;
2541 vat_json_init_object (&node);
2542 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2543 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2545 vat_json_print (vam->ofp, &node);
2546 vat_json_free (&node);
2548 vam->retval = ntohl (mp->retval);
2549 vam->result_ready = 1;
2552 static void vl_api_ip_address_details_t_handler
2553 (vl_api_ip_address_details_t * mp)
2555 vat_main_t *vam = &vat_main;
2556 static ip_address_details_t empty_ip_address_details = { {0} };
2557 ip_address_details_t *address = NULL;
2558 ip_details_t *current_ip_details = NULL;
2559 ip_details_t *details = NULL;
2561 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2563 if (!details || vam->current_sw_if_index >= vec_len (details)
2564 || !details[vam->current_sw_if_index].present)
2566 errmsg ("ip address details arrived but not stored");
2567 errmsg ("ip_dump should be called first");
2571 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2573 #define addresses (current_ip_details->addr)
2575 vec_validate_init_empty (addresses, vec_len (addresses),
2576 empty_ip_address_details);
2578 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2580 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2581 address->prefix_length = mp->prefix.len;
2585 static void vl_api_ip_address_details_t_handler_json
2586 (vl_api_ip_address_details_t * mp)
2588 vat_main_t *vam = &vat_main;
2589 vat_json_node_t *node = NULL;
2591 if (VAT_JSON_ARRAY != vam->json_tree.type)
2593 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2594 vat_json_init_array (&vam->json_tree);
2596 node = vat_json_array_add (&vam->json_tree);
2598 vat_json_init_object (node);
2599 vat_json_object_add_prefix (node, &mp->prefix);
2603 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 static ip_details_t empty_ip_details = { 0 };
2607 ip_details_t *ip = NULL;
2608 u32 sw_if_index = ~0;
2610 sw_if_index = ntohl (mp->sw_if_index);
2612 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2613 sw_if_index, empty_ip_details);
2615 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2622 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2624 vat_main_t *vam = &vat_main;
2626 if (VAT_JSON_ARRAY != vam->json_tree.type)
2628 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2629 vat_json_init_array (&vam->json_tree);
2631 vat_json_array_add_uint (&vam->json_tree,
2632 clib_net_to_host_u32 (mp->sw_if_index));
2635 static void vl_api_get_first_msg_id_reply_t_handler
2636 (vl_api_get_first_msg_id_reply_t * mp)
2638 vat_main_t *vam = &vat_main;
2639 i32 retval = ntohl (mp->retval);
2641 if (vam->async_mode)
2643 vam->async_errors += (retval < 0);
2647 vam->retval = retval;
2648 vam->result_ready = 1;
2652 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2656 static void vl_api_get_first_msg_id_reply_t_handler_json
2657 (vl_api_get_first_msg_id_reply_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vat_json_node_t node;
2662 vat_json_init_object (&node);
2663 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2664 vat_json_object_add_uint (&node, "first_msg_id",
2665 (uint) ntohs (mp->first_msg_id));
2667 vat_json_print (vam->ofp, &node);
2668 vat_json_free (&node);
2670 vam->retval = ntohl (mp->retval);
2671 vam->result_ready = 1;
2674 static void vl_api_get_node_graph_reply_t_handler
2675 (vl_api_get_node_graph_reply_t * mp)
2677 vat_main_t *vam = &vat_main;
2678 i32 retval = ntohl (mp->retval);
2679 u8 *pvt_copy, *reply;
2684 if (vam->async_mode)
2686 vam->async_errors += (retval < 0);
2690 vam->retval = retval;
2691 vam->result_ready = 1;
2694 /* "Should never happen..." */
2698 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2699 pvt_copy = vec_dup (reply);
2701 /* Toss the shared-memory original... */
2702 oldheap = vl_msg_push_heap ();
2706 vl_msg_pop_heap (oldheap);
2708 if (vam->graph_nodes)
2710 hash_free (vam->graph_node_index_by_name);
2712 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2714 node = vam->graph_nodes[0][i];
2715 vec_free (node->name);
2716 vec_free (node->next_nodes);
2719 vec_free (vam->graph_nodes[0]);
2720 vec_free (vam->graph_nodes);
2723 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2724 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2725 vec_free (pvt_copy);
2727 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2729 node = vam->graph_nodes[0][i];
2730 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2734 static void vl_api_get_node_graph_reply_t_handler_json
2735 (vl_api_get_node_graph_reply_t * mp)
2737 vat_main_t *vam = &vat_main;
2739 vat_json_node_t node;
2742 /* $$$$ make this real? */
2743 vat_json_init_object (&node);
2744 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2745 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2747 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2749 /* Toss the shared-memory original... */
2750 oldheap = vl_msg_push_heap ();
2754 vl_msg_pop_heap (oldheap);
2756 vat_json_print (vam->ofp, &node);
2757 vat_json_free (&node);
2759 vam->retval = ntohl (mp->retval);
2760 vam->result_ready = 1;
2764 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2766 vat_main_t *vam = &vat_main;
2771 s = format (s, "%=16d%=16d%=16d",
2772 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2776 s = format (s, "%=16U%=16d%=16d",
2777 mp->is_ipv6 ? format_ip6_address :
2779 mp->ip_address, mp->priority, mp->weight);
2782 print (vam->ofp, "%v", s);
2787 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2789 vat_main_t *vam = &vat_main;
2790 vat_json_node_t *node = NULL;
2791 struct in6_addr ip6;
2794 if (VAT_JSON_ARRAY != vam->json_tree.type)
2796 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2797 vat_json_init_array (&vam->json_tree);
2799 node = vat_json_array_add (&vam->json_tree);
2800 vat_json_init_object (node);
2802 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2803 vat_json_object_add_uint (node, "priority", mp->priority);
2804 vat_json_object_add_uint (node, "weight", mp->weight);
2807 vat_json_object_add_uint (node, "sw_if_index",
2808 clib_net_to_host_u32 (mp->sw_if_index));
2813 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2814 vat_json_object_add_ip6 (node, "address", ip6);
2818 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2819 vat_json_object_add_ip4 (node, "address", ip4);
2825 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2828 vat_main_t *vam = &vat_main;
2831 ls_name = format (0, "%s", mp->ls_name);
2833 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2839 vl_api_one_locator_set_details_t_handler_json
2840 (vl_api_one_locator_set_details_t * mp)
2842 vat_main_t *vam = &vat_main;
2843 vat_json_node_t *node = 0;
2846 ls_name = format (0, "%s", mp->ls_name);
2847 vec_add1 (ls_name, 0);
2849 if (VAT_JSON_ARRAY != vam->json_tree.type)
2851 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2852 vat_json_init_array (&vam->json_tree);
2854 node = vat_json_array_add (&vam->json_tree);
2856 vat_json_init_object (node);
2857 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2858 vat_json_object_add_uint (node, "ls_index",
2859 clib_net_to_host_u32 (mp->ls_index));
2867 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2870 unformat_nsh_address (unformat_input_t * input, va_list * args)
2872 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2873 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2877 format_nsh_address_vat (u8 * s, va_list * args)
2879 nsh_t *a = va_arg (*args, nsh_t *);
2880 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2884 format_lisp_flat_eid (u8 * s, va_list * args)
2886 u32 type = va_arg (*args, u32);
2887 u8 *eid = va_arg (*args, u8 *);
2888 u32 eid_len = va_arg (*args, u32);
2893 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2895 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2897 return format (s, "%U", format_ethernet_address, eid);
2899 return format (s, "%U", format_nsh_address_vat, eid);
2905 format_lisp_eid_vat (u8 * s, va_list * args)
2907 u32 type = va_arg (*args, u32);
2908 u8 *eid = va_arg (*args, u8 *);
2909 u32 eid_len = va_arg (*args, u32);
2910 u8 *seid = va_arg (*args, u8 *);
2911 u32 seid_len = va_arg (*args, u32);
2912 u32 is_src_dst = va_arg (*args, u32);
2915 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2917 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2923 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2925 vat_main_t *vam = &vat_main;
2926 u8 *s = 0, *eid = 0;
2928 if (~0 == mp->locator_set_index)
2929 s = format (0, "action: %d", mp->action);
2931 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2933 eid = format (0, "%U", format_lisp_eid_vat,
2937 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2940 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2941 clib_net_to_host_u32 (mp->vni),
2943 mp->is_local ? "local" : "remote",
2944 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2945 clib_net_to_host_u16 (mp->key_id), mp->key);
2952 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2955 vat_main_t *vam = &vat_main;
2956 vat_json_node_t *node = 0;
2959 if (VAT_JSON_ARRAY != vam->json_tree.type)
2961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2962 vat_json_init_array (&vam->json_tree);
2964 node = vat_json_array_add (&vam->json_tree);
2966 vat_json_init_object (node);
2967 if (~0 == mp->locator_set_index)
2968 vat_json_object_add_uint (node, "action", mp->action);
2970 vat_json_object_add_uint (node, "locator_set_index",
2971 clib_net_to_host_u32 (mp->locator_set_index));
2973 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2974 if (mp->eid_type == 3)
2976 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
2977 vat_json_init_object (nsh_json);
2978 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
2979 vat_json_object_add_uint (nsh_json, "spi",
2980 clib_net_to_host_u32 (nsh->spi));
2981 vat_json_object_add_uint (nsh_json, "si", nsh->si);
2985 eid = format (0, "%U", format_lisp_eid_vat,
2989 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2991 vat_json_object_add_string_copy (node, "eid", eid);
2994 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2995 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2996 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3000 vat_json_object_add_uint (node, "key_id",
3001 clib_net_to_host_u16 (mp->key_id));
3002 vat_json_object_add_string_copy (node, "key", mp->key);
3007 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3009 vat_main_t *vam = &vat_main;
3010 u8 *seid = 0, *deid = 0;
3011 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3013 deid = format (0, "%U", format_lisp_eid_vat,
3014 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3016 seid = format (0, "%U", format_lisp_eid_vat,
3017 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3023 format_ip_address_fcn = format_ip4_address;
3025 format_ip_address_fcn = format_ip6_address;
3028 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3029 clib_net_to_host_u32 (mp->vni),
3031 format_ip_address_fcn, mp->lloc,
3032 format_ip_address_fcn, mp->rloc,
3033 clib_net_to_host_u32 (mp->pkt_count),
3034 clib_net_to_host_u32 (mp->bytes));
3041 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3043 struct in6_addr ip6;
3045 vat_main_t *vam = &vat_main;
3046 vat_json_node_t *node = 0;
3047 u8 *deid = 0, *seid = 0;
3049 if (VAT_JSON_ARRAY != vam->json_tree.type)
3051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3052 vat_json_init_array (&vam->json_tree);
3054 node = vat_json_array_add (&vam->json_tree);
3056 vat_json_init_object (node);
3057 deid = format (0, "%U", format_lisp_eid_vat,
3058 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3060 seid = format (0, "%U", format_lisp_eid_vat,
3061 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3066 vat_json_object_add_string_copy (node, "seid", seid);
3067 vat_json_object_add_string_copy (node, "deid", deid);
3068 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3072 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3073 vat_json_object_add_ip4 (node, "lloc", ip4);
3074 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3075 vat_json_object_add_ip4 (node, "rloc", ip4);
3079 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3080 vat_json_object_add_ip6 (node, "lloc", ip6);
3081 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3082 vat_json_object_add_ip6 (node, "rloc", ip6);
3084 vat_json_object_add_uint (node, "pkt_count",
3085 clib_net_to_host_u32 (mp->pkt_count));
3086 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3093 vl_api_one_eid_table_map_details_t_handler
3094 (vl_api_one_eid_table_map_details_t * mp)
3096 vat_main_t *vam = &vat_main;
3098 u8 *line = format (0, "%=10d%=10d",
3099 clib_net_to_host_u32 (mp->vni),
3100 clib_net_to_host_u32 (mp->dp_table));
3101 print (vam->ofp, "%v", line);
3106 vl_api_one_eid_table_map_details_t_handler_json
3107 (vl_api_one_eid_table_map_details_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t *node = NULL;
3112 if (VAT_JSON_ARRAY != vam->json_tree.type)
3114 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3115 vat_json_init_array (&vam->json_tree);
3117 node = vat_json_array_add (&vam->json_tree);
3118 vat_json_init_object (node);
3119 vat_json_object_add_uint (node, "dp_table",
3120 clib_net_to_host_u32 (mp->dp_table));
3121 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3125 vl_api_one_eid_table_vni_details_t_handler
3126 (vl_api_one_eid_table_vni_details_t * mp)
3128 vat_main_t *vam = &vat_main;
3130 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3131 print (vam->ofp, "%v", line);
3136 vl_api_one_eid_table_vni_details_t_handler_json
3137 (vl_api_one_eid_table_vni_details_t * mp)
3139 vat_main_t *vam = &vat_main;
3140 vat_json_node_t *node = NULL;
3142 if (VAT_JSON_ARRAY != vam->json_tree.type)
3144 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3145 vat_json_init_array (&vam->json_tree);
3147 node = vat_json_array_add (&vam->json_tree);
3148 vat_json_init_object (node);
3149 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3153 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3154 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3156 vat_main_t *vam = &vat_main;
3157 int retval = clib_net_to_host_u32 (mp->retval);
3159 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3160 print (vam->ofp, "fallback threshold value: %d", mp->value);
3162 vam->retval = retval;
3163 vam->result_ready = 1;
3167 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3168 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3170 vat_main_t *vam = &vat_main;
3171 vat_json_node_t _node, *node = &_node;
3172 int retval = clib_net_to_host_u32 (mp->retval);
3174 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3175 vat_json_init_object (node);
3176 vat_json_object_add_uint (node, "value", mp->value);
3178 vat_json_print (vam->ofp, node);
3179 vat_json_free (node);
3181 vam->retval = retval;
3182 vam->result_ready = 1;
3186 vl_api_show_one_map_register_state_reply_t_handler
3187 (vl_api_show_one_map_register_state_reply_t * mp)
3189 vat_main_t *vam = &vat_main;
3190 int retval = clib_net_to_host_u32 (mp->retval);
3192 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3194 vam->retval = retval;
3195 vam->result_ready = 1;
3199 vl_api_show_one_map_register_state_reply_t_handler_json
3200 (vl_api_show_one_map_register_state_reply_t * mp)
3202 vat_main_t *vam = &vat_main;
3203 vat_json_node_t _node, *node = &_node;
3204 int retval = clib_net_to_host_u32 (mp->retval);
3206 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3208 vat_json_init_object (node);
3209 vat_json_object_add_string_copy (node, "state", s);
3211 vat_json_print (vam->ofp, node);
3212 vat_json_free (node);
3214 vam->retval = retval;
3215 vam->result_ready = 1;
3220 vl_api_show_one_rloc_probe_state_reply_t_handler
3221 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3223 vat_main_t *vam = &vat_main;
3224 int retval = clib_net_to_host_u32 (mp->retval);
3229 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3231 vam->retval = retval;
3232 vam->result_ready = 1;
3236 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3237 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3239 vat_main_t *vam = &vat_main;
3240 vat_json_node_t _node, *node = &_node;
3241 int retval = clib_net_to_host_u32 (mp->retval);
3243 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3244 vat_json_init_object (node);
3245 vat_json_object_add_string_copy (node, "state", s);
3247 vat_json_print (vam->ofp, node);
3248 vat_json_free (node);
3250 vam->retval = retval;
3251 vam->result_ready = 1;
3256 vl_api_show_one_stats_enable_disable_reply_t_handler
3257 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3259 vat_main_t *vam = &vat_main;
3260 int retval = clib_net_to_host_u32 (mp->retval);
3265 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3267 vam->retval = retval;
3268 vam->result_ready = 1;
3272 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3273 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3275 vat_main_t *vam = &vat_main;
3276 vat_json_node_t _node, *node = &_node;
3277 int retval = clib_net_to_host_u32 (mp->retval);
3279 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3280 vat_json_init_object (node);
3281 vat_json_object_add_string_copy (node, "state", s);
3283 vat_json_print (vam->ofp, node);
3284 vat_json_free (node);
3286 vam->retval = retval;
3287 vam->result_ready = 1;
3292 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3294 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3295 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3296 e->vni = clib_net_to_host_u32 (e->vni);
3300 gpe_fwd_entries_get_reply_t_net_to_host
3301 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3305 mp->count = clib_net_to_host_u32 (mp->count);
3306 for (i = 0; i < mp->count; i++)
3308 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3313 format_gpe_encap_mode (u8 * s, va_list * args)
3315 u32 mode = va_arg (*args, u32);
3320 return format (s, "lisp");
3322 return format (s, "vxlan");
3328 vl_api_gpe_get_encap_mode_reply_t_handler
3329 (vl_api_gpe_get_encap_mode_reply_t * mp)
3331 vat_main_t *vam = &vat_main;
3333 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3334 vam->retval = ntohl (mp->retval);
3335 vam->result_ready = 1;
3339 vl_api_gpe_get_encap_mode_reply_t_handler_json
3340 (vl_api_gpe_get_encap_mode_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 vat_json_node_t node;
3345 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3346 vec_add1 (encap_mode, 0);
3348 vat_json_init_object (&node);
3349 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3351 vec_free (encap_mode);
3352 vat_json_print (vam->ofp, &node);
3353 vat_json_free (&node);
3355 vam->retval = ntohl (mp->retval);
3356 vam->result_ready = 1;
3360 vl_api_gpe_fwd_entry_path_details_t_handler
3361 (vl_api_gpe_fwd_entry_path_details_t * mp)
3363 vat_main_t *vam = &vat_main;
3364 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3366 if (mp->lcl_loc.is_ip4)
3367 format_ip_address_fcn = format_ip4_address;
3369 format_ip_address_fcn = format_ip6_address;
3371 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3372 format_ip_address_fcn, &mp->lcl_loc,
3373 format_ip_address_fcn, &mp->rmt_loc);
3377 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3379 struct in6_addr ip6;
3384 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3385 vat_json_object_add_ip4 (n, "address", ip4);
3389 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3390 vat_json_object_add_ip6 (n, "address", ip6);
3392 vat_json_object_add_uint (n, "weight", loc->weight);
3396 vl_api_gpe_fwd_entry_path_details_t_handler_json
3397 (vl_api_gpe_fwd_entry_path_details_t * mp)
3399 vat_main_t *vam = &vat_main;
3400 vat_json_node_t *node = NULL;
3401 vat_json_node_t *loc_node;
3403 if (VAT_JSON_ARRAY != vam->json_tree.type)
3405 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3406 vat_json_init_array (&vam->json_tree);
3408 node = vat_json_array_add (&vam->json_tree);
3409 vat_json_init_object (node);
3411 loc_node = vat_json_object_add (node, "local_locator");
3412 vat_json_init_object (loc_node);
3413 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3415 loc_node = vat_json_object_add (node, "remote_locator");
3416 vat_json_init_object (loc_node);
3417 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3421 vl_api_gpe_fwd_entries_get_reply_t_handler
3422 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3424 vat_main_t *vam = &vat_main;
3426 int retval = clib_net_to_host_u32 (mp->retval);
3427 vl_api_gpe_fwd_entry_t *e;
3432 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3434 for (i = 0; i < mp->count; i++)
3436 e = &mp->entries[i];
3437 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3438 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3439 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3443 vam->retval = retval;
3444 vam->result_ready = 1;
3448 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3449 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3452 vat_main_t *vam = &vat_main;
3453 vat_json_node_t *e = 0, root;
3455 int retval = clib_net_to_host_u32 (mp->retval);
3456 vl_api_gpe_fwd_entry_t *fwd;
3461 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3462 vat_json_init_array (&root);
3464 for (i = 0; i < mp->count; i++)
3466 e = vat_json_array_add (&root);
3467 fwd = &mp->entries[i];
3469 vat_json_init_object (e);
3470 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3471 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3472 vat_json_object_add_int (e, "vni", fwd->vni);
3473 vat_json_object_add_int (e, "action", fwd->action);
3475 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3476 fwd->leid_prefix_len);
3478 vat_json_object_add_string_copy (e, "leid", s);
3481 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3482 fwd->reid_prefix_len);
3484 vat_json_object_add_string_copy (e, "reid", s);
3488 vat_json_print (vam->ofp, &root);
3489 vat_json_free (&root);
3492 vam->retval = retval;
3493 vam->result_ready = 1;
3497 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3498 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3500 vat_main_t *vam = &vat_main;
3502 int retval = clib_net_to_host_u32 (mp->retval);
3503 vl_api_gpe_native_fwd_rpath_t *r;
3508 n = clib_net_to_host_u32 (mp->count);
3510 for (i = 0; i < n; i++)
3512 r = &mp->entries[i];
3513 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3514 clib_net_to_host_u32 (r->fib_index),
3515 clib_net_to_host_u32 (r->nh_sw_if_index),
3516 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3520 vam->retval = retval;
3521 vam->result_ready = 1;
3525 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3526 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3528 vat_main_t *vam = &vat_main;
3529 vat_json_node_t root, *e;
3531 int retval = clib_net_to_host_u32 (mp->retval);
3532 vl_api_gpe_native_fwd_rpath_t *r;
3538 n = clib_net_to_host_u32 (mp->count);
3539 vat_json_init_array (&root);
3541 for (i = 0; i < n; i++)
3543 e = vat_json_array_add (&root);
3544 vat_json_init_object (e);
3545 r = &mp->entries[i];
3547 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3550 vat_json_object_add_string_copy (e, "ip4", s);
3553 vat_json_object_add_uint (e, "fib_index",
3554 clib_net_to_host_u32 (r->fib_index));
3555 vat_json_object_add_uint (e, "nh_sw_if_index",
3556 clib_net_to_host_u32 (r->nh_sw_if_index));
3559 vat_json_print (vam->ofp, &root);
3560 vat_json_free (&root);
3563 vam->retval = retval;
3564 vam->result_ready = 1;
3568 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3569 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3571 vat_main_t *vam = &vat_main;
3573 int retval = clib_net_to_host_u32 (mp->retval);
3578 n = clib_net_to_host_u32 (mp->count);
3580 for (i = 0; i < n; i++)
3581 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3584 vam->retval = retval;
3585 vam->result_ready = 1;
3589 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3590 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3592 vat_main_t *vam = &vat_main;
3593 vat_json_node_t root;
3595 int retval = clib_net_to_host_u32 (mp->retval);
3600 n = clib_net_to_host_u32 (mp->count);
3601 vat_json_init_array (&root);
3603 for (i = 0; i < n; i++)
3604 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3606 vat_json_print (vam->ofp, &root);
3607 vat_json_free (&root);
3610 vam->retval = retval;
3611 vam->result_ready = 1;
3615 vl_api_one_ndp_entries_get_reply_t_handler
3616 (vl_api_one_ndp_entries_get_reply_t * mp)
3618 vat_main_t *vam = &vat_main;
3620 int retval = clib_net_to_host_u32 (mp->retval);
3625 n = clib_net_to_host_u32 (mp->count);
3627 for (i = 0; i < n; i++)
3628 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3629 format_ethernet_address, mp->entries[i].mac);
3632 vam->retval = retval;
3633 vam->result_ready = 1;
3637 vl_api_one_ndp_entries_get_reply_t_handler_json
3638 (vl_api_one_ndp_entries_get_reply_t * mp)
3641 vat_main_t *vam = &vat_main;
3642 vat_json_node_t *e = 0, root;
3644 int retval = clib_net_to_host_u32 (mp->retval);
3645 vl_api_one_ndp_entry_t *arp_entry;
3650 n = clib_net_to_host_u32 (mp->count);
3651 vat_json_init_array (&root);
3653 for (i = 0; i < n; i++)
3655 e = vat_json_array_add (&root);
3656 arp_entry = &mp->entries[i];
3658 vat_json_init_object (e);
3659 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3662 vat_json_object_add_string_copy (e, "mac", s);
3665 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3667 vat_json_object_add_string_copy (e, "ip6", s);
3671 vat_json_print (vam->ofp, &root);
3672 vat_json_free (&root);
3675 vam->retval = retval;
3676 vam->result_ready = 1;
3680 vl_api_one_l2_arp_entries_get_reply_t_handler
3681 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3683 vat_main_t *vam = &vat_main;
3685 int retval = clib_net_to_host_u32 (mp->retval);
3690 n = clib_net_to_host_u32 (mp->count);
3692 for (i = 0; i < n; i++)
3693 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3694 format_ethernet_address, mp->entries[i].mac);
3697 vam->retval = retval;
3698 vam->result_ready = 1;
3702 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3703 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 vat_json_node_t *e = 0, root;
3709 int retval = clib_net_to_host_u32 (mp->retval);
3710 vl_api_one_l2_arp_entry_t *arp_entry;
3715 n = clib_net_to_host_u32 (mp->count);
3716 vat_json_init_array (&root);
3718 for (i = 0; i < n; i++)
3720 e = vat_json_array_add (&root);
3721 arp_entry = &mp->entries[i];
3723 vat_json_init_object (e);
3724 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3727 vat_json_object_add_string_copy (e, "mac", s);
3730 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3732 vat_json_object_add_string_copy (e, "ip4", s);
3736 vat_json_print (vam->ofp, &root);
3737 vat_json_free (&root);
3740 vam->retval = retval;
3741 vam->result_ready = 1;
3745 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3747 vat_main_t *vam = &vat_main;
3749 int retval = clib_net_to_host_u32 (mp->retval);
3754 n = clib_net_to_host_u32 (mp->count);
3756 for (i = 0; i < n; i++)
3758 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3762 vam->retval = retval;
3763 vam->result_ready = 1;
3767 vl_api_one_ndp_bd_get_reply_t_handler_json
3768 (vl_api_one_ndp_bd_get_reply_t * mp)
3770 vat_main_t *vam = &vat_main;
3771 vat_json_node_t root;
3773 int retval = clib_net_to_host_u32 (mp->retval);
3778 n = clib_net_to_host_u32 (mp->count);
3779 vat_json_init_array (&root);
3781 for (i = 0; i < n; i++)
3783 vat_json_array_add_uint (&root,
3784 clib_net_to_host_u32 (mp->bridge_domains[i]));
3787 vat_json_print (vam->ofp, &root);
3788 vat_json_free (&root);
3791 vam->retval = retval;
3792 vam->result_ready = 1;
3796 vl_api_one_l2_arp_bd_get_reply_t_handler
3797 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3799 vat_main_t *vam = &vat_main;
3801 int retval = clib_net_to_host_u32 (mp->retval);
3806 n = clib_net_to_host_u32 (mp->count);
3808 for (i = 0; i < n; i++)
3810 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3814 vam->retval = retval;
3815 vam->result_ready = 1;
3819 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3820 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3822 vat_main_t *vam = &vat_main;
3823 vat_json_node_t root;
3825 int retval = clib_net_to_host_u32 (mp->retval);
3830 n = clib_net_to_host_u32 (mp->count);
3831 vat_json_init_array (&root);
3833 for (i = 0; i < n; i++)
3835 vat_json_array_add_uint (&root,
3836 clib_net_to_host_u32 (mp->bridge_domains[i]));
3839 vat_json_print (vam->ofp, &root);
3840 vat_json_free (&root);
3843 vam->retval = retval;
3844 vam->result_ready = 1;
3848 vl_api_one_adjacencies_get_reply_t_handler
3849 (vl_api_one_adjacencies_get_reply_t * mp)
3851 vat_main_t *vam = &vat_main;
3853 int retval = clib_net_to_host_u32 (mp->retval);
3854 vl_api_one_adjacency_t *a;
3859 n = clib_net_to_host_u32 (mp->count);
3861 for (i = 0; i < n; i++)
3863 a = &mp->adjacencies[i];
3864 print (vam->ofp, "%U %40U",
3865 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3866 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3870 vam->retval = retval;
3871 vam->result_ready = 1;
3875 vl_api_one_adjacencies_get_reply_t_handler_json
3876 (vl_api_one_adjacencies_get_reply_t * mp)
3879 vat_main_t *vam = &vat_main;
3880 vat_json_node_t *e = 0, root;
3882 int retval = clib_net_to_host_u32 (mp->retval);
3883 vl_api_one_adjacency_t *a;
3888 n = clib_net_to_host_u32 (mp->count);
3889 vat_json_init_array (&root);
3891 for (i = 0; i < n; i++)
3893 e = vat_json_array_add (&root);
3894 a = &mp->adjacencies[i];
3896 vat_json_init_object (e);
3897 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3898 a->leid_prefix_len);
3900 vat_json_object_add_string_copy (e, "leid", s);
3903 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3904 a->reid_prefix_len);
3906 vat_json_object_add_string_copy (e, "reid", s);
3910 vat_json_print (vam->ofp, &root);
3911 vat_json_free (&root);
3914 vam->retval = retval;
3915 vam->result_ready = 1;
3919 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3921 vat_main_t *vam = &vat_main;
3923 print (vam->ofp, "%=20U",
3924 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3929 vl_api_one_map_server_details_t_handler_json
3930 (vl_api_one_map_server_details_t * mp)
3932 vat_main_t *vam = &vat_main;
3933 vat_json_node_t *node = NULL;
3934 struct in6_addr ip6;
3937 if (VAT_JSON_ARRAY != vam->json_tree.type)
3939 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3940 vat_json_init_array (&vam->json_tree);
3942 node = vat_json_array_add (&vam->json_tree);
3944 vat_json_init_object (node);
3947 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3948 vat_json_object_add_ip6 (node, "map-server", ip6);
3952 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3953 vat_json_object_add_ip4 (node, "map-server", ip4);
3958 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3961 vat_main_t *vam = &vat_main;
3963 print (vam->ofp, "%=20U",
3964 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3969 vl_api_one_map_resolver_details_t_handler_json
3970 (vl_api_one_map_resolver_details_t * mp)
3972 vat_main_t *vam = &vat_main;
3973 vat_json_node_t *node = NULL;
3974 struct in6_addr ip6;
3977 if (VAT_JSON_ARRAY != vam->json_tree.type)
3979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3980 vat_json_init_array (&vam->json_tree);
3982 node = vat_json_array_add (&vam->json_tree);
3984 vat_json_init_object (node);
3987 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3988 vat_json_object_add_ip6 (node, "map resolver", ip6);
3992 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3993 vat_json_object_add_ip4 (node, "map resolver", ip4);
3998 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4000 vat_main_t *vam = &vat_main;
4001 i32 retval = ntohl (mp->retval);
4005 print (vam->ofp, "feature: %s\ngpe: %s",
4006 mp->feature_status ? "enabled" : "disabled",
4007 mp->gpe_status ? "enabled" : "disabled");
4010 vam->retval = retval;
4011 vam->result_ready = 1;
4015 vl_api_show_one_status_reply_t_handler_json
4016 (vl_api_show_one_status_reply_t * mp)
4018 vat_main_t *vam = &vat_main;
4019 vat_json_node_t node;
4020 u8 *gpe_status = NULL;
4021 u8 *feature_status = NULL;
4023 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4024 feature_status = format (0, "%s",
4025 mp->feature_status ? "enabled" : "disabled");
4026 vec_add1 (gpe_status, 0);
4027 vec_add1 (feature_status, 0);
4029 vat_json_init_object (&node);
4030 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4031 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4033 vec_free (gpe_status);
4034 vec_free (feature_status);
4036 vat_json_print (vam->ofp, &node);
4037 vat_json_free (&node);
4039 vam->retval = ntohl (mp->retval);
4040 vam->result_ready = 1;
4044 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4045 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4047 vat_main_t *vam = &vat_main;
4048 i32 retval = ntohl (mp->retval);
4052 print (vam->ofp, "%=20s", mp->locator_set_name);
4055 vam->retval = retval;
4056 vam->result_ready = 1;
4060 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4061 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4063 vat_main_t *vam = &vat_main;
4064 vat_json_node_t *node = NULL;
4066 if (VAT_JSON_ARRAY != vam->json_tree.type)
4068 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4069 vat_json_init_array (&vam->json_tree);
4071 node = vat_json_array_add (&vam->json_tree);
4073 vat_json_init_object (node);
4074 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4076 vat_json_print (vam->ofp, node);
4077 vat_json_free (node);
4079 vam->retval = ntohl (mp->retval);
4080 vam->result_ready = 1;
4084 format_lisp_map_request_mode (u8 * s, va_list * args)
4086 u32 mode = va_arg (*args, u32);
4091 return format (0, "dst-only");
4093 return format (0, "src-dst");
4099 vl_api_show_one_map_request_mode_reply_t_handler
4100 (vl_api_show_one_map_request_mode_reply_t * mp)
4102 vat_main_t *vam = &vat_main;
4103 i32 retval = ntohl (mp->retval);
4107 u32 mode = mp->mode;
4108 print (vam->ofp, "map_request_mode: %U",
4109 format_lisp_map_request_mode, mode);
4112 vam->retval = retval;
4113 vam->result_ready = 1;
4117 vl_api_show_one_map_request_mode_reply_t_handler_json
4118 (vl_api_show_one_map_request_mode_reply_t * mp)
4120 vat_main_t *vam = &vat_main;
4121 vat_json_node_t node;
4126 s = format (0, "%U", format_lisp_map_request_mode, mode);
4129 vat_json_init_object (&node);
4130 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4131 vat_json_print (vam->ofp, &node);
4132 vat_json_free (&node);
4135 vam->retval = ntohl (mp->retval);
4136 vam->result_ready = 1;
4140 vl_api_one_show_xtr_mode_reply_t_handler
4141 (vl_api_one_show_xtr_mode_reply_t * mp)
4143 vat_main_t *vam = &vat_main;
4144 i32 retval = ntohl (mp->retval);
4148 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4151 vam->retval = retval;
4152 vam->result_ready = 1;
4156 vl_api_one_show_xtr_mode_reply_t_handler_json
4157 (vl_api_one_show_xtr_mode_reply_t * mp)
4159 vat_main_t *vam = &vat_main;
4160 vat_json_node_t node;
4163 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4164 vec_add1 (status, 0);
4166 vat_json_init_object (&node);
4167 vat_json_object_add_string_copy (&node, "status", status);
4171 vat_json_print (vam->ofp, &node);
4172 vat_json_free (&node);
4174 vam->retval = ntohl (mp->retval);
4175 vam->result_ready = 1;
4179 vl_api_one_show_pitr_mode_reply_t_handler
4180 (vl_api_one_show_pitr_mode_reply_t * mp)
4182 vat_main_t *vam = &vat_main;
4183 i32 retval = ntohl (mp->retval);
4187 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4190 vam->retval = retval;
4191 vam->result_ready = 1;
4195 vl_api_one_show_pitr_mode_reply_t_handler_json
4196 (vl_api_one_show_pitr_mode_reply_t * mp)
4198 vat_main_t *vam = &vat_main;
4199 vat_json_node_t node;
4202 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4203 vec_add1 (status, 0);
4205 vat_json_init_object (&node);
4206 vat_json_object_add_string_copy (&node, "status", status);
4210 vat_json_print (vam->ofp, &node);
4211 vat_json_free (&node);
4213 vam->retval = ntohl (mp->retval);
4214 vam->result_ready = 1;
4218 vl_api_one_show_petr_mode_reply_t_handler
4219 (vl_api_one_show_petr_mode_reply_t * mp)
4221 vat_main_t *vam = &vat_main;
4222 i32 retval = ntohl (mp->retval);
4226 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4229 vam->retval = retval;
4230 vam->result_ready = 1;
4234 vl_api_one_show_petr_mode_reply_t_handler_json
4235 (vl_api_one_show_petr_mode_reply_t * mp)
4237 vat_main_t *vam = &vat_main;
4238 vat_json_node_t node;
4241 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4242 vec_add1 (status, 0);
4244 vat_json_init_object (&node);
4245 vat_json_object_add_string_copy (&node, "status", status);
4249 vat_json_print (vam->ofp, &node);
4250 vat_json_free (&node);
4252 vam->retval = ntohl (mp->retval);
4253 vam->result_ready = 1;
4257 vl_api_show_one_use_petr_reply_t_handler
4258 (vl_api_show_one_use_petr_reply_t * mp)
4260 vat_main_t *vam = &vat_main;
4261 i32 retval = ntohl (mp->retval);
4265 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4268 print (vam->ofp, "Proxy-ETR address; %U",
4269 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4274 vam->retval = retval;
4275 vam->result_ready = 1;
4279 vl_api_show_one_use_petr_reply_t_handler_json
4280 (vl_api_show_one_use_petr_reply_t * mp)
4282 vat_main_t *vam = &vat_main;
4283 vat_json_node_t node;
4286 struct in6_addr ip6;
4288 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4289 vec_add1 (status, 0);
4291 vat_json_init_object (&node);
4292 vat_json_object_add_string_copy (&node, "status", status);
4297 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4298 vat_json_object_add_ip6 (&node, "address", ip6);
4302 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4303 vat_json_object_add_ip4 (&node, "address", ip4);
4309 vat_json_print (vam->ofp, &node);
4310 vat_json_free (&node);
4312 vam->retval = ntohl (mp->retval);
4313 vam->result_ready = 1;
4317 vl_api_show_one_nsh_mapping_reply_t_handler
4318 (vl_api_show_one_nsh_mapping_reply_t * mp)
4320 vat_main_t *vam = &vat_main;
4321 i32 retval = ntohl (mp->retval);
4325 print (vam->ofp, "%-20s%-16s",
4326 mp->is_set ? "set" : "not-set",
4327 mp->is_set ? (char *) mp->locator_set_name : "");
4330 vam->retval = retval;
4331 vam->result_ready = 1;
4335 vl_api_show_one_nsh_mapping_reply_t_handler_json
4336 (vl_api_show_one_nsh_mapping_reply_t * mp)
4338 vat_main_t *vam = &vat_main;
4339 vat_json_node_t node;
4342 status = format (0, "%s", mp->is_set ? "yes" : "no");
4343 vec_add1 (status, 0);
4345 vat_json_init_object (&node);
4346 vat_json_object_add_string_copy (&node, "is_set", status);
4349 vat_json_object_add_string_copy (&node, "locator_set",
4350 mp->locator_set_name);
4355 vat_json_print (vam->ofp, &node);
4356 vat_json_free (&node);
4358 vam->retval = ntohl (mp->retval);
4359 vam->result_ready = 1;
4363 vl_api_show_one_map_register_ttl_reply_t_handler
4364 (vl_api_show_one_map_register_ttl_reply_t * mp)
4366 vat_main_t *vam = &vat_main;
4367 i32 retval = ntohl (mp->retval);
4369 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4373 print (vam->ofp, "ttl: %u", mp->ttl);
4376 vam->retval = retval;
4377 vam->result_ready = 1;
4381 vl_api_show_one_map_register_ttl_reply_t_handler_json
4382 (vl_api_show_one_map_register_ttl_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 vat_json_node_t node;
4387 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4388 vat_json_init_object (&node);
4389 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4391 vat_json_print (vam->ofp, &node);
4392 vat_json_free (&node);
4394 vam->retval = ntohl (mp->retval);
4395 vam->result_ready = 1;
4399 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4401 vat_main_t *vam = &vat_main;
4402 i32 retval = ntohl (mp->retval);
4406 print (vam->ofp, "%-20s%-16s",
4407 mp->status ? "enabled" : "disabled",
4408 mp->status ? (char *) mp->locator_set_name : "");
4411 vam->retval = retval;
4412 vam->result_ready = 1;
4416 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4418 vat_main_t *vam = &vat_main;
4419 vat_json_node_t node;
4422 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4423 vec_add1 (status, 0);
4425 vat_json_init_object (&node);
4426 vat_json_object_add_string_copy (&node, "status", status);
4429 vat_json_object_add_string_copy (&node, "locator_set",
4430 mp->locator_set_name);
4435 vat_json_print (vam->ofp, &node);
4436 vat_json_free (&node);
4438 vam->retval = ntohl (mp->retval);
4439 vam->result_ready = 1;
4443 format_policer_type (u8 * s, va_list * va)
4445 u32 i = va_arg (*va, u32);
4447 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4448 s = format (s, "1r2c");
4449 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4450 s = format (s, "1r3c");
4451 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4452 s = format (s, "2r3c-2698");
4453 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4454 s = format (s, "2r3c-4115");
4455 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4456 s = format (s, "2r3c-mef5cf1");
4458 s = format (s, "ILLEGAL");
4463 format_policer_rate_type (u8 * s, va_list * va)
4465 u32 i = va_arg (*va, u32);
4467 if (i == SSE2_QOS_RATE_KBPS)
4468 s = format (s, "kbps");
4469 else if (i == SSE2_QOS_RATE_PPS)
4470 s = format (s, "pps");
4472 s = format (s, "ILLEGAL");
4477 format_policer_round_type (u8 * s, va_list * va)
4479 u32 i = va_arg (*va, u32);
4481 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4482 s = format (s, "closest");
4483 else if (i == SSE2_QOS_ROUND_TO_UP)
4484 s = format (s, "up");
4485 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4486 s = format (s, "down");
4488 s = format (s, "ILLEGAL");
4493 format_policer_action_type (u8 * s, va_list * va)
4495 u32 i = va_arg (*va, u32);
4497 if (i == SSE2_QOS_ACTION_DROP)
4498 s = format (s, "drop");
4499 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4500 s = format (s, "transmit");
4501 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4502 s = format (s, "mark-and-transmit");
4504 s = format (s, "ILLEGAL");
4509 format_dscp (u8 * s, va_list * va)
4511 u32 i = va_arg (*va, u32);
4516 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4520 return format (s, "ILLEGAL");
4522 s = format (s, "%s", t);
4527 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4529 vat_main_t *vam = &vat_main;
4530 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4532 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4533 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4535 conform_dscp_str = format (0, "");
4537 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4538 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4540 exceed_dscp_str = format (0, "");
4542 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4543 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4545 violate_dscp_str = format (0, "");
4547 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4548 "rate type %U, round type %U, %s rate, %s color-aware, "
4549 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4550 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4551 "conform action %U%s, exceed action %U%s, violate action %U%s",
4553 format_policer_type, mp->type,
4556 clib_net_to_host_u64 (mp->cb),
4557 clib_net_to_host_u64 (mp->eb),
4558 format_policer_rate_type, mp->rate_type,
4559 format_policer_round_type, mp->round_type,
4560 mp->single_rate ? "single" : "dual",
4561 mp->color_aware ? "is" : "not",
4562 ntohl (mp->cir_tokens_per_period),
4563 ntohl (mp->pir_tokens_per_period),
4565 ntohl (mp->current_limit),
4566 ntohl (mp->current_bucket),
4567 ntohl (mp->extended_limit),
4568 ntohl (mp->extended_bucket),
4569 clib_net_to_host_u64 (mp->last_update_time),
4570 format_policer_action_type, mp->conform_action_type,
4572 format_policer_action_type, mp->exceed_action_type,
4574 format_policer_action_type, mp->violate_action_type,
4577 vec_free (conform_dscp_str);
4578 vec_free (exceed_dscp_str);
4579 vec_free (violate_dscp_str);
4582 static void vl_api_policer_details_t_handler_json
4583 (vl_api_policer_details_t * mp)
4585 vat_main_t *vam = &vat_main;
4586 vat_json_node_t *node;
4587 u8 *rate_type_str, *round_type_str, *type_str;
4588 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4590 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4592 format (0, "%U", format_policer_round_type, mp->round_type);
4593 type_str = format (0, "%U", format_policer_type, mp->type);
4594 conform_action_str = format (0, "%U", format_policer_action_type,
4595 mp->conform_action_type);
4596 exceed_action_str = format (0, "%U", format_policer_action_type,
4597 mp->exceed_action_type);
4598 violate_action_str = format (0, "%U", format_policer_action_type,
4599 mp->violate_action_type);
4601 if (VAT_JSON_ARRAY != vam->json_tree.type)
4603 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4604 vat_json_init_array (&vam->json_tree);
4606 node = vat_json_array_add (&vam->json_tree);
4608 vat_json_init_object (node);
4609 vat_json_object_add_string_copy (node, "name", mp->name);
4610 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4611 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4612 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4613 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4614 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4615 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4616 vat_json_object_add_string_copy (node, "type", type_str);
4617 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4618 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4619 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4620 vat_json_object_add_uint (node, "cir_tokens_per_period",
4621 ntohl (mp->cir_tokens_per_period));
4622 vat_json_object_add_uint (node, "eir_tokens_per_period",
4623 ntohl (mp->pir_tokens_per_period));
4624 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4625 vat_json_object_add_uint (node, "current_bucket",
4626 ntohl (mp->current_bucket));
4627 vat_json_object_add_uint (node, "extended_limit",
4628 ntohl (mp->extended_limit));
4629 vat_json_object_add_uint (node, "extended_bucket",
4630 ntohl (mp->extended_bucket));
4631 vat_json_object_add_uint (node, "last_update_time",
4632 ntohl (mp->last_update_time));
4633 vat_json_object_add_string_copy (node, "conform_action",
4634 conform_action_str);
4635 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4637 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4638 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4639 vec_free (dscp_str);
4641 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4642 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4644 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4645 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4646 vec_free (dscp_str);
4648 vat_json_object_add_string_copy (node, "violate_action",
4649 violate_action_str);
4650 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4652 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4653 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4654 vec_free (dscp_str);
4657 vec_free (rate_type_str);
4658 vec_free (round_type_str);
4659 vec_free (type_str);
4660 vec_free (conform_action_str);
4661 vec_free (exceed_action_str);
4662 vec_free (violate_action_str);
4666 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4669 vat_main_t *vam = &vat_main;
4670 int i, count = ntohl (mp->count);
4673 print (vam->ofp, "classify table ids (%d) : ", count);
4674 for (i = 0; i < count; i++)
4676 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4677 print (vam->ofp, (i < count - 1) ? "," : "");
4679 vam->retval = ntohl (mp->retval);
4680 vam->result_ready = 1;
4684 vl_api_classify_table_ids_reply_t_handler_json
4685 (vl_api_classify_table_ids_reply_t * mp)
4687 vat_main_t *vam = &vat_main;
4688 int i, count = ntohl (mp->count);
4692 vat_json_node_t node;
4694 vat_json_init_object (&node);
4695 for (i = 0; i < count; i++)
4697 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4699 vat_json_print (vam->ofp, &node);
4700 vat_json_free (&node);
4702 vam->retval = ntohl (mp->retval);
4703 vam->result_ready = 1;
4707 vl_api_classify_table_by_interface_reply_t_handler
4708 (vl_api_classify_table_by_interface_reply_t * mp)
4710 vat_main_t *vam = &vat_main;
4713 table_id = ntohl (mp->l2_table_id);
4715 print (vam->ofp, "l2 table id : %d", table_id);
4717 print (vam->ofp, "l2 table id : No input ACL tables configured");
4718 table_id = ntohl (mp->ip4_table_id);
4720 print (vam->ofp, "ip4 table id : %d", table_id);
4722 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4723 table_id = ntohl (mp->ip6_table_id);
4725 print (vam->ofp, "ip6 table id : %d", table_id);
4727 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4728 vam->retval = ntohl (mp->retval);
4729 vam->result_ready = 1;
4733 vl_api_classify_table_by_interface_reply_t_handler_json
4734 (vl_api_classify_table_by_interface_reply_t * mp)
4736 vat_main_t *vam = &vat_main;
4737 vat_json_node_t node;
4739 vat_json_init_object (&node);
4741 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4742 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4743 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4745 vat_json_print (vam->ofp, &node);
4746 vat_json_free (&node);
4748 vam->retval = ntohl (mp->retval);
4749 vam->result_ready = 1;
4752 static void vl_api_policer_add_del_reply_t_handler
4753 (vl_api_policer_add_del_reply_t * mp)
4755 vat_main_t *vam = &vat_main;
4756 i32 retval = ntohl (mp->retval);
4757 if (vam->async_mode)
4759 vam->async_errors += (retval < 0);
4763 vam->retval = retval;
4764 vam->result_ready = 1;
4765 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4767 * Note: this is just barely thread-safe, depends on
4768 * the main thread spinning waiting for an answer...
4770 errmsg ("policer index %d", ntohl (mp->policer_index));
4774 static void vl_api_policer_add_del_reply_t_handler_json
4775 (vl_api_policer_add_del_reply_t * mp)
4777 vat_main_t *vam = &vat_main;
4778 vat_json_node_t node;
4780 vat_json_init_object (&node);
4781 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4782 vat_json_object_add_uint (&node, "policer_index",
4783 ntohl (mp->policer_index));
4785 vat_json_print (vam->ofp, &node);
4786 vat_json_free (&node);
4788 vam->retval = ntohl (mp->retval);
4789 vam->result_ready = 1;
4792 /* Format hex dump. */
4794 format_hex_bytes (u8 * s, va_list * va)
4796 u8 *bytes = va_arg (*va, u8 *);
4797 int n_bytes = va_arg (*va, int);
4800 /* Print short or long form depending on byte count. */
4801 uword short_form = n_bytes <= 32;
4802 u32 indent = format_get_indent (s);
4807 for (i = 0; i < n_bytes; i++)
4809 if (!short_form && (i % 32) == 0)
4810 s = format (s, "%08x: ", i);
4811 s = format (s, "%02x", bytes[i]);
4812 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4813 s = format (s, "\n%U", format_white_space, indent);
4820 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4823 vat_main_t *vam = &vat_main;
4824 i32 retval = ntohl (mp->retval);
4827 print (vam->ofp, "classify table info :");
4828 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4829 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4830 ntohl (mp->miss_next_index));
4831 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4832 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4833 ntohl (mp->match_n_vectors));
4834 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4835 ntohl (mp->mask_length));
4837 vam->retval = retval;
4838 vam->result_ready = 1;
4842 vl_api_classify_table_info_reply_t_handler_json
4843 (vl_api_classify_table_info_reply_t * mp)
4845 vat_main_t *vam = &vat_main;
4846 vat_json_node_t node;
4848 i32 retval = ntohl (mp->retval);
4851 vat_json_init_object (&node);
4853 vat_json_object_add_int (&node, "sessions",
4854 ntohl (mp->active_sessions));
4855 vat_json_object_add_int (&node, "nexttbl",
4856 ntohl (mp->next_table_index));
4857 vat_json_object_add_int (&node, "nextnode",
4858 ntohl (mp->miss_next_index));
4859 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4860 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4861 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4862 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4863 ntohl (mp->mask_length), 0);
4864 vat_json_object_add_string_copy (&node, "mask", s);
4866 vat_json_print (vam->ofp, &node);
4867 vat_json_free (&node);
4869 vam->retval = ntohl (mp->retval);
4870 vam->result_ready = 1;
4874 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4877 vat_main_t *vam = &vat_main;
4879 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4880 ntohl (mp->hit_next_index), ntohl (mp->advance),
4881 ntohl (mp->opaque_index));
4882 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4883 ntohl (mp->match_length));
4887 vl_api_classify_session_details_t_handler_json
4888 (vl_api_classify_session_details_t * mp)
4890 vat_main_t *vam = &vat_main;
4891 vat_json_node_t *node = NULL;
4893 if (VAT_JSON_ARRAY != vam->json_tree.type)
4895 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4896 vat_json_init_array (&vam->json_tree);
4898 node = vat_json_array_add (&vam->json_tree);
4900 vat_json_init_object (node);
4901 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4902 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4903 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4905 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4907 vat_json_object_add_string_copy (node, "match", s);
4910 static void vl_api_pg_create_interface_reply_t_handler
4911 (vl_api_pg_create_interface_reply_t * mp)
4913 vat_main_t *vam = &vat_main;
4915 vam->retval = ntohl (mp->retval);
4916 vam->result_ready = 1;
4919 static void vl_api_pg_create_interface_reply_t_handler_json
4920 (vl_api_pg_create_interface_reply_t * mp)
4922 vat_main_t *vam = &vat_main;
4923 vat_json_node_t node;
4925 i32 retval = ntohl (mp->retval);
4928 vat_json_init_object (&node);
4930 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4932 vat_json_print (vam->ofp, &node);
4933 vat_json_free (&node);
4935 vam->retval = ntohl (mp->retval);
4936 vam->result_ready = 1;
4939 static void vl_api_policer_classify_details_t_handler
4940 (vl_api_policer_classify_details_t * mp)
4942 vat_main_t *vam = &vat_main;
4944 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4945 ntohl (mp->table_index));
4948 static void vl_api_policer_classify_details_t_handler_json
4949 (vl_api_policer_classify_details_t * mp)
4951 vat_main_t *vam = &vat_main;
4952 vat_json_node_t *node;
4954 if (VAT_JSON_ARRAY != vam->json_tree.type)
4956 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4957 vat_json_init_array (&vam->json_tree);
4959 node = vat_json_array_add (&vam->json_tree);
4961 vat_json_init_object (node);
4962 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4963 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4966 static void vl_api_flow_classify_details_t_handler
4967 (vl_api_flow_classify_details_t * mp)
4969 vat_main_t *vam = &vat_main;
4971 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4972 ntohl (mp->table_index));
4975 static void vl_api_flow_classify_details_t_handler_json
4976 (vl_api_flow_classify_details_t * mp)
4978 vat_main_t *vam = &vat_main;
4979 vat_json_node_t *node;
4981 if (VAT_JSON_ARRAY != vam->json_tree.type)
4983 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4984 vat_json_init_array (&vam->json_tree);
4986 node = vat_json_array_add (&vam->json_tree);
4988 vat_json_init_object (node);
4989 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4990 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4993 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
4994 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
4995 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
4996 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
4997 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
4998 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
4999 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5000 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5001 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5002 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5005 * Generate boilerplate reply handlers, which
5006 * dig the return value out of the xxx_reply_t API message,
5007 * stick it into vam->retval, and set vam->result_ready
5009 * Could also do this by pointing N message decode slots at
5010 * a single function, but that could break in subtle ways.
5013 #define foreach_standard_reply_retval_handler \
5014 _(sw_interface_set_flags_reply) \
5015 _(sw_interface_add_del_address_reply) \
5016 _(sw_interface_set_rx_mode_reply) \
5017 _(sw_interface_set_rx_placement_reply) \
5018 _(sw_interface_set_table_reply) \
5019 _(sw_interface_set_mpls_enable_reply) \
5020 _(sw_interface_set_vpath_reply) \
5021 _(sw_interface_set_vxlan_bypass_reply) \
5022 _(sw_interface_set_geneve_bypass_reply) \
5023 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5024 _(sw_interface_set_l2_bridge_reply) \
5025 _(sw_interface_set_bond_weight_reply) \
5026 _(bridge_domain_add_del_reply) \
5027 _(sw_interface_set_l2_xconnect_reply) \
5028 _(l2fib_add_del_reply) \
5029 _(l2fib_flush_int_reply) \
5030 _(l2fib_flush_bd_reply) \
5031 _(ip_route_add_del_reply) \
5032 _(ip_table_add_del_reply) \
5033 _(ip_table_replace_begin_reply) \
5034 _(ip_table_flush_reply) \
5035 _(ip_table_replace_end_reply) \
5036 _(ip_mroute_add_del_reply) \
5037 _(mpls_route_add_del_reply) \
5038 _(mpls_table_add_del_reply) \
5039 _(mpls_ip_bind_unbind_reply) \
5040 _(bier_route_add_del_reply) \
5041 _(bier_table_add_del_reply) \
5042 _(sw_interface_set_unnumbered_reply) \
5043 _(set_ip_flow_hash_reply) \
5044 _(sw_interface_ip6_enable_disable_reply) \
5045 _(l2_patch_add_del_reply) \
5046 _(sr_mpls_policy_add_reply) \
5047 _(sr_mpls_policy_mod_reply) \
5048 _(sr_mpls_policy_del_reply) \
5049 _(sr_policy_add_reply) \
5050 _(sr_policy_mod_reply) \
5051 _(sr_policy_del_reply) \
5052 _(sr_localsid_add_del_reply) \
5053 _(sr_steering_add_del_reply) \
5054 _(classify_add_del_session_reply) \
5055 _(classify_set_interface_ip_table_reply) \
5056 _(classify_set_interface_l2_tables_reply) \
5057 _(l2tpv3_set_tunnel_cookies_reply) \
5058 _(l2tpv3_interface_enable_disable_reply) \
5059 _(l2tpv3_set_lookup_key_reply) \
5060 _(l2_fib_clear_table_reply) \
5061 _(l2_interface_efp_filter_reply) \
5062 _(l2_interface_vlan_tag_rewrite_reply) \
5063 _(modify_vhost_user_if_reply) \
5064 _(delete_vhost_user_if_reply) \
5065 _(want_l2_macs_events_reply) \
5066 _(input_acl_set_interface_reply) \
5067 _(ipsec_spd_add_del_reply) \
5068 _(ipsec_interface_add_del_spd_reply) \
5069 _(ipsec_spd_entry_add_del_reply) \
5070 _(ipsec_sad_entry_add_del_reply) \
5071 _(ipsec_tunnel_if_add_del_reply) \
5072 _(ipsec_tunnel_if_set_sa_reply) \
5073 _(delete_loopback_reply) \
5074 _(bd_ip_mac_add_del_reply) \
5075 _(bd_ip_mac_flush_reply) \
5076 _(want_interface_events_reply) \
5077 _(cop_interface_enable_disable_reply) \
5078 _(cop_whitelist_enable_disable_reply) \
5079 _(sw_interface_clear_stats_reply) \
5080 _(ioam_enable_reply) \
5081 _(ioam_disable_reply) \
5082 _(one_add_del_locator_reply) \
5083 _(one_add_del_local_eid_reply) \
5084 _(one_add_del_remote_mapping_reply) \
5085 _(one_add_del_adjacency_reply) \
5086 _(one_add_del_map_resolver_reply) \
5087 _(one_add_del_map_server_reply) \
5088 _(one_enable_disable_reply) \
5089 _(one_rloc_probe_enable_disable_reply) \
5090 _(one_map_register_enable_disable_reply) \
5091 _(one_map_register_set_ttl_reply) \
5092 _(one_set_transport_protocol_reply) \
5093 _(one_map_register_fallback_threshold_reply) \
5094 _(one_pitr_set_locator_set_reply) \
5095 _(one_map_request_mode_reply) \
5096 _(one_add_del_map_request_itr_rlocs_reply) \
5097 _(one_eid_table_add_del_map_reply) \
5098 _(one_use_petr_reply) \
5099 _(one_stats_enable_disable_reply) \
5100 _(one_add_del_l2_arp_entry_reply) \
5101 _(one_add_del_ndp_entry_reply) \
5102 _(one_stats_flush_reply) \
5103 _(one_enable_disable_xtr_mode_reply) \
5104 _(one_enable_disable_pitr_mode_reply) \
5105 _(one_enable_disable_petr_mode_reply) \
5106 _(gpe_enable_disable_reply) \
5107 _(gpe_set_encap_mode_reply) \
5108 _(gpe_add_del_iface_reply) \
5109 _(gpe_add_del_native_fwd_rpath_reply) \
5110 _(af_packet_delete_reply) \
5111 _(policer_classify_set_interface_reply) \
5112 _(netmap_create_reply) \
5113 _(netmap_delete_reply) \
5114 _(set_ipfix_exporter_reply) \
5115 _(set_ipfix_classify_stream_reply) \
5116 _(ipfix_classify_table_add_del_reply) \
5117 _(flow_classify_set_interface_reply) \
5118 _(sw_interface_span_enable_disable_reply) \
5119 _(pg_capture_reply) \
5120 _(pg_enable_disable_reply) \
5121 _(ip_source_and_port_range_check_add_del_reply) \
5122 _(ip_source_and_port_range_check_interface_add_del_reply)\
5123 _(delete_subif_reply) \
5124 _(l2_interface_pbb_tag_rewrite_reply) \
5126 _(feature_enable_disable_reply) \
5127 _(feature_gso_enable_disable_reply) \
5128 _(sw_interface_tag_add_del_reply) \
5129 _(sw_interface_add_del_mac_address_reply) \
5130 _(hw_interface_set_mtu_reply) \
5131 _(p2p_ethernet_add_reply) \
5132 _(p2p_ethernet_del_reply) \
5133 _(lldp_config_reply) \
5134 _(sw_interface_set_lldp_reply) \
5135 _(tcp_configure_src_addresses_reply) \
5136 _(session_rule_add_del_reply) \
5137 _(ip_container_proxy_add_del_reply) \
5138 _(output_acl_set_interface_reply) \
5139 _(qos_record_enable_disable_reply)
5142 static void vl_api_##n##_t_handler \
5143 (vl_api_##n##_t * mp) \
5145 vat_main_t * vam = &vat_main; \
5146 i32 retval = ntohl(mp->retval); \
5147 if (vam->async_mode) { \
5148 vam->async_errors += (retval < 0); \
5150 vam->retval = retval; \
5151 vam->result_ready = 1; \
5154 foreach_standard_reply_retval_handler;
5158 static void vl_api_##n##_t_handler_json \
5159 (vl_api_##n##_t * mp) \
5161 vat_main_t * vam = &vat_main; \
5162 vat_json_node_t node; \
5163 vat_json_init_object(&node); \
5164 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5165 vat_json_print(vam->ofp, &node); \
5166 vam->retval = ntohl(mp->retval); \
5167 vam->result_ready = 1; \
5169 foreach_standard_reply_retval_handler;
5173 * Table of message reply handlers, must include boilerplate handlers
5177 #define foreach_vpe_api_reply_msg \
5178 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5179 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5180 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5181 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5182 _(CONTROL_PING_REPLY, control_ping_reply) \
5183 _(CLI_REPLY, cli_reply) \
5184 _(CLI_INBAND_REPLY, cli_inband_reply) \
5185 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5186 sw_interface_add_del_address_reply) \
5187 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5188 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5189 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5190 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5191 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5192 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5193 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5194 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5195 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5196 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5197 sw_interface_set_l2_xconnect_reply) \
5198 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5199 sw_interface_set_l2_bridge_reply) \
5200 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5201 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5202 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5203 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5204 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5205 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5206 _(L2_FLAGS_REPLY, l2_flags_reply) \
5207 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5208 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5209 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5210 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5211 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5212 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5213 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5214 _(BOND_CREATE_REPLY, bond_create_reply) \
5215 _(BOND_DELETE_REPLY, bond_delete_reply) \
5216 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5217 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5218 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5219 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5220 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5221 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5222 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5223 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5224 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5225 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5226 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5227 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5228 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5229 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5230 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5231 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5232 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5233 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5234 sw_interface_set_unnumbered_reply) \
5235 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5236 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5237 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5238 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5239 sw_interface_ip6_enable_disable_reply) \
5240 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5241 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5242 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5243 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5244 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5245 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5246 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5247 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5248 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5249 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5250 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5251 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5252 classify_set_interface_ip_table_reply) \
5253 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5254 classify_set_interface_l2_tables_reply) \
5255 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5256 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5257 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5258 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5259 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5260 l2tpv3_interface_enable_disable_reply) \
5261 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5262 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5263 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5264 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5265 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5266 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5267 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5268 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5269 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5270 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5271 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5272 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5273 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5274 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5275 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5276 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5277 _(SHOW_VERSION_REPLY, show_version_reply) \
5278 _(SHOW_THREADS_REPLY, show_threads_reply) \
5279 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5280 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5281 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5282 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5283 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5284 _(L2_MACS_EVENT, l2_macs_event) \
5285 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5286 _(IP_ADDRESS_DETAILS, ip_address_details) \
5287 _(IP_DETAILS, ip_details) \
5288 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5289 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5290 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5291 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5292 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5293 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5294 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5295 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5296 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5297 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5298 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5299 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5300 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5301 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5302 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5303 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5304 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5305 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5306 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5307 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5308 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5309 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5310 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5311 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5312 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5313 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5314 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5315 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5316 one_map_register_enable_disable_reply) \
5317 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5318 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5319 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5320 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5321 one_map_register_fallback_threshold_reply) \
5322 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5323 one_rloc_probe_enable_disable_reply) \
5324 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5325 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5326 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5327 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5328 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5329 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5330 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5331 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5332 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5333 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5334 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5335 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5336 _(ONE_STATS_DETAILS, one_stats_details) \
5337 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5338 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5339 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5340 show_one_stats_enable_disable_reply) \
5341 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5342 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5343 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5344 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5345 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5346 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5347 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5348 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5349 one_enable_disable_pitr_mode_reply) \
5350 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5351 one_enable_disable_petr_mode_reply) \
5352 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5353 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5354 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5355 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5356 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5357 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5358 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5359 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5360 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5361 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5362 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5363 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5364 gpe_add_del_native_fwd_rpath_reply) \
5365 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5366 gpe_fwd_entry_path_details) \
5367 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5368 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5369 one_add_del_map_request_itr_rlocs_reply) \
5370 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5371 one_get_map_request_itr_rlocs_reply) \
5372 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5373 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5374 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5375 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5376 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5377 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5378 show_one_map_register_state_reply) \
5379 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5380 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5381 show_one_map_register_fallback_threshold_reply) \
5382 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5383 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5384 _(AF_PACKET_DETAILS, af_packet_details) \
5385 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5386 _(POLICER_DETAILS, policer_details) \
5387 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5388 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5389 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5390 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5391 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5392 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5393 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5394 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5395 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5396 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5397 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5398 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5399 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5400 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5401 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5402 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5403 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5404 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5405 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5406 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5407 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5408 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5409 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5410 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5411 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5412 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5413 ip_source_and_port_range_check_add_del_reply) \
5414 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5415 ip_source_and_port_range_check_interface_add_del_reply) \
5416 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5417 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5418 _(SET_PUNT_REPLY, set_punt_reply) \
5419 _(IP_TABLE_DETAILS, ip_table_details) \
5420 _(IP_ROUTE_DETAILS, ip_route_details) \
5421 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5422 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5423 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5424 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5425 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5426 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5427 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5428 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5429 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5430 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5431 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5432 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5433 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5434 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5435 _(SESSION_RULES_DETAILS, session_rules_details) \
5436 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5437 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5438 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5440 #define foreach_standalone_reply_msg \
5441 _(SW_INTERFACE_EVENT, sw_interface_event)
5449 #define STR_VTR_OP_CASE(op) \
5450 case L2_VTR_ ## op: \
5454 str_vtr_op (u32 vtr_op)
5458 STR_VTR_OP_CASE (DISABLED);
5459 STR_VTR_OP_CASE (PUSH_1);
5460 STR_VTR_OP_CASE (PUSH_2);
5461 STR_VTR_OP_CASE (POP_1);
5462 STR_VTR_OP_CASE (POP_2);
5463 STR_VTR_OP_CASE (TRANSLATE_1_1);
5464 STR_VTR_OP_CASE (TRANSLATE_1_2);
5465 STR_VTR_OP_CASE (TRANSLATE_2_1);
5466 STR_VTR_OP_CASE (TRANSLATE_2_2);
5473 dump_sub_interface_table (vat_main_t * vam)
5475 const sw_interface_subif_t *sub = NULL;
5477 if (vam->json_output)
5480 ("JSON output supported only for VPE API calls and dump_stats_table");
5485 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5486 "Interface", "sw_if_index",
5487 "sub id", "dot1ad", "tags", "outer id",
5488 "inner id", "exact", "default", "outer any", "inner any");
5490 vec_foreach (sub, vam->sw_if_subif_table)
5493 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5494 sub->interface_name,
5496 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5497 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5498 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5499 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5500 if (sub->vtr_op != L2_VTR_DISABLED)
5503 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5504 "tag1: %d tag2: %d ]",
5505 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5506 sub->vtr_tag1, sub->vtr_tag2);
5514 name_sort_cmp (void *a1, void *a2)
5516 name_sort_t *n1 = a1;
5517 name_sort_t *n2 = a2;
5519 return strcmp ((char *) n1->name, (char *) n2->name);
5523 dump_interface_table (vat_main_t * vam)
5526 name_sort_t *nses = 0, *ns;
5528 if (vam->json_output)
5531 ("JSON output supported only for VPE API calls and dump_stats_table");
5536 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5538 vec_add2 (nses, ns, 1);
5539 ns->name = (u8 *)(p->key);
5540 ns->value = (u32) p->value[0];
5544 vec_sort_with_function (nses, name_sort_cmp);
5546 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5547 vec_foreach (ns, nses)
5549 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5556 dump_ip_table (vat_main_t * vam, int is_ipv6)
5558 const ip_details_t *det = NULL;
5559 const ip_address_details_t *address = NULL;
5562 print (vam->ofp, "%-12s", "sw_if_index");
5564 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5571 print (vam->ofp, "%-12d", i);
5572 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5577 vec_foreach (address, det->addr)
5581 is_ipv6 ? format_ip6_address : format_ip4_address,
5582 address->ip, address->prefix_length);
5590 dump_ipv4_table (vat_main_t * vam)
5592 if (vam->json_output)
5595 ("JSON output supported only for VPE API calls and dump_stats_table");
5599 return dump_ip_table (vam, 0);
5603 dump_ipv6_table (vat_main_t * vam)
5605 if (vam->json_output)
5608 ("JSON output supported only for VPE API calls and dump_stats_table");
5612 return dump_ip_table (vam, 1);
5616 * Pass CLI buffers directly in the CLI_INBAND API message,
5617 * instead of an additional shared memory area.
5620 exec_inband (vat_main_t * vam)
5622 vl_api_cli_inband_t *mp;
5623 unformat_input_t *i = vam->input;
5626 if (vec_len (i->buffer) == 0)
5629 if (vam->exec_mode == 0 && unformat (i, "mode"))
5634 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5641 * In order for the CLI command to work, it
5642 * must be a vector ending in \n, not a C-string ending
5645 u32 len = vec_len (vam->input->buffer);
5646 M2 (CLI_INBAND, mp, len);
5647 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5651 /* json responses may or may not include a useful reply... */
5652 if (vec_len (vam->cmd_reply))
5653 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5658 exec (vat_main_t * vam)
5660 return exec_inband (vam);
5664 api_create_loopback (vat_main_t * vam)
5666 unformat_input_t *i = vam->input;
5667 vl_api_create_loopback_t *mp;
5668 vl_api_create_loopback_instance_t *mp_lbi;
5671 u8 is_specified = 0;
5672 u32 user_instance = 0;
5675 clib_memset (mac_address, 0, sizeof (mac_address));
5677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5679 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5681 if (unformat (i, "instance %d", &user_instance))
5689 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5690 mp_lbi->is_specified = is_specified;
5692 mp_lbi->user_instance = htonl (user_instance);
5694 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5699 /* Construct the API message */
5700 M (CREATE_LOOPBACK, mp);
5702 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5711 api_delete_loopback (vat_main_t * vam)
5713 unformat_input_t *i = vam->input;
5714 vl_api_delete_loopback_t *mp;
5715 u32 sw_if_index = ~0;
5718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5720 if (unformat (i, "sw_if_index %d", &sw_if_index))
5726 if (sw_if_index == ~0)
5728 errmsg ("missing sw_if_index");
5732 /* Construct the API message */
5733 M (DELETE_LOOPBACK, mp);
5734 mp->sw_if_index = ntohl (sw_if_index);
5742 api_want_interface_events (vat_main_t * vam)
5744 unformat_input_t *i = vam->input;
5745 vl_api_want_interface_events_t *mp;
5749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5751 if (unformat (i, "enable"))
5753 else if (unformat (i, "disable"))
5761 errmsg ("missing enable|disable");
5765 M (WANT_INTERFACE_EVENTS, mp);
5766 mp->enable_disable = enable;
5768 vam->interface_event_display = enable;
5776 /* Note: non-static, called once to set up the initial intfc table */
5778 api_sw_interface_dump (vat_main_t * vam)
5780 vl_api_sw_interface_dump_t *mp;
5781 vl_api_control_ping_t *mp_ping;
5783 name_sort_t *nses = 0, *ns;
5784 sw_interface_subif_t *sub = NULL;
5787 /* Toss the old name table */
5789 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5791 vec_add2 (nses, ns, 1);
5792 ns->name = (u8 *)(p->key);
5793 ns->value = (u32) p->value[0];
5797 hash_free (vam->sw_if_index_by_interface_name);
5799 vec_foreach (ns, nses) vec_free (ns->name);
5803 vec_foreach (sub, vam->sw_if_subif_table)
5805 vec_free (sub->interface_name);
5807 vec_free (vam->sw_if_subif_table);
5809 /* recreate the interface name hash table */
5810 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5813 * Ask for all interface names. Otherwise, the epic catalog of
5814 * name filters becomes ridiculously long, and vat ends up needing
5815 * to be taught about new interface types.
5817 M (SW_INTERFACE_DUMP, mp);
5820 /* Use a control ping for synchronization */
5821 MPING (CONTROL_PING, mp_ping);
5829 api_sw_interface_set_flags (vat_main_t * vam)
5831 unformat_input_t *i = vam->input;
5832 vl_api_sw_interface_set_flags_t *mp;
5834 u8 sw_if_index_set = 0;
5838 /* Parse args required to build the message */
5839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5841 if (unformat (i, "admin-up"))
5843 else if (unformat (i, "admin-down"))
5846 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5847 sw_if_index_set = 1;
5848 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5849 sw_if_index_set = 1;
5854 if (sw_if_index_set == 0)
5856 errmsg ("missing interface name or sw_if_index");
5860 /* Construct the API message */
5861 M (SW_INTERFACE_SET_FLAGS, mp);
5862 mp->sw_if_index = ntohl (sw_if_index);
5863 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5868 /* Wait for a reply, return the good/bad news... */
5874 api_sw_interface_set_rx_mode (vat_main_t * vam)
5876 unformat_input_t *i = vam->input;
5877 vl_api_sw_interface_set_rx_mode_t *mp;
5879 u8 sw_if_index_set = 0;
5881 u8 queue_id_valid = 0;
5883 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5885 /* Parse args required to build the message */
5886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5888 if (unformat (i, "queue %d", &queue_id))
5890 else if (unformat (i, "polling"))
5891 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5892 else if (unformat (i, "interrupt"))
5893 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5894 else if (unformat (i, "adaptive"))
5895 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5897 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5898 sw_if_index_set = 1;
5899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5900 sw_if_index_set = 1;
5905 if (sw_if_index_set == 0)
5907 errmsg ("missing interface name or sw_if_index");
5910 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5912 errmsg ("missing rx-mode");
5916 /* Construct the API message */
5917 M (SW_INTERFACE_SET_RX_MODE, mp);
5918 mp->sw_if_index = ntohl (sw_if_index);
5919 mp->mode = (vl_api_rx_mode_t) mode;
5920 mp->queue_id_valid = queue_id_valid;
5921 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5926 /* Wait for a reply, return the good/bad news... */
5932 api_sw_interface_set_rx_placement (vat_main_t * vam)
5934 unformat_input_t *i = vam->input;
5935 vl_api_sw_interface_set_rx_placement_t *mp;
5937 u8 sw_if_index_set = 0;
5940 u32 queue_id, thread_index;
5942 /* Parse args required to build the message */
5943 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5945 if (unformat (i, "queue %d", &queue_id))
5947 else if (unformat (i, "main"))
5949 else if (unformat (i, "worker %d", &thread_index))
5952 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5953 sw_if_index_set = 1;
5954 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5955 sw_if_index_set = 1;
5960 if (sw_if_index_set == 0)
5962 errmsg ("missing interface name or sw_if_index");
5968 /* Construct the API message */
5969 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5970 mp->sw_if_index = ntohl (sw_if_index);
5971 mp->worker_id = ntohl (thread_index);
5972 mp->queue_id = ntohl (queue_id);
5973 mp->is_main = is_main;
5977 /* Wait for a reply, return the good/bad news... */
5982 static void vl_api_sw_interface_rx_placement_details_t_handler
5983 (vl_api_sw_interface_rx_placement_details_t * mp)
5985 vat_main_t *vam = &vat_main;
5986 u32 worker_id = ntohl (mp->worker_id);
5989 "\n%-11d %-11s %-6d %-5d %-9s",
5990 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
5991 worker_id, ntohl (mp->queue_id),
5993 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
5996 static void vl_api_sw_interface_rx_placement_details_t_handler_json
5997 (vl_api_sw_interface_rx_placement_details_t * mp)
5999 vat_main_t *vam = &vat_main;
6000 vat_json_node_t *node = NULL;
6002 if (VAT_JSON_ARRAY != vam->json_tree.type)
6004 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6005 vat_json_init_array (&vam->json_tree);
6007 node = vat_json_array_add (&vam->json_tree);
6009 vat_json_init_object (node);
6010 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6011 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6012 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6013 vat_json_object_add_uint (node, "mode", mp->mode);
6017 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6019 unformat_input_t *i = vam->input;
6020 vl_api_sw_interface_rx_placement_dump_t *mp;
6021 vl_api_control_ping_t *mp_ping;
6024 u8 sw_if_index_set = 0;
6026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6037 "\n%-11s %-11s %-6s %-5s %-4s",
6038 "sw_if_index", "main/worker", "thread", "queue", "mode");
6040 /* Dump Interface rx placement */
6041 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6043 if (sw_if_index_set)
6044 mp->sw_if_index = htonl (sw_if_index);
6046 mp->sw_if_index = ~0;
6050 /* Use a control ping for synchronization */
6051 MPING (CONTROL_PING, mp_ping);
6059 api_sw_interface_clear_stats (vat_main_t * vam)
6061 unformat_input_t *i = vam->input;
6062 vl_api_sw_interface_clear_stats_t *mp;
6064 u8 sw_if_index_set = 0;
6067 /* Parse args required to build the message */
6068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6070 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6071 sw_if_index_set = 1;
6072 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6073 sw_if_index_set = 1;
6078 /* Construct the API message */
6079 M (SW_INTERFACE_CLEAR_STATS, mp);
6081 if (sw_if_index_set == 1)
6082 mp->sw_if_index = ntohl (sw_if_index);
6084 mp->sw_if_index = ~0;
6089 /* Wait for a reply, return the good/bad news... */
6095 api_sw_interface_add_del_address (vat_main_t * vam)
6097 unformat_input_t *i = vam->input;
6098 vl_api_sw_interface_add_del_address_t *mp;
6100 u8 sw_if_index_set = 0;
6101 u8 is_add = 1, del_all = 0;
6102 u32 address_length = 0;
6103 u8 v4_address_set = 0;
6104 u8 v6_address_set = 0;
6105 ip4_address_t v4address;
6106 ip6_address_t v6address;
6109 /* Parse args required to build the message */
6110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6112 if (unformat (i, "del-all"))
6114 else if (unformat (i, "del"))
6117 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6118 sw_if_index_set = 1;
6119 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6120 sw_if_index_set = 1;
6121 else if (unformat (i, "%U/%d",
6122 unformat_ip4_address, &v4address, &address_length))
6124 else if (unformat (i, "%U/%d",
6125 unformat_ip6_address, &v6address, &address_length))
6131 if (sw_if_index_set == 0)
6133 errmsg ("missing interface name or sw_if_index");
6136 if (v4_address_set && v6_address_set)
6138 errmsg ("both v4 and v6 addresses set");
6141 if (!v4_address_set && !v6_address_set && !del_all)
6143 errmsg ("no addresses set");
6147 /* Construct the API message */
6148 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6150 mp->sw_if_index = ntohl (sw_if_index);
6151 mp->is_add = is_add;
6152 mp->del_all = del_all;
6155 mp->prefix.address.af = ADDRESS_IP6;
6156 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6160 mp->prefix.address.af = ADDRESS_IP4;
6161 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6163 mp->prefix.len = address_length;
6168 /* Wait for a reply, return good/bad news */
6174 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6176 unformat_input_t *i = vam->input;
6177 vl_api_sw_interface_set_mpls_enable_t *mp;
6179 u8 sw_if_index_set = 0;
6183 /* Parse args required to build the message */
6184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6186 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6187 sw_if_index_set = 1;
6188 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6189 sw_if_index_set = 1;
6190 else if (unformat (i, "disable"))
6192 else if (unformat (i, "dis"))
6198 if (sw_if_index_set == 0)
6200 errmsg ("missing interface name or sw_if_index");
6204 /* Construct the API message */
6205 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6207 mp->sw_if_index = ntohl (sw_if_index);
6208 mp->enable = enable;
6213 /* Wait for a reply... */
6219 api_sw_interface_set_table (vat_main_t * vam)
6221 unformat_input_t *i = vam->input;
6222 vl_api_sw_interface_set_table_t *mp;
6223 u32 sw_if_index, vrf_id = 0;
6224 u8 sw_if_index_set = 0;
6228 /* Parse args required to build the message */
6229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6231 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6232 sw_if_index_set = 1;
6233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6234 sw_if_index_set = 1;
6235 else if (unformat (i, "vrf %d", &vrf_id))
6237 else if (unformat (i, "ipv6"))
6243 if (sw_if_index_set == 0)
6245 errmsg ("missing interface name or sw_if_index");
6249 /* Construct the API message */
6250 M (SW_INTERFACE_SET_TABLE, mp);
6252 mp->sw_if_index = ntohl (sw_if_index);
6253 mp->is_ipv6 = is_ipv6;
6254 mp->vrf_id = ntohl (vrf_id);
6259 /* Wait for a reply... */
6264 static void vl_api_sw_interface_get_table_reply_t_handler
6265 (vl_api_sw_interface_get_table_reply_t * mp)
6267 vat_main_t *vam = &vat_main;
6269 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6271 vam->retval = ntohl (mp->retval);
6272 vam->result_ready = 1;
6276 static void vl_api_sw_interface_get_table_reply_t_handler_json
6277 (vl_api_sw_interface_get_table_reply_t * mp)
6279 vat_main_t *vam = &vat_main;
6280 vat_json_node_t node;
6282 vat_json_init_object (&node);
6283 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6284 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6286 vat_json_print (vam->ofp, &node);
6287 vat_json_free (&node);
6289 vam->retval = ntohl (mp->retval);
6290 vam->result_ready = 1;
6294 api_sw_interface_get_table (vat_main_t * vam)
6296 unformat_input_t *i = vam->input;
6297 vl_api_sw_interface_get_table_t *mp;
6299 u8 sw_if_index_set = 0;
6303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6306 sw_if_index_set = 1;
6307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6308 sw_if_index_set = 1;
6309 else if (unformat (i, "ipv6"))
6315 if (sw_if_index_set == 0)
6317 errmsg ("missing interface name or sw_if_index");
6321 M (SW_INTERFACE_GET_TABLE, mp);
6322 mp->sw_if_index = htonl (sw_if_index);
6323 mp->is_ipv6 = is_ipv6;
6331 api_sw_interface_set_vpath (vat_main_t * vam)
6333 unformat_input_t *i = vam->input;
6334 vl_api_sw_interface_set_vpath_t *mp;
6335 u32 sw_if_index = 0;
6336 u8 sw_if_index_set = 0;
6340 /* Parse args required to build the message */
6341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6343 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6344 sw_if_index_set = 1;
6345 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6346 sw_if_index_set = 1;
6347 else if (unformat (i, "enable"))
6349 else if (unformat (i, "disable"))
6355 if (sw_if_index_set == 0)
6357 errmsg ("missing interface name or sw_if_index");
6361 /* Construct the API message */
6362 M (SW_INTERFACE_SET_VPATH, mp);
6364 mp->sw_if_index = ntohl (sw_if_index);
6365 mp->enable = is_enable;
6370 /* Wait for a reply... */
6376 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6378 unformat_input_t *i = vam->input;
6379 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6380 u32 sw_if_index = 0;
6381 u8 sw_if_index_set = 0;
6386 /* Parse args required to build the message */
6387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6390 sw_if_index_set = 1;
6391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6392 sw_if_index_set = 1;
6393 else if (unformat (i, "enable"))
6395 else if (unformat (i, "disable"))
6397 else if (unformat (i, "ip4"))
6399 else if (unformat (i, "ip6"))
6405 if (sw_if_index_set == 0)
6407 errmsg ("missing interface name or sw_if_index");
6411 /* Construct the API message */
6412 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6414 mp->sw_if_index = ntohl (sw_if_index);
6415 mp->enable = is_enable;
6416 mp->is_ipv6 = is_ipv6;
6421 /* Wait for a reply... */
6427 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6429 unformat_input_t *i = vam->input;
6430 vl_api_sw_interface_set_geneve_bypass_t *mp;
6431 u32 sw_if_index = 0;
6432 u8 sw_if_index_set = 0;
6437 /* Parse args required to build the message */
6438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6440 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6441 sw_if_index_set = 1;
6442 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6443 sw_if_index_set = 1;
6444 else if (unformat (i, "enable"))
6446 else if (unformat (i, "disable"))
6448 else if (unformat (i, "ip4"))
6450 else if (unformat (i, "ip6"))
6456 if (sw_if_index_set == 0)
6458 errmsg ("missing interface name or sw_if_index");
6462 /* Construct the API message */
6463 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6465 mp->sw_if_index = ntohl (sw_if_index);
6466 mp->enable = is_enable;
6467 mp->is_ipv6 = is_ipv6;
6472 /* Wait for a reply... */
6478 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6480 unformat_input_t *i = vam->input;
6481 vl_api_sw_interface_set_l2_xconnect_t *mp;
6483 u8 rx_sw_if_index_set = 0;
6485 u8 tx_sw_if_index_set = 0;
6489 /* Parse args required to build the message */
6490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6492 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6493 rx_sw_if_index_set = 1;
6494 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6495 tx_sw_if_index_set = 1;
6496 else if (unformat (i, "rx"))
6498 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6500 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6502 rx_sw_if_index_set = 1;
6507 else if (unformat (i, "tx"))
6509 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6511 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6513 tx_sw_if_index_set = 1;
6518 else if (unformat (i, "enable"))
6520 else if (unformat (i, "disable"))
6526 if (rx_sw_if_index_set == 0)
6528 errmsg ("missing rx interface name or rx_sw_if_index");
6532 if (enable && (tx_sw_if_index_set == 0))
6534 errmsg ("missing tx interface name or tx_sw_if_index");
6538 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6540 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6541 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6542 mp->enable = enable;
6550 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6552 unformat_input_t *i = vam->input;
6553 vl_api_sw_interface_set_l2_bridge_t *mp;
6554 vl_api_l2_port_type_t port_type;
6556 u8 rx_sw_if_index_set = 0;
6563 port_type = L2_API_PORT_TYPE_NORMAL;
6565 /* Parse args required to build the message */
6566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6568 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6569 rx_sw_if_index_set = 1;
6570 else if (unformat (i, "bd_id %d", &bd_id))
6574 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6575 rx_sw_if_index_set = 1;
6576 else if (unformat (i, "shg %d", &shg))
6578 else if (unformat (i, "bvi"))
6579 port_type = L2_API_PORT_TYPE_BVI;
6580 else if (unformat (i, "uu-fwd"))
6581 port_type = L2_API_PORT_TYPE_UU_FWD;
6582 else if (unformat (i, "enable"))
6584 else if (unformat (i, "disable"))
6590 if (rx_sw_if_index_set == 0)
6592 errmsg ("missing rx interface name or sw_if_index");
6596 if (enable && (bd_id_set == 0))
6598 errmsg ("missing bridge domain");
6602 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6604 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6605 mp->bd_id = ntohl (bd_id);
6607 mp->port_type = ntohl (port_type);
6608 mp->enable = enable;
6616 api_bridge_domain_dump (vat_main_t * vam)
6618 unformat_input_t *i = vam->input;
6619 vl_api_bridge_domain_dump_t *mp;
6620 vl_api_control_ping_t *mp_ping;
6624 /* Parse args required to build the message */
6625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6627 if (unformat (i, "bd_id %d", &bd_id))
6633 M (BRIDGE_DOMAIN_DUMP, mp);
6634 mp->bd_id = ntohl (bd_id);
6637 /* Use a control ping for synchronization */
6638 MPING (CONTROL_PING, mp_ping);
6646 api_bridge_domain_add_del (vat_main_t * vam)
6648 unformat_input_t *i = vam->input;
6649 vl_api_bridge_domain_add_del_t *mp;
6652 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6657 /* Parse args required to build the message */
6658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6660 if (unformat (i, "bd_id %d", &bd_id))
6662 else if (unformat (i, "flood %d", &flood))
6664 else if (unformat (i, "uu-flood %d", &uu_flood))
6666 else if (unformat (i, "forward %d", &forward))
6668 else if (unformat (i, "learn %d", &learn))
6670 else if (unformat (i, "arp-term %d", &arp_term))
6672 else if (unformat (i, "mac-age %d", &mac_age))
6674 else if (unformat (i, "bd-tag %s", &bd_tag))
6676 else if (unformat (i, "del"))
6679 flood = uu_flood = forward = learn = 0;
6687 errmsg ("missing bridge domain");
6694 errmsg ("mac age must be less than 256 ");
6699 if ((bd_tag) && (vec_len (bd_tag) > 63))
6701 errmsg ("bd-tag cannot be longer than 63");
6706 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6708 mp->bd_id = ntohl (bd_id);
6710 mp->uu_flood = uu_flood;
6711 mp->forward = forward;
6713 mp->arp_term = arp_term;
6714 mp->is_add = is_add;
6715 mp->mac_age = (u8) mac_age;
6718 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6719 mp->bd_tag[vec_len (bd_tag)] = 0;
6730 api_l2fib_flush_bd (vat_main_t * vam)
6732 unformat_input_t *i = vam->input;
6733 vl_api_l2fib_flush_bd_t *mp;
6737 /* Parse args required to build the message */
6738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6740 if (unformat (i, "bd_id %d", &bd_id));
6747 errmsg ("missing bridge domain");
6751 M (L2FIB_FLUSH_BD, mp);
6753 mp->bd_id = htonl (bd_id);
6761 api_l2fib_flush_int (vat_main_t * vam)
6763 unformat_input_t *i = vam->input;
6764 vl_api_l2fib_flush_int_t *mp;
6765 u32 sw_if_index = ~0;
6768 /* Parse args required to build the message */
6769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6771 if (unformat (i, "sw_if_index %d", &sw_if_index));
6773 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6778 if (sw_if_index == ~0)
6780 errmsg ("missing interface name or sw_if_index");
6784 M (L2FIB_FLUSH_INT, mp);
6786 mp->sw_if_index = ntohl (sw_if_index);
6794 api_l2fib_add_del (vat_main_t * vam)
6796 unformat_input_t *i = vam->input;
6797 vl_api_l2fib_add_del_t *mp;
6803 u32 sw_if_index = 0;
6804 u8 sw_if_index_set = 0;
6813 /* Parse args required to build the message */
6814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6816 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6818 else if (unformat (i, "bd_id %d", &bd_id))
6820 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6821 sw_if_index_set = 1;
6822 else if (unformat (i, "sw_if"))
6824 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6827 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6828 sw_if_index_set = 1;
6833 else if (unformat (i, "static"))
6835 else if (unformat (i, "filter"))
6840 else if (unformat (i, "bvi"))
6845 else if (unformat (i, "del"))
6847 else if (unformat (i, "count %d", &count))
6855 errmsg ("missing mac address");
6861 errmsg ("missing bridge domain");
6865 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6867 errmsg ("missing interface name or sw_if_index");
6873 /* Turn on async mode */
6874 vam->async_mode = 1;
6875 vam->async_errors = 0;
6876 before = vat_time_now (vam);
6879 for (j = 0; j < count; j++)
6881 M (L2FIB_ADD_DEL, mp);
6883 clib_memcpy (mp->mac, mac, 6);
6884 mp->bd_id = ntohl (bd_id);
6885 mp->is_add = is_add;
6886 mp->sw_if_index = ntohl (sw_if_index);
6890 mp->static_mac = static_mac;
6891 mp->filter_mac = filter_mac;
6892 mp->bvi_mac = bvi_mac;
6894 increment_mac_address (mac);
6901 vl_api_control_ping_t *mp_ping;
6904 /* Shut off async mode */
6905 vam->async_mode = 0;
6907 MPING (CONTROL_PING, mp_ping);
6910 timeout = vat_time_now (vam) + 1.0;
6911 while (vat_time_now (vam) < timeout)
6912 if (vam->result_ready == 1)
6917 if (vam->retval == -99)
6920 if (vam->async_errors > 0)
6922 errmsg ("%d asynchronous errors", vam->async_errors);
6925 vam->async_errors = 0;
6926 after = vat_time_now (vam);
6928 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6929 count, after - before, count / (after - before));
6935 /* Wait for a reply... */
6939 /* Return the good/bad news */
6940 return (vam->retval);
6944 api_bridge_domain_set_mac_age (vat_main_t * vam)
6946 unformat_input_t *i = vam->input;
6947 vl_api_bridge_domain_set_mac_age_t *mp;
6952 /* Parse args required to build the message */
6953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6955 if (unformat (i, "bd_id %d", &bd_id));
6956 else if (unformat (i, "mac-age %d", &mac_age));
6963 errmsg ("missing bridge domain");
6969 errmsg ("mac age must be less than 256 ");
6973 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6975 mp->bd_id = htonl (bd_id);
6976 mp->mac_age = (u8) mac_age;
6984 api_l2_flags (vat_main_t * vam)
6986 unformat_input_t *i = vam->input;
6987 vl_api_l2_flags_t *mp;
6990 u8 sw_if_index_set = 0;
6994 /* Parse args required to build the message */
6995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6997 if (unformat (i, "sw_if_index %d", &sw_if_index))
6998 sw_if_index_set = 1;
6999 else if (unformat (i, "sw_if"))
7001 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7004 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7005 sw_if_index_set = 1;
7010 else if (unformat (i, "learn"))
7012 else if (unformat (i, "forward"))
7014 else if (unformat (i, "flood"))
7016 else if (unformat (i, "uu-flood"))
7017 flags |= L2_UU_FLOOD;
7018 else if (unformat (i, "arp-term"))
7019 flags |= L2_ARP_TERM;
7020 else if (unformat (i, "off"))
7022 else if (unformat (i, "disable"))
7028 if (sw_if_index_set == 0)
7030 errmsg ("missing interface name or sw_if_index");
7036 mp->sw_if_index = ntohl (sw_if_index);
7037 mp->feature_bitmap = ntohl (flags);
7038 mp->is_set = is_set;
7046 api_bridge_flags (vat_main_t * vam)
7048 unformat_input_t *i = vam->input;
7049 vl_api_bridge_flags_t *mp;
7053 bd_flags_t flags = 0;
7056 /* Parse args required to build the message */
7057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7059 if (unformat (i, "bd_id %d", &bd_id))
7061 else if (unformat (i, "learn"))
7062 flags |= BRIDGE_API_FLAG_LEARN;
7063 else if (unformat (i, "forward"))
7064 flags |= BRIDGE_API_FLAG_FWD;
7065 else if (unformat (i, "flood"))
7066 flags |= BRIDGE_API_FLAG_FLOOD;
7067 else if (unformat (i, "uu-flood"))
7068 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7069 else if (unformat (i, "arp-term"))
7070 flags |= BRIDGE_API_FLAG_ARP_TERM;
7071 else if (unformat (i, "off"))
7073 else if (unformat (i, "disable"))
7081 errmsg ("missing bridge domain");
7085 M (BRIDGE_FLAGS, mp);
7087 mp->bd_id = ntohl (bd_id);
7088 mp->flags = ntohl (flags);
7089 mp->is_set = is_set;
7097 api_bd_ip_mac_add_del (vat_main_t * vam)
7099 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7100 vl_api_mac_address_t mac = { 0 };
7101 unformat_input_t *i = vam->input;
7102 vl_api_bd_ip_mac_add_del_t *mp;
7111 /* Parse args required to build the message */
7112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7114 if (unformat (i, "bd_id %d", &bd_id))
7118 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7122 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7126 else if (unformat (i, "del"))
7134 errmsg ("missing bridge domain");
7137 else if (ip_set == 0)
7139 errmsg ("missing IP address");
7142 else if (mac_set == 0)
7144 errmsg ("missing MAC address");
7148 M (BD_IP_MAC_ADD_DEL, mp);
7150 mp->entry.bd_id = ntohl (bd_id);
7151 mp->is_add = is_add;
7153 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7154 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7162 api_bd_ip_mac_flush (vat_main_t * vam)
7164 unformat_input_t *i = vam->input;
7165 vl_api_bd_ip_mac_flush_t *mp;
7170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 if (unformat (i, "bd_id %d", &bd_id))
7182 errmsg ("missing bridge domain");
7186 M (BD_IP_MAC_FLUSH, mp);
7188 mp->bd_id = ntohl (bd_id);
7195 static void vl_api_bd_ip_mac_details_t_handler
7196 (vl_api_bd_ip_mac_details_t * mp)
7198 vat_main_t *vam = &vat_main;
7202 ntohl (mp->entry.bd_id),
7203 format_vl_api_mac_address, mp->entry.mac,
7204 format_vl_api_address, &mp->entry.ip);
7207 static void vl_api_bd_ip_mac_details_t_handler_json
7208 (vl_api_bd_ip_mac_details_t * mp)
7210 vat_main_t *vam = &vat_main;
7211 vat_json_node_t *node = NULL;
7213 if (VAT_JSON_ARRAY != vam->json_tree.type)
7215 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7216 vat_json_init_array (&vam->json_tree);
7218 node = vat_json_array_add (&vam->json_tree);
7220 vat_json_init_object (node);
7221 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7222 vat_json_object_add_string_copy (node, "mac_address",
7223 format (0, "%U", format_vl_api_mac_address,
7227 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7228 vat_json_object_add_string_copy (node, "ip_address", ip);
7233 api_bd_ip_mac_dump (vat_main_t * vam)
7235 unformat_input_t *i = vam->input;
7236 vl_api_bd_ip_mac_dump_t *mp;
7237 vl_api_control_ping_t *mp_ping;
7242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7244 if (unformat (i, "bd_id %d", &bd_id))
7253 "\n%-5s %-7s %-20s %-30s",
7254 "bd_id", "is_ipv6", "mac_address", "ip_address");
7256 /* Dump Bridge Domain Ip to Mac entries */
7257 M (BD_IP_MAC_DUMP, mp);
7260 mp->bd_id = htonl (bd_id);
7266 /* Use a control ping for synchronization */
7267 MPING (CONTROL_PING, mp_ping);
7275 api_tap_create_v2 (vat_main_t * vam)
7277 unformat_input_t *i = vam->input;
7278 vl_api_tap_create_v2_t *mp;
7279 #define TAP_FLAG_GSO (1 << 0)
7283 u8 *host_if_name = 0;
7285 u8 host_mac_addr[6];
7286 u8 host_mac_addr_set = 0;
7287 u8 *host_bridge = 0;
7288 ip4_address_t host_ip4_addr;
7289 ip4_address_t host_ip4_gw;
7290 u8 host_ip4_gw_set = 0;
7291 u32 host_ip4_prefix_len = 0;
7292 ip6_address_t host_ip6_addr;
7293 ip6_address_t host_ip6_gw;
7294 u8 host_ip6_gw_set = 0;
7295 u32 host_ip6_prefix_len = 0;
7296 u8 host_mtu_set = 0;
7297 u32 host_mtu_size = 0;
7300 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7302 clib_memset (mac_address, 0, sizeof (mac_address));
7304 /* Parse args required to build the message */
7305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7307 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7311 else if (unformat (i, "id %u", &id))
7313 else if (unformat (i, "host-if-name %s", &host_if_name))
7315 else if (unformat (i, "host-ns %s", &host_ns))
7317 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7319 host_mac_addr_set = 1;
7320 else if (unformat (i, "host-bridge %s", &host_bridge))
7322 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7323 &host_ip4_addr, &host_ip4_prefix_len))
7325 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7326 &host_ip6_addr, &host_ip6_prefix_len))
7328 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7330 host_ip4_gw_set = 1;
7331 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7333 host_ip6_gw_set = 1;
7334 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7336 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7338 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7340 else if (unformat (i, "no-gso"))
7341 tap_flags &= ~TAP_FLAG_GSO;
7342 else if (unformat (i, "gso"))
7343 tap_flags |= TAP_FLAG_GSO;
7344 else if (unformat (i, "csum-offload"))
7345 tap_flags |= TAP_FLAG_CSUM_OFFLOAD;
7350 if (vec_len (host_if_name) > 63)
7352 errmsg ("tap name too long. ");
7355 if (vec_len (host_ns) > 63)
7357 errmsg ("host name space too long. ");
7360 if (vec_len (host_bridge) > 63)
7362 errmsg ("host bridge name too long. ");
7365 if (host_ip4_prefix_len > 32)
7367 errmsg ("host ip4 prefix length not valid. ");
7370 if (host_ip6_prefix_len > 128)
7372 errmsg ("host ip6 prefix length not valid. ");
7375 if (!is_pow2 (rx_ring_sz))
7377 errmsg ("rx ring size must be power of 2. ");
7380 if (rx_ring_sz > 32768)
7382 errmsg ("rx ring size must be 32768 or lower. ");
7385 if (!is_pow2 (tx_ring_sz))
7387 errmsg ("tx ring size must be power of 2. ");
7390 if (tx_ring_sz > 32768)
7392 errmsg ("tx ring size must be 32768 or lower. ");
7395 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7397 errmsg ("host MTU size must be in between 64 and 65355. ");
7401 /* Construct the API message */
7402 M (TAP_CREATE_V2, mp);
7404 mp->use_random_mac = random_mac;
7406 mp->id = ntohl (id);
7407 mp->host_namespace_set = host_ns != 0;
7408 mp->host_bridge_set = host_bridge != 0;
7409 mp->host_ip4_prefix_set = host_ip4_prefix_len != 0;
7410 mp->host_ip6_prefix_set = host_ip6_prefix_len != 0;
7411 mp->rx_ring_sz = ntohs (rx_ring_sz);
7412 mp->tx_ring_sz = ntohs (tx_ring_sz);
7413 mp->host_mtu_set = host_mtu_set;
7414 mp->host_mtu_size = ntohl (host_mtu_size);
7415 mp->tap_flags = ntohl (tap_flags);
7417 if (random_mac == 0)
7418 clib_memcpy (mp->mac_address, mac_address, 6);
7419 if (host_mac_addr_set)
7420 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7422 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7424 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7426 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7427 if (host_ip4_prefix_len)
7428 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7429 if (host_ip6_prefix_len)
7430 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7431 if (host_ip4_gw_set)
7432 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7433 if (host_ip6_gw_set)
7434 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7437 vec_free (host_if_name);
7438 vec_free (host_bridge);
7443 /* Wait for a reply... */
7449 api_tap_delete_v2 (vat_main_t * vam)
7451 unformat_input_t *i = vam->input;
7452 vl_api_tap_delete_v2_t *mp;
7453 u32 sw_if_index = ~0;
7454 u8 sw_if_index_set = 0;
7457 /* Parse args required to build the message */
7458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7460 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7461 sw_if_index_set = 1;
7462 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7463 sw_if_index_set = 1;
7468 if (sw_if_index_set == 0)
7470 errmsg ("missing vpp interface name. ");
7474 /* Construct the API message */
7475 M (TAP_DELETE_V2, mp);
7477 mp->sw_if_index = ntohl (sw_if_index);
7482 /* Wait for a reply... */
7488 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7490 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7493 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7496 addr->domain = x[0];
7499 addr->function = x[3];
7505 api_virtio_pci_create (vat_main_t * vam)
7507 unformat_input_t *i = vam->input;
7508 vl_api_virtio_pci_create_t *mp;
7512 u8 checksum_offload_enabled = 0;
7514 u64 features = (u64) ~ (0ULL);
7517 clib_memset (mac_address, 0, sizeof (mac_address));
7519 /* Parse args required to build the message */
7520 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7522 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7526 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7528 else if (unformat (i, "features 0x%llx", &features))
7530 else if (unformat (i, "gso-enabled"))
7532 else if (unformat (i, "csum-offload-enabled"))
7533 checksum_offload_enabled = 1;
7540 errmsg ("pci address must be non zero. ");
7544 /* Construct the API message */
7545 M (VIRTIO_PCI_CREATE, mp);
7547 mp->use_random_mac = random_mac;
7549 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7550 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7551 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7552 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7554 mp->features = clib_host_to_net_u64 (features);
7555 mp->gso_enabled = gso_enabled;
7556 mp->checksum_offload_enabled = checksum_offload_enabled;
7558 if (random_mac == 0)
7559 clib_memcpy (mp->mac_address, mac_address, 6);
7564 /* Wait for a reply... */
7570 api_virtio_pci_delete (vat_main_t * vam)
7572 unformat_input_t *i = vam->input;
7573 vl_api_virtio_pci_delete_t *mp;
7574 u32 sw_if_index = ~0;
7575 u8 sw_if_index_set = 0;
7578 /* Parse args required to build the message */
7579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7581 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7582 sw_if_index_set = 1;
7583 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7584 sw_if_index_set = 1;
7589 if (sw_if_index_set == 0)
7591 errmsg ("missing vpp interface name. ");
7595 /* Construct the API message */
7596 M (VIRTIO_PCI_DELETE, mp);
7598 mp->sw_if_index = htonl (sw_if_index);
7603 /* Wait for a reply... */
7609 api_bond_create (vat_main_t * vam)
7611 unformat_input_t *i = vam->input;
7612 vl_api_bond_create_t *mp;
7622 clib_memset (mac_address, 0, sizeof (mac_address));
7625 /* Parse args required to build the message */
7626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7628 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7630 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7631 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7633 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7636 else if (unformat (i, "numa-only"))
7638 else if (unformat (i, "id %u", &id))
7644 if (mode_is_set == 0)
7646 errmsg ("Missing bond mode. ");
7650 /* Construct the API message */
7651 M (BOND_CREATE, mp);
7653 mp->use_custom_mac = custom_mac;
7655 mp->mode = htonl (mode);
7656 mp->lb = htonl (lb);
7657 mp->id = htonl (id);
7658 mp->numa_only = numa_only;
7661 clib_memcpy (mp->mac_address, mac_address, 6);
7666 /* Wait for a reply... */
7672 api_bond_delete (vat_main_t * vam)
7674 unformat_input_t *i = vam->input;
7675 vl_api_bond_delete_t *mp;
7676 u32 sw_if_index = ~0;
7677 u8 sw_if_index_set = 0;
7680 /* Parse args required to build the message */
7681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7683 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7684 sw_if_index_set = 1;
7685 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7686 sw_if_index_set = 1;
7691 if (sw_if_index_set == 0)
7693 errmsg ("missing vpp interface name. ");
7697 /* Construct the API message */
7698 M (BOND_DELETE, mp);
7700 mp->sw_if_index = ntohl (sw_if_index);
7705 /* Wait for a reply... */
7711 api_bond_enslave (vat_main_t * vam)
7713 unformat_input_t *i = vam->input;
7714 vl_api_bond_enslave_t *mp;
7715 u32 bond_sw_if_index;
7719 u32 bond_sw_if_index_is_set = 0;
7721 u8 sw_if_index_is_set = 0;
7723 /* Parse args required to build the message */
7724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7726 if (unformat (i, "sw_if_index %d", &sw_if_index))
7727 sw_if_index_is_set = 1;
7728 else if (unformat (i, "bond %u", &bond_sw_if_index))
7729 bond_sw_if_index_is_set = 1;
7730 else if (unformat (i, "passive %d", &is_passive))
7732 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7738 if (bond_sw_if_index_is_set == 0)
7740 errmsg ("Missing bond sw_if_index. ");
7743 if (sw_if_index_is_set == 0)
7745 errmsg ("Missing slave sw_if_index. ");
7749 /* Construct the API message */
7750 M (BOND_ENSLAVE, mp);
7752 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7753 mp->sw_if_index = ntohl (sw_if_index);
7754 mp->is_long_timeout = is_long_timeout;
7755 mp->is_passive = is_passive;
7760 /* Wait for a reply... */
7766 api_bond_detach_slave (vat_main_t * vam)
7768 unformat_input_t *i = vam->input;
7769 vl_api_bond_detach_slave_t *mp;
7770 u32 sw_if_index = ~0;
7771 u8 sw_if_index_set = 0;
7774 /* Parse args required to build the message */
7775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7777 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7778 sw_if_index_set = 1;
7779 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7780 sw_if_index_set = 1;
7785 if (sw_if_index_set == 0)
7787 errmsg ("missing vpp interface name. ");
7791 /* Construct the API message */
7792 M (BOND_DETACH_SLAVE, mp);
7794 mp->sw_if_index = ntohl (sw_if_index);
7799 /* Wait for a reply... */
7805 api_ip_table_add_del (vat_main_t * vam)
7807 unformat_input_t *i = vam->input;
7808 vl_api_ip_table_add_del_t *mp;
7814 /* Parse args required to build the message */
7815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7817 if (unformat (i, "ipv6"))
7819 else if (unformat (i, "del"))
7821 else if (unformat (i, "add"))
7823 else if (unformat (i, "table %d", &table_id))
7827 clib_warning ("parse error '%U'", format_unformat_error, i);
7834 errmsg ("missing table-ID");
7838 /* Construct the API message */
7839 M (IP_TABLE_ADD_DEL, mp);
7841 mp->table.table_id = ntohl (table_id);
7842 mp->table.is_ip6 = is_ipv6;
7843 mp->is_add = is_add;
7848 /* Wait for a reply... */
7855 unformat_fib_path (unformat_input_t * input, va_list * args)
7857 vat_main_t *vam = va_arg (*args, vat_main_t *);
7858 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7859 u32 weight, preference;
7860 mpls_label_t out_label;
7862 clib_memset (path, 0, sizeof (*path));
7864 path->sw_if_index = ~0;
7868 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7870 if (unformat (input, "%U %U",
7871 unformat_vl_api_ip4_address,
7872 &path->nh.address.ip4,
7873 api_unformat_sw_if_index, vam, &path->sw_if_index))
7875 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7877 else if (unformat (input, "%U %U",
7878 unformat_vl_api_ip6_address,
7879 &path->nh.address.ip6,
7880 api_unformat_sw_if_index, vam, &path->sw_if_index))
7882 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7884 else if (unformat (input, "weight %u", &weight))
7886 path->weight = weight;
7888 else if (unformat (input, "preference %u", &preference))
7890 path->preference = preference;
7892 else if (unformat (input, "%U next-hop-table %d",
7893 unformat_vl_api_ip4_address,
7894 &path->nh.address.ip4, &path->table_id))
7896 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7898 else if (unformat (input, "%U next-hop-table %d",
7899 unformat_vl_api_ip6_address,
7900 &path->nh.address.ip6, &path->table_id))
7902 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7904 else if (unformat (input, "%U",
7905 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7908 * the recursive next-hops are by default in the default table
7911 path->sw_if_index = ~0;
7912 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7914 else if (unformat (input, "%U",
7915 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7918 * the recursive next-hops are by default in the default table
7921 path->sw_if_index = ~0;
7922 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7924 else if (unformat (input, "resolve-via-host"))
7926 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7928 else if (unformat (input, "resolve-via-attached"))
7930 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7932 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7934 path->type = FIB_API_PATH_TYPE_LOCAL;
7935 path->sw_if_index = ~0;
7936 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7938 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7940 path->type = FIB_API_PATH_TYPE_LOCAL;
7941 path->sw_if_index = ~0;
7942 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7944 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7946 else if (unformat (input, "via-label %d", &path->nh.via_label))
7948 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7949 path->sw_if_index = ~0;
7951 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7953 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7954 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7956 else if (unformat (input, "local"))
7958 path->type = FIB_API_PATH_TYPE_LOCAL;
7960 else if (unformat (input, "out-labels"))
7962 while (unformat (input, "%d", &out_label))
7964 path->label_stack[path->n_labels].label = out_label;
7965 path->label_stack[path->n_labels].is_uniform = 0;
7966 path->label_stack[path->n_labels].ttl = 64;
7970 else if (unformat (input, "via"))
7972 /* new path, back up and return */
7973 unformat_put_input (input);
7974 unformat_put_input (input);
7975 unformat_put_input (input);
7976 unformat_put_input (input);
7985 path->proto = ntohl (path->proto);
7986 path->type = ntohl (path->type);
7987 path->flags = ntohl (path->flags);
7988 path->table_id = ntohl (path->table_id);
7989 path->sw_if_index = ntohl (path->sw_if_index);
7995 api_ip_route_add_del (vat_main_t * vam)
7997 unformat_input_t *i = vam->input;
7998 vl_api_ip_route_add_del_t *mp;
8001 u8 is_multipath = 0;
8004 vl_api_prefix_t pfx = { };
8005 vl_api_fib_path_t paths[8];
8009 u32 random_add_del = 0;
8010 u32 *random_vector = 0;
8011 u32 random_seed = 0xdeaddabe;
8013 /* Parse args required to build the message */
8014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8016 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8018 else if (unformat (i, "del"))
8020 else if (unformat (i, "add"))
8022 else if (unformat (i, "vrf %d", &vrf_id))
8024 else if (unformat (i, "count %d", &count))
8026 else if (unformat (i, "random"))
8028 else if (unformat (i, "multipath"))
8030 else if (unformat (i, "seed %d", &random_seed))
8034 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8037 if (8 == path_count)
8039 errmsg ("max 8 paths");
8045 clib_warning ("parse error '%U'", format_unformat_error, i);
8052 errmsg ("specify a path; via ...");
8055 if (prefix_set == 0)
8057 errmsg ("missing prefix");
8061 /* Generate a pile of unique, random routes */
8064 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8065 u32 this_random_address;
8068 random_hash = hash_create (count, sizeof (uword));
8070 hash_set (random_hash, i->as_u32, 1);
8071 for (j = 0; j <= count; j++)
8075 this_random_address = random_u32 (&random_seed);
8076 this_random_address =
8077 clib_host_to_net_u32 (this_random_address);
8079 while (hash_get (random_hash, this_random_address));
8080 vec_add1 (random_vector, this_random_address);
8081 hash_set (random_hash, this_random_address, 1);
8083 hash_free (random_hash);
8084 set_ip4_address (&pfx.address, random_vector[0]);
8089 /* Turn on async mode */
8090 vam->async_mode = 1;
8091 vam->async_errors = 0;
8092 before = vat_time_now (vam);
8095 for (j = 0; j < count; j++)
8097 /* Construct the API message */
8098 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8100 mp->is_add = is_add;
8101 mp->is_multipath = is_multipath;
8103 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8104 mp->route.table_id = ntohl (vrf_id);
8105 mp->route.n_paths = path_count;
8107 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8110 set_ip4_address (&pfx.address, random_vector[j + 1]);
8112 increment_address (&pfx.address);
8115 /* If we receive SIGTERM, stop now... */
8120 /* When testing multiple add/del ops, use a control-ping to sync */
8123 vl_api_control_ping_t *mp_ping;
8127 /* Shut off async mode */
8128 vam->async_mode = 0;
8130 MPING (CONTROL_PING, mp_ping);
8133 timeout = vat_time_now (vam) + 1.0;
8134 while (vat_time_now (vam) < timeout)
8135 if (vam->result_ready == 1)
8140 if (vam->retval == -99)
8143 if (vam->async_errors > 0)
8145 errmsg ("%d asynchronous errors", vam->async_errors);
8148 vam->async_errors = 0;
8149 after = vat_time_now (vam);
8151 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8155 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8156 count, after - before, count / (after - before));
8162 /* Wait for a reply... */
8167 /* Return the good/bad news */
8168 return (vam->retval);
8172 api_ip_mroute_add_del (vat_main_t * vam)
8174 unformat_input_t *i = vam->input;
8175 u8 path_set = 0, prefix_set = 0, is_add = 1;
8176 vl_api_ip_mroute_add_del_t *mp;
8177 mfib_entry_flags_t eflags = 0;
8178 vl_api_mfib_path_t path;
8179 vl_api_mprefix_t pfx = { };
8183 /* Parse args required to build the message */
8184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8186 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8189 pfx.grp_address_length = htons (pfx.grp_address_length);
8191 else if (unformat (i, "del"))
8193 else if (unformat (i, "add"))
8195 else if (unformat (i, "vrf %d", &vrf_id))
8197 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8198 path.itf_flags = htonl (path.itf_flags);
8199 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8201 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8205 clib_warning ("parse error '%U'", format_unformat_error, i);
8210 if (prefix_set == 0)
8212 errmsg ("missing addresses\n");
8217 errmsg ("missing path\n");
8221 /* Construct the API message */
8222 M (IP_MROUTE_ADD_DEL, mp);
8224 mp->is_add = is_add;
8225 mp->is_multipath = 1;
8227 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8228 mp->route.table_id = htonl (vrf_id);
8229 mp->route.n_paths = 1;
8230 mp->route.entry_flags = htonl (eflags);
8232 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8236 /* Wait for a reply... */
8242 api_mpls_table_add_del (vat_main_t * vam)
8244 unformat_input_t *i = vam->input;
8245 vl_api_mpls_table_add_del_t *mp;
8250 /* Parse args required to build the message */
8251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8253 if (unformat (i, "table %d", &table_id))
8255 else if (unformat (i, "del"))
8257 else if (unformat (i, "add"))
8261 clib_warning ("parse error '%U'", format_unformat_error, i);
8268 errmsg ("missing table-ID");
8272 /* Construct the API message */
8273 M (MPLS_TABLE_ADD_DEL, mp);
8275 mp->mt_table.mt_table_id = ntohl (table_id);
8276 mp->mt_is_add = is_add;
8281 /* Wait for a reply... */
8288 api_mpls_route_add_del (vat_main_t * vam)
8290 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8291 mpls_label_t local_label = MPLS_LABEL_INVALID;
8292 unformat_input_t *i = vam->input;
8293 vl_api_mpls_route_add_del_t *mp;
8294 vl_api_fib_path_t paths[8];
8298 /* Parse args required to build the message */
8299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8301 if (unformat (i, "%d", &local_label))
8303 else if (unformat (i, "eos"))
8305 else if (unformat (i, "non-eos"))
8307 else if (unformat (i, "del"))
8309 else if (unformat (i, "add"))
8311 else if (unformat (i, "multipath"))
8313 else if (unformat (i, "count %d", &count))
8317 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8320 if (8 == path_count)
8322 errmsg ("max 8 paths");
8328 clib_warning ("parse error '%U'", format_unformat_error, i);
8335 errmsg ("specify a path; via ...");
8339 if (MPLS_LABEL_INVALID == local_label)
8341 errmsg ("missing label");
8347 /* Turn on async mode */
8348 vam->async_mode = 1;
8349 vam->async_errors = 0;
8350 before = vat_time_now (vam);
8353 for (j = 0; j < count; j++)
8355 /* Construct the API message */
8356 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8358 mp->mr_is_add = is_add;
8359 mp->mr_is_multipath = is_multipath;
8361 mp->mr_route.mr_label = local_label;
8362 mp->mr_route.mr_eos = is_eos;
8363 mp->mr_route.mr_table_id = 0;
8364 mp->mr_route.mr_n_paths = path_count;
8366 clib_memcpy (&mp->mr_route.mr_paths, paths,
8367 sizeof (paths[0]) * path_count);
8373 /* If we receive SIGTERM, stop now... */
8378 /* When testing multiple add/del ops, use a control-ping to sync */
8381 vl_api_control_ping_t *mp_ping;
8385 /* Shut off async mode */
8386 vam->async_mode = 0;
8388 MPING (CONTROL_PING, mp_ping);
8391 timeout = vat_time_now (vam) + 1.0;
8392 while (vat_time_now (vam) < timeout)
8393 if (vam->result_ready == 1)
8398 if (vam->retval == -99)
8401 if (vam->async_errors > 0)
8403 errmsg ("%d asynchronous errors", vam->async_errors);
8406 vam->async_errors = 0;
8407 after = vat_time_now (vam);
8409 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8413 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8414 count, after - before, count / (after - before));
8420 /* Wait for a reply... */
8425 /* Return the good/bad news */
8426 return (vam->retval);
8431 api_mpls_ip_bind_unbind (vat_main_t * vam)
8433 unformat_input_t *i = vam->input;
8434 vl_api_mpls_ip_bind_unbind_t *mp;
8435 u32 ip_table_id = 0;
8437 vl_api_prefix_t pfx;
8439 mpls_label_t local_label = MPLS_LABEL_INVALID;
8442 /* Parse args required to build the message */
8443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8445 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8447 else if (unformat (i, "%d", &local_label))
8449 else if (unformat (i, "table-id %d", &ip_table_id))
8451 else if (unformat (i, "unbind"))
8453 else if (unformat (i, "bind"))
8457 clib_warning ("parse error '%U'", format_unformat_error, i);
8464 errmsg ("IP prefix not set");
8468 if (MPLS_LABEL_INVALID == local_label)
8470 errmsg ("missing label");
8474 /* Construct the API message */
8475 M (MPLS_IP_BIND_UNBIND, mp);
8477 mp->mb_is_bind = is_bind;
8478 mp->mb_ip_table_id = ntohl (ip_table_id);
8479 mp->mb_mpls_table_id = 0;
8480 mp->mb_label = ntohl (local_label);
8481 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8486 /* Wait for a reply... */
8493 api_sr_mpls_policy_add (vat_main_t * vam)
8495 unformat_input_t *i = vam->input;
8496 vl_api_sr_mpls_policy_add_t *mp;
8502 u32 *segments = NULL;
8505 /* Parse args required to build the message */
8506 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8508 if (unformat (i, "bsid %d", &bsid))
8510 else if (unformat (i, "weight %d", &weight))
8512 else if (unformat (i, "spray"))
8514 else if (unformat (i, "next %d", &sid))
8517 vec_add1 (segments, htonl (sid));
8521 clib_warning ("parse error '%U'", format_unformat_error, i);
8528 errmsg ("bsid not set");
8532 if (n_segments == 0)
8534 errmsg ("no sid in segment stack");
8538 /* Construct the API message */
8539 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8541 mp->bsid = htonl (bsid);
8542 mp->weight = htonl (weight);
8544 mp->n_segments = n_segments;
8545 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8546 vec_free (segments);
8551 /* Wait for a reply... */
8557 api_sr_mpls_policy_del (vat_main_t * vam)
8559 unformat_input_t *i = vam->input;
8560 vl_api_sr_mpls_policy_del_t *mp;
8564 /* Parse args required to build the message */
8565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8567 if (unformat (i, "bsid %d", &bsid))
8571 clib_warning ("parse error '%U'", format_unformat_error, i);
8578 errmsg ("bsid not set");
8582 /* Construct the API message */
8583 M (SR_MPLS_POLICY_DEL, mp);
8585 mp->bsid = htonl (bsid);
8590 /* Wait for a reply... */
8596 api_bier_table_add_del (vat_main_t * vam)
8598 unformat_input_t *i = vam->input;
8599 vl_api_bier_table_add_del_t *mp;
8601 u32 set = 0, sub_domain = 0, hdr_len = 3;
8602 mpls_label_t local_label = MPLS_LABEL_INVALID;
8605 /* Parse args required to build the message */
8606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8608 if (unformat (i, "sub-domain %d", &sub_domain))
8610 else if (unformat (i, "set %d", &set))
8612 else if (unformat (i, "label %d", &local_label))
8614 else if (unformat (i, "hdr-len %d", &hdr_len))
8616 else if (unformat (i, "add"))
8618 else if (unformat (i, "del"))
8622 clib_warning ("parse error '%U'", format_unformat_error, i);
8627 if (MPLS_LABEL_INVALID == local_label)
8629 errmsg ("missing label\n");
8633 /* Construct the API message */
8634 M (BIER_TABLE_ADD_DEL, mp);
8636 mp->bt_is_add = is_add;
8637 mp->bt_label = ntohl (local_label);
8638 mp->bt_tbl_id.bt_set = set;
8639 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8640 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8645 /* Wait for a reply... */
8652 api_bier_route_add_del (vat_main_t * vam)
8654 unformat_input_t *i = vam->input;
8655 vl_api_bier_route_add_del_t *mp;
8657 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8658 ip4_address_t v4_next_hop_address;
8659 ip6_address_t v6_next_hop_address;
8660 u8 next_hop_set = 0;
8661 u8 next_hop_proto_is_ip4 = 1;
8662 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8665 /* Parse args required to build the message */
8666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8668 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8670 next_hop_proto_is_ip4 = 1;
8673 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8675 next_hop_proto_is_ip4 = 0;
8678 if (unformat (i, "sub-domain %d", &sub_domain))
8680 else if (unformat (i, "set %d", &set))
8682 else if (unformat (i, "hdr-len %d", &hdr_len))
8684 else if (unformat (i, "bp %d", &bp))
8686 else if (unformat (i, "add"))
8688 else if (unformat (i, "del"))
8690 else if (unformat (i, "out-label %d", &next_hop_out_label))
8694 clib_warning ("parse error '%U'", format_unformat_error, i);
8699 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8701 errmsg ("next hop / label set\n");
8706 errmsg ("bit=position not set\n");
8710 /* Construct the API message */
8711 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8713 mp->br_is_add = is_add;
8714 mp->br_route.br_tbl_id.bt_set = set;
8715 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8716 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8717 mp->br_route.br_bp = ntohs (bp);
8718 mp->br_route.br_n_paths = 1;
8719 mp->br_route.br_paths[0].n_labels = 1;
8720 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8721 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8722 FIB_API_PATH_NH_PROTO_IP4 :
8723 FIB_API_PATH_NH_PROTO_IP6);
8725 if (next_hop_proto_is_ip4)
8727 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8728 &v4_next_hop_address, sizeof (v4_next_hop_address));
8732 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8733 &v6_next_hop_address, sizeof (v6_next_hop_address));
8739 /* Wait for a reply... */
8746 api_mpls_tunnel_add_del (vat_main_t * vam)
8748 unformat_input_t *i = vam->input;
8749 vl_api_mpls_tunnel_add_del_t *mp;
8751 vl_api_fib_path_t paths[8];
8752 u32 sw_if_index = ~0;
8758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8760 if (unformat (i, "add"))
8764 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8766 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8768 else if (unformat (i, "l2-only"))
8772 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8775 if (8 == path_count)
8777 errmsg ("max 8 paths");
8783 clib_warning ("parse error '%U'", format_unformat_error, i);
8788 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8790 mp->mt_is_add = is_add;
8791 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8792 mp->mt_tunnel.mt_l2_only = l2_only;
8793 mp->mt_tunnel.mt_is_multicast = 0;
8794 mp->mt_tunnel.mt_n_paths = path_count;
8796 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8797 sizeof (paths[0]) * path_count);
8805 api_sw_interface_set_unnumbered (vat_main_t * vam)
8807 unformat_input_t *i = vam->input;
8808 vl_api_sw_interface_set_unnumbered_t *mp;
8810 u32 unnum_sw_index = ~0;
8812 u8 sw_if_index_set = 0;
8815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8817 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8818 sw_if_index_set = 1;
8819 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8820 sw_if_index_set = 1;
8821 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8823 else if (unformat (i, "del"))
8827 clib_warning ("parse error '%U'", format_unformat_error, i);
8832 if (sw_if_index_set == 0)
8834 errmsg ("missing interface name or sw_if_index");
8838 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8840 mp->sw_if_index = ntohl (sw_if_index);
8841 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8842 mp->is_add = is_add;
8851 api_create_vlan_subif (vat_main_t * vam)
8853 unformat_input_t *i = vam->input;
8854 vl_api_create_vlan_subif_t *mp;
8856 u8 sw_if_index_set = 0;
8861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8863 if (unformat (i, "sw_if_index %d", &sw_if_index))
8864 sw_if_index_set = 1;
8866 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8867 sw_if_index_set = 1;
8868 else if (unformat (i, "vlan %d", &vlan_id))
8872 clib_warning ("parse error '%U'", format_unformat_error, i);
8877 if (sw_if_index_set == 0)
8879 errmsg ("missing interface name or sw_if_index");
8883 if (vlan_id_set == 0)
8885 errmsg ("missing vlan_id");
8888 M (CREATE_VLAN_SUBIF, mp);
8890 mp->sw_if_index = ntohl (sw_if_index);
8891 mp->vlan_id = ntohl (vlan_id);
8898 #define foreach_create_subif_bit \
8905 _(outer_vlan_id_any) \
8906 _(inner_vlan_id_any)
8908 #define foreach_create_subif_flag \
8913 _(4, "exact_match") \
8914 _(5, "default_sub") \
8915 _(6, "outer_vlan_id_any") \
8916 _(7, "inner_vlan_id_any")
8919 api_create_subif (vat_main_t * vam)
8921 unformat_input_t *i = vam->input;
8922 vl_api_create_subif_t *mp;
8924 u8 sw_if_index_set = 0;
8927 u32 __attribute__ ((unused)) no_tags = 0;
8928 u32 __attribute__ ((unused)) one_tag = 0;
8929 u32 __attribute__ ((unused)) two_tags = 0;
8930 u32 __attribute__ ((unused)) dot1ad = 0;
8931 u32 __attribute__ ((unused)) exact_match = 0;
8932 u32 __attribute__ ((unused)) default_sub = 0;
8933 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8934 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8936 u16 outer_vlan_id = 0;
8937 u16 inner_vlan_id = 0;
8940 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8942 if (unformat (i, "sw_if_index %d", &sw_if_index))
8943 sw_if_index_set = 1;
8945 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8946 sw_if_index_set = 1;
8947 else if (unformat (i, "sub_id %d", &sub_id))
8949 else if (unformat (i, "outer_vlan_id %d", &tmp))
8950 outer_vlan_id = tmp;
8951 else if (unformat (i, "inner_vlan_id %d", &tmp))
8952 inner_vlan_id = tmp;
8954 #define _(a) else if (unformat (i, #a)) a = 1 ;
8955 foreach_create_subif_bit
8959 clib_warning ("parse error '%U'", format_unformat_error, i);
8964 if (sw_if_index_set == 0)
8966 errmsg ("missing interface name or sw_if_index");
8970 if (sub_id_set == 0)
8972 errmsg ("missing sub_id");
8975 M (CREATE_SUBIF, mp);
8977 mp->sw_if_index = ntohl (sw_if_index);
8978 mp->sub_id = ntohl (sub_id);
8980 #define _(a,b) mp->sub_if_flags |= (1 << a);
8981 foreach_create_subif_flag;
8984 mp->outer_vlan_id = ntohs (outer_vlan_id);
8985 mp->inner_vlan_id = ntohs (inner_vlan_id);
8993 api_ip_table_replace_begin (vat_main_t * vam)
8995 unformat_input_t *i = vam->input;
8996 vl_api_ip_table_replace_begin_t *mp;
9001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9003 if (unformat (i, "table %d", &table_id))
9005 else if (unformat (i, "ipv6"))
9009 clib_warning ("parse error '%U'", format_unformat_error, i);
9014 M (IP_TABLE_REPLACE_BEGIN, mp);
9016 mp->table.table_id = ntohl (table_id);
9017 mp->table.is_ip6 = is_ipv6;
9025 api_ip_table_flush (vat_main_t * vam)
9027 unformat_input_t *i = vam->input;
9028 vl_api_ip_table_flush_t *mp;
9033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9035 if (unformat (i, "table %d", &table_id))
9037 else if (unformat (i, "ipv6"))
9041 clib_warning ("parse error '%U'", format_unformat_error, i);
9046 M (IP_TABLE_FLUSH, mp);
9048 mp->table.table_id = ntohl (table_id);
9049 mp->table.is_ip6 = is_ipv6;
9057 api_ip_table_replace_end (vat_main_t * vam)
9059 unformat_input_t *i = vam->input;
9060 vl_api_ip_table_replace_end_t *mp;
9065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9067 if (unformat (i, "table %d", &table_id))
9069 else if (unformat (i, "ipv6"))
9073 clib_warning ("parse error '%U'", format_unformat_error, i);
9078 M (IP_TABLE_REPLACE_END, mp);
9080 mp->table.table_id = ntohl (table_id);
9081 mp->table.is_ip6 = is_ipv6;
9089 api_set_ip_flow_hash (vat_main_t * vam)
9091 unformat_input_t *i = vam->input;
9092 vl_api_set_ip_flow_hash_t *mp;
9104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9106 if (unformat (i, "vrf %d", &vrf_id))
9108 else if (unformat (i, "ipv6"))
9110 else if (unformat (i, "src"))
9112 else if (unformat (i, "dst"))
9114 else if (unformat (i, "sport"))
9116 else if (unformat (i, "dport"))
9118 else if (unformat (i, "proto"))
9120 else if (unformat (i, "reverse"))
9125 clib_warning ("parse error '%U'", format_unformat_error, i);
9130 if (vrf_id_set == 0)
9132 errmsg ("missing vrf id");
9136 M (SET_IP_FLOW_HASH, mp);
9142 mp->reverse = reverse;
9143 mp->vrf_id = ntohl (vrf_id);
9144 mp->is_ipv6 = is_ipv6;
9152 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9154 unformat_input_t *i = vam->input;
9155 vl_api_sw_interface_ip6_enable_disable_t *mp;
9157 u8 sw_if_index_set = 0;
9161 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9163 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9164 sw_if_index_set = 1;
9165 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9166 sw_if_index_set = 1;
9167 else if (unformat (i, "enable"))
9169 else if (unformat (i, "disable"))
9173 clib_warning ("parse error '%U'", format_unformat_error, i);
9178 if (sw_if_index_set == 0)
9180 errmsg ("missing interface name or sw_if_index");
9184 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9186 mp->sw_if_index = ntohl (sw_if_index);
9187 mp->enable = enable;
9196 api_l2_patch_add_del (vat_main_t * vam)
9198 unformat_input_t *i = vam->input;
9199 vl_api_l2_patch_add_del_t *mp;
9201 u8 rx_sw_if_index_set = 0;
9203 u8 tx_sw_if_index_set = 0;
9207 /* Parse args required to build the message */
9208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9210 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9211 rx_sw_if_index_set = 1;
9212 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9213 tx_sw_if_index_set = 1;
9214 else if (unformat (i, "rx"))
9216 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9218 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9220 rx_sw_if_index_set = 1;
9225 else if (unformat (i, "tx"))
9227 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9229 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9231 tx_sw_if_index_set = 1;
9236 else if (unformat (i, "del"))
9242 if (rx_sw_if_index_set == 0)
9244 errmsg ("missing rx interface name or rx_sw_if_index");
9248 if (tx_sw_if_index_set == 0)
9250 errmsg ("missing tx interface name or tx_sw_if_index");
9254 M (L2_PATCH_ADD_DEL, mp);
9256 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9257 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9258 mp->is_add = is_add;
9266 u8 localsid_addr[16];
9275 api_sr_localsid_add_del (vat_main_t * vam)
9277 unformat_input_t *i = vam->input;
9278 vl_api_sr_localsid_add_del_t *mp;
9281 ip6_address_t localsid;
9285 u32 fib_table = ~(u32) 0;
9286 ip6_address_t nh_addr6;
9287 ip4_address_t nh_addr4;
9288 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9289 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9291 bool nexthop_set = 0;
9295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9297 if (unformat (i, "del"))
9299 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9300 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9302 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9304 else if (unformat (i, "behavior %u", &behavior));
9305 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9306 else if (unformat (i, "fib-table %u", &fib_table));
9307 else if (unformat (i, "end.psp %u", &behavior));
9312 M (SR_LOCALSID_ADD_DEL, mp);
9314 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9318 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9319 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9321 mp->behavior = behavior;
9322 mp->sw_if_index = ntohl (sw_if_index);
9323 mp->fib_table = ntohl (fib_table);
9324 mp->end_psp = end_psp;
9325 mp->is_del = is_del;
9333 api_ioam_enable (vat_main_t * vam)
9335 unformat_input_t *input = vam->input;
9336 vl_api_ioam_enable_t *mp;
9338 int has_trace_option = 0;
9339 int has_pot_option = 0;
9340 int has_seqno_option = 0;
9341 int has_analyse_option = 0;
9344 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9346 if (unformat (input, "trace"))
9347 has_trace_option = 1;
9348 else if (unformat (input, "pot"))
9350 else if (unformat (input, "seqno"))
9351 has_seqno_option = 1;
9352 else if (unformat (input, "analyse"))
9353 has_analyse_option = 1;
9357 M (IOAM_ENABLE, mp);
9358 mp->id = htons (id);
9359 mp->seqno = has_seqno_option;
9360 mp->analyse = has_analyse_option;
9361 mp->pot_enable = has_pot_option;
9362 mp->trace_enable = has_trace_option;
9371 api_ioam_disable (vat_main_t * vam)
9373 vl_api_ioam_disable_t *mp;
9376 M (IOAM_DISABLE, mp);
9382 #define foreach_tcp_proto_field \
9386 #define foreach_udp_proto_field \
9390 #define foreach_ip4_proto_field \
9402 u16 src_port, dst_port;
9405 #if VPP_API_TEST_BUILTIN == 0
9407 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9409 u8 **maskp = va_arg (*args, u8 **);
9411 u8 found_something = 0;
9414 #define _(a) u8 a=0;
9415 foreach_tcp_proto_field;
9418 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9421 #define _(a) else if (unformat (input, #a)) a=1;
9422 foreach_tcp_proto_field
9428 #define _(a) found_something += a;
9429 foreach_tcp_proto_field;
9432 if (found_something == 0)
9435 vec_validate (mask, sizeof (*tcp) - 1);
9437 tcp = (tcp_header_t *) mask;
9439 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9440 foreach_tcp_proto_field;
9448 unformat_udp_mask (unformat_input_t * input, va_list * args)
9450 u8 **maskp = va_arg (*args, u8 **);
9452 u8 found_something = 0;
9455 #define _(a) u8 a=0;
9456 foreach_udp_proto_field;
9459 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9462 #define _(a) else if (unformat (input, #a)) a=1;
9463 foreach_udp_proto_field
9469 #define _(a) found_something += a;
9470 foreach_udp_proto_field;
9473 if (found_something == 0)
9476 vec_validate (mask, sizeof (*udp) - 1);
9478 udp = (udp_header_t *) mask;
9480 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9481 foreach_udp_proto_field;
9489 unformat_l4_mask (unformat_input_t * input, va_list * args)
9491 u8 **maskp = va_arg (*args, u8 **);
9492 u16 src_port = 0, dst_port = 0;
9493 tcpudp_header_t *tcpudp;
9495 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9497 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9499 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9501 else if (unformat (input, "src_port"))
9503 else if (unformat (input, "dst_port"))
9509 if (!src_port && !dst_port)
9513 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9515 tcpudp = (tcpudp_header_t *) mask;
9516 tcpudp->src_port = src_port;
9517 tcpudp->dst_port = dst_port;
9525 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9527 u8 **maskp = va_arg (*args, u8 **);
9529 u8 found_something = 0;
9532 #define _(a) u8 a=0;
9533 foreach_ip4_proto_field;
9539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9541 if (unformat (input, "version"))
9543 else if (unformat (input, "hdr_length"))
9545 else if (unformat (input, "src"))
9547 else if (unformat (input, "dst"))
9549 else if (unformat (input, "proto"))
9552 #define _(a) else if (unformat (input, #a)) a=1;
9553 foreach_ip4_proto_field
9559 #define _(a) found_something += a;
9560 foreach_ip4_proto_field;
9563 if (found_something == 0)
9566 vec_validate (mask, sizeof (*ip) - 1);
9568 ip = (ip4_header_t *) mask;
9570 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9571 foreach_ip4_proto_field;
9574 ip->ip_version_and_header_length = 0;
9577 ip->ip_version_and_header_length |= 0xF0;
9580 ip->ip_version_and_header_length |= 0x0F;
9586 #define foreach_ip6_proto_field \
9594 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9596 u8 **maskp = va_arg (*args, u8 **);
9598 u8 found_something = 0;
9600 u32 ip_version_traffic_class_and_flow_label;
9602 #define _(a) u8 a=0;
9603 foreach_ip6_proto_field;
9606 u8 traffic_class = 0;
9609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9611 if (unformat (input, "version"))
9613 else if (unformat (input, "traffic-class"))
9615 else if (unformat (input, "flow-label"))
9617 else if (unformat (input, "src"))
9619 else if (unformat (input, "dst"))
9621 else if (unformat (input, "proto"))
9624 #define _(a) else if (unformat (input, #a)) a=1;
9625 foreach_ip6_proto_field
9631 #define _(a) found_something += a;
9632 foreach_ip6_proto_field;
9635 if (found_something == 0)
9638 vec_validate (mask, sizeof (*ip) - 1);
9640 ip = (ip6_header_t *) mask;
9642 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9643 foreach_ip6_proto_field;
9646 ip_version_traffic_class_and_flow_label = 0;
9649 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9652 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9655 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9657 ip->ip_version_traffic_class_and_flow_label =
9658 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9665 unformat_l3_mask (unformat_input_t * input, va_list * args)
9667 u8 **maskp = va_arg (*args, u8 **);
9669 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9671 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9673 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9682 unformat_l2_mask (unformat_input_t * input, va_list * args)
9684 u8 **maskp = va_arg (*args, u8 **);
9699 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9701 if (unformat (input, "src"))
9703 else if (unformat (input, "dst"))
9705 else if (unformat (input, "proto"))
9707 else if (unformat (input, "tag1"))
9709 else if (unformat (input, "tag2"))
9711 else if (unformat (input, "ignore-tag1"))
9713 else if (unformat (input, "ignore-tag2"))
9715 else if (unformat (input, "cos1"))
9717 else if (unformat (input, "cos2"))
9719 else if (unformat (input, "dot1q"))
9721 else if (unformat (input, "dot1ad"))
9726 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9727 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9730 if (tag1 || ignore_tag1 || cos1 || dot1q)
9732 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9735 vec_validate (mask, len - 1);
9738 clib_memset (mask, 0xff, 6);
9741 clib_memset (mask + 6, 0xff, 6);
9745 /* inner vlan tag */
9754 mask[21] = mask[20] = 0xff;
9775 mask[16] = mask[17] = 0xff;
9785 mask[12] = mask[13] = 0xff;
9792 unformat_classify_mask (unformat_input_t * input, va_list * args)
9794 u8 **maskp = va_arg (*args, u8 **);
9795 u32 *skipp = va_arg (*args, u32 *);
9796 u32 *matchp = va_arg (*args, u32 *);
9804 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9806 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9808 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9810 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9812 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9826 if (mask || l2 || l3 || l4)
9830 /* "With a free Ethernet header in every package" */
9832 vec_validate (l2, 13);
9836 vec_append (mask, l3);
9841 vec_append (mask, l4);
9846 /* Scan forward looking for the first significant mask octet */
9847 for (i = 0; i < vec_len (mask); i++)
9851 /* compute (skip, match) params */
9852 *skipp = i / sizeof (u32x4);
9853 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9855 /* Pad mask to an even multiple of the vector size */
9856 while (vec_len (mask) % sizeof (u32x4))
9859 match = vec_len (mask) / sizeof (u32x4);
9861 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9863 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9864 if (*tmp || *(tmp + 1))
9869 clib_warning ("BUG: match 0");
9871 _vec_len (mask) = match * sizeof (u32x4);
9881 #endif /* VPP_API_TEST_BUILTIN */
9883 #define foreach_l2_next \
9885 _(ethernet, ETHERNET_INPUT) \
9890 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9892 u32 *miss_next_indexp = va_arg (*args, u32 *);
9897 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9901 if (unformat (input, "%d", &tmp))
9910 *miss_next_indexp = next_index;
9914 #define foreach_ip_next \
9920 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9922 u32 *miss_next_indexp = va_arg (*args, u32 *);
9927 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9931 if (unformat (input, "%d", &tmp))
9940 *miss_next_indexp = next_index;
9944 #define foreach_acl_next \
9948 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9950 u32 *miss_next_indexp = va_arg (*args, u32 *);
9955 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9959 if (unformat (input, "permit"))
9964 else if (unformat (input, "%d", &tmp))
9973 *miss_next_indexp = next_index;
9978 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9980 u32 *r = va_arg (*args, u32 *);
9982 if (unformat (input, "conform-color"))
9983 *r = POLICE_CONFORM;
9984 else if (unformat (input, "exceed-color"))
9993 api_classify_add_del_table (vat_main_t * vam)
9995 unformat_input_t *i = vam->input;
9996 vl_api_classify_add_del_table_t *mp;
10003 u32 table_index = ~0;
10004 u32 next_table_index = ~0;
10005 u32 miss_next_index = ~0;
10006 u32 memory_size = 32 << 20;
10008 u32 current_data_flag = 0;
10009 int current_data_offset = 0;
10012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10014 if (unformat (i, "del"))
10016 else if (unformat (i, "del-chain"))
10021 else if (unformat (i, "buckets %d", &nbuckets))
10023 else if (unformat (i, "memory_size %d", &memory_size))
10025 else if (unformat (i, "skip %d", &skip))
10027 else if (unformat (i, "match %d", &match))
10029 else if (unformat (i, "table %d", &table_index))
10031 else if (unformat (i, "mask %U", unformat_classify_mask,
10032 &mask, &skip, &match))
10034 else if (unformat (i, "next-table %d", &next_table_index))
10036 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10039 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10042 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10045 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10047 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10053 if (is_add && mask == 0)
10055 errmsg ("Mask required");
10059 if (is_add && skip == ~0)
10061 errmsg ("skip count required");
10065 if (is_add && match == ~0)
10067 errmsg ("match count required");
10071 if (!is_add && table_index == ~0)
10073 errmsg ("table index required for delete");
10077 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10079 mp->is_add = is_add;
10080 mp->del_chain = del_chain;
10081 mp->table_index = ntohl (table_index);
10082 mp->nbuckets = ntohl (nbuckets);
10083 mp->memory_size = ntohl (memory_size);
10084 mp->skip_n_vectors = ntohl (skip);
10085 mp->match_n_vectors = ntohl (match);
10086 mp->next_table_index = ntohl (next_table_index);
10087 mp->miss_next_index = ntohl (miss_next_index);
10088 mp->current_data_flag = ntohl (current_data_flag);
10089 mp->current_data_offset = ntohl (current_data_offset);
10090 mp->mask_len = ntohl (vec_len (mask));
10091 clib_memcpy (mp->mask, mask, vec_len (mask));
10100 #if VPP_API_TEST_BUILTIN == 0
10102 unformat_l4_match (unformat_input_t * input, va_list * args)
10104 u8 **matchp = va_arg (*args, u8 **);
10106 u8 *proto_header = 0;
10112 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10114 if (unformat (input, "src_port %d", &src_port))
10116 else if (unformat (input, "dst_port %d", &dst_port))
10122 h.src_port = clib_host_to_net_u16 (src_port);
10123 h.dst_port = clib_host_to_net_u16 (dst_port);
10124 vec_validate (proto_header, sizeof (h) - 1);
10125 memcpy (proto_header, &h, sizeof (h));
10127 *matchp = proto_header;
10133 unformat_ip4_match (unformat_input_t * input, va_list * args)
10135 u8 **matchp = va_arg (*args, u8 **);
10140 int hdr_length = 0;
10141 u32 hdr_length_val;
10142 int src = 0, dst = 0;
10143 ip4_address_t src_val, dst_val;
10150 int fragment_id = 0;
10151 u32 fragment_id_val;
10157 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10159 if (unformat (input, "version %d", &version_val))
10161 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10163 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10165 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10167 else if (unformat (input, "proto %d", &proto_val))
10169 else if (unformat (input, "tos %d", &tos_val))
10171 else if (unformat (input, "length %d", &length_val))
10173 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10175 else if (unformat (input, "ttl %d", &ttl_val))
10177 else if (unformat (input, "checksum %d", &checksum_val))
10183 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10184 + ttl + checksum == 0)
10188 * Aligned because we use the real comparison functions
10190 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10192 ip = (ip4_header_t *) match;
10194 /* These are realistically matched in practice */
10196 ip->src_address.as_u32 = src_val.as_u32;
10199 ip->dst_address.as_u32 = dst_val.as_u32;
10202 ip->protocol = proto_val;
10205 /* These are not, but they're included for completeness */
10207 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10210 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10216 ip->length = clib_host_to_net_u16 (length_val);
10222 ip->checksum = clib_host_to_net_u16 (checksum_val);
10229 unformat_ip6_match (unformat_input_t * input, va_list * args)
10231 u8 **matchp = va_arg (*args, u8 **);
10236 u8 traffic_class = 0;
10237 u32 traffic_class_val = 0;
10240 int src = 0, dst = 0;
10241 ip6_address_t src_val, dst_val;
10244 int payload_length = 0;
10245 u32 payload_length_val;
10248 u32 ip_version_traffic_class_and_flow_label;
10250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10252 if (unformat (input, "version %d", &version_val))
10254 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10256 else if (unformat (input, "flow_label %d", &flow_label_val))
10258 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10260 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10262 else if (unformat (input, "proto %d", &proto_val))
10264 else if (unformat (input, "payload_length %d", &payload_length_val))
10265 payload_length = 1;
10266 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10272 if (version + traffic_class + flow_label + src + dst + proto +
10273 payload_length + hop_limit == 0)
10277 * Aligned because we use the real comparison functions
10279 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10281 ip = (ip6_header_t *) match;
10284 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10287 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10290 ip->protocol = proto_val;
10292 ip_version_traffic_class_and_flow_label = 0;
10295 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10298 ip_version_traffic_class_and_flow_label |=
10299 (traffic_class_val & 0xFF) << 20;
10302 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10304 ip->ip_version_traffic_class_and_flow_label =
10305 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10307 if (payload_length)
10308 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10311 ip->hop_limit = hop_limit_val;
10318 unformat_l3_match (unformat_input_t * input, va_list * args)
10320 u8 **matchp = va_arg (*args, u8 **);
10322 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10324 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10326 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10335 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10337 u8 *tagp = va_arg (*args, u8 *);
10340 if (unformat (input, "%d", &tag))
10342 tagp[0] = (tag >> 8) & 0x0F;
10343 tagp[1] = tag & 0xFF;
10351 unformat_l2_match (unformat_input_t * input, va_list * args)
10353 u8 **matchp = va_arg (*args, u8 **);
10366 u8 ignore_tag1 = 0;
10367 u8 ignore_tag2 = 0;
10373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10375 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10378 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10380 else if (unformat (input, "proto %U",
10381 unformat_ethernet_type_host_byte_order, &proto_val))
10383 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10385 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10387 else if (unformat (input, "ignore-tag1"))
10389 else if (unformat (input, "ignore-tag2"))
10391 else if (unformat (input, "cos1 %d", &cos1_val))
10393 else if (unformat (input, "cos2 %d", &cos2_val))
10398 if ((src + dst + proto + tag1 + tag2 +
10399 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10402 if (tag1 || ignore_tag1 || cos1)
10404 if (tag2 || ignore_tag2 || cos2)
10407 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10410 clib_memcpy (match, dst_val, 6);
10413 clib_memcpy (match + 6, src_val, 6);
10417 /* inner vlan tag */
10418 match[19] = tag2_val[1];
10419 match[18] = tag2_val[0];
10421 match[18] |= (cos2_val & 0x7) << 5;
10424 match[21] = proto_val & 0xff;
10425 match[20] = proto_val >> 8;
10429 match[15] = tag1_val[1];
10430 match[14] = tag1_val[0];
10433 match[14] |= (cos1_val & 0x7) << 5;
10439 match[15] = tag1_val[1];
10440 match[14] = tag1_val[0];
10443 match[17] = proto_val & 0xff;
10444 match[16] = proto_val >> 8;
10447 match[14] |= (cos1_val & 0x7) << 5;
10453 match[18] |= (cos2_val & 0x7) << 5;
10455 match[14] |= (cos1_val & 0x7) << 5;
10458 match[13] = proto_val & 0xff;
10459 match[12] = proto_val >> 8;
10467 unformat_qos_source (unformat_input_t * input, va_list * args)
10469 int *qs = va_arg (*args, int *);
10471 if (unformat (input, "ip"))
10472 *qs = QOS_SOURCE_IP;
10473 else if (unformat (input, "mpls"))
10474 *qs = QOS_SOURCE_MPLS;
10475 else if (unformat (input, "ext"))
10476 *qs = QOS_SOURCE_EXT;
10477 else if (unformat (input, "vlan"))
10478 *qs = QOS_SOURCE_VLAN;
10487 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10489 u8 **matchp = va_arg (*args, u8 **);
10490 u32 skip_n_vectors = va_arg (*args, u32);
10491 u32 match_n_vectors = va_arg (*args, u32);
10498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10500 if (unformat (input, "hex %U", unformat_hex_string, &match))
10502 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10504 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10506 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10520 if (match || l2 || l3 || l4)
10522 if (l2 || l3 || l4)
10524 /* "Win a free Ethernet header in every packet" */
10526 vec_validate_aligned (l2, 13, sizeof (u32x4));
10530 vec_append_aligned (match, l3, sizeof (u32x4));
10535 vec_append_aligned (match, l4, sizeof (u32x4));
10540 /* Make sure the vector is big enough even if key is all 0's */
10541 vec_validate_aligned
10542 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10545 /* Set size, include skipped vectors */
10546 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10557 api_classify_add_del_session (vat_main_t * vam)
10559 unformat_input_t *i = vam->input;
10560 vl_api_classify_add_del_session_t *mp;
10562 u32 table_index = ~0;
10563 u32 hit_next_index = ~0;
10564 u32 opaque_index = ~0;
10567 u32 skip_n_vectors = 0;
10568 u32 match_n_vectors = 0;
10574 * Warning: you have to supply skip_n and match_n
10575 * because the API client cant simply look at the classify
10579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10581 if (unformat (i, "del"))
10583 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10586 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10589 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10592 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10594 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10596 else if (unformat (i, "opaque-index %d", &opaque_index))
10598 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10600 else if (unformat (i, "match_n %d", &match_n_vectors))
10602 else if (unformat (i, "match %U", api_unformat_classify_match,
10603 &match, skip_n_vectors, match_n_vectors))
10605 else if (unformat (i, "advance %d", &advance))
10607 else if (unformat (i, "table-index %d", &table_index))
10609 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10611 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10613 else if (unformat (i, "action %d", &action))
10615 else if (unformat (i, "metadata %d", &metadata))
10621 if (table_index == ~0)
10623 errmsg ("Table index required");
10627 if (is_add && match == 0)
10629 errmsg ("Match value required");
10633 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10635 mp->is_add = is_add;
10636 mp->table_index = ntohl (table_index);
10637 mp->hit_next_index = ntohl (hit_next_index);
10638 mp->opaque_index = ntohl (opaque_index);
10639 mp->advance = ntohl (advance);
10640 mp->action = action;
10641 mp->metadata = ntohl (metadata);
10642 mp->match_len = ntohl (vec_len (match));
10643 clib_memcpy (mp->match, match, vec_len (match));
10652 api_classify_set_interface_ip_table (vat_main_t * vam)
10654 unformat_input_t *i = vam->input;
10655 vl_api_classify_set_interface_ip_table_t *mp;
10657 int sw_if_index_set;
10658 u32 table_index = ~0;
10662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10664 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10665 sw_if_index_set = 1;
10666 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10667 sw_if_index_set = 1;
10668 else if (unformat (i, "table %d", &table_index))
10672 clib_warning ("parse error '%U'", format_unformat_error, i);
10677 if (sw_if_index_set == 0)
10679 errmsg ("missing interface name or sw_if_index");
10684 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10686 mp->sw_if_index = ntohl (sw_if_index);
10687 mp->table_index = ntohl (table_index);
10688 mp->is_ipv6 = is_ipv6;
10696 api_classify_set_interface_l2_tables (vat_main_t * vam)
10698 unformat_input_t *i = vam->input;
10699 vl_api_classify_set_interface_l2_tables_t *mp;
10701 int sw_if_index_set;
10702 u32 ip4_table_index = ~0;
10703 u32 ip6_table_index = ~0;
10704 u32 other_table_index = ~0;
10708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10710 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10711 sw_if_index_set = 1;
10712 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10713 sw_if_index_set = 1;
10714 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10716 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10718 else if (unformat (i, "other-table %d", &other_table_index))
10720 else if (unformat (i, "is-input %d", &is_input))
10724 clib_warning ("parse error '%U'", format_unformat_error, i);
10729 if (sw_if_index_set == 0)
10731 errmsg ("missing interface name or sw_if_index");
10736 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10738 mp->sw_if_index = ntohl (sw_if_index);
10739 mp->ip4_table_index = ntohl (ip4_table_index);
10740 mp->ip6_table_index = ntohl (ip6_table_index);
10741 mp->other_table_index = ntohl (other_table_index);
10742 mp->is_input = (u8) is_input;
10750 api_set_ipfix_exporter (vat_main_t * vam)
10752 unformat_input_t *i = vam->input;
10753 vl_api_set_ipfix_exporter_t *mp;
10754 ip4_address_t collector_address;
10755 u8 collector_address_set = 0;
10756 u32 collector_port = ~0;
10757 ip4_address_t src_address;
10758 u8 src_address_set = 0;
10761 u32 template_interval = ~0;
10762 u8 udp_checksum = 0;
10765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10767 if (unformat (i, "collector_address %U", unformat_ip4_address,
10768 &collector_address))
10769 collector_address_set = 1;
10770 else if (unformat (i, "collector_port %d", &collector_port))
10772 else if (unformat (i, "src_address %U", unformat_ip4_address,
10774 src_address_set = 1;
10775 else if (unformat (i, "vrf_id %d", &vrf_id))
10777 else if (unformat (i, "path_mtu %d", &path_mtu))
10779 else if (unformat (i, "template_interval %d", &template_interval))
10781 else if (unformat (i, "udp_checksum"))
10787 if (collector_address_set == 0)
10789 errmsg ("collector_address required");
10793 if (src_address_set == 0)
10795 errmsg ("src_address required");
10799 M (SET_IPFIX_EXPORTER, mp);
10801 memcpy (mp->collector_address.un.ip4, collector_address.data,
10802 sizeof (collector_address.data));
10803 mp->collector_port = htons ((u16) collector_port);
10804 memcpy (mp->src_address.un.ip4, src_address.data,
10805 sizeof (src_address.data));
10806 mp->vrf_id = htonl (vrf_id);
10807 mp->path_mtu = htonl (path_mtu);
10808 mp->template_interval = htonl (template_interval);
10809 mp->udp_checksum = udp_checksum;
10817 api_set_ipfix_classify_stream (vat_main_t * vam)
10819 unformat_input_t *i = vam->input;
10820 vl_api_set_ipfix_classify_stream_t *mp;
10822 u32 src_port = UDP_DST_PORT_ipfix;
10825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10827 if (unformat (i, "domain %d", &domain_id))
10829 else if (unformat (i, "src_port %d", &src_port))
10833 errmsg ("unknown input `%U'", format_unformat_error, i);
10838 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10840 mp->domain_id = htonl (domain_id);
10841 mp->src_port = htons ((u16) src_port);
10849 api_ipfix_classify_table_add_del (vat_main_t * vam)
10851 unformat_input_t *i = vam->input;
10852 vl_api_ipfix_classify_table_add_del_t *mp;
10854 u32 classify_table_index = ~0;
10856 u8 transport_protocol = 255;
10859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10861 if (unformat (i, "add"))
10863 else if (unformat (i, "del"))
10865 else if (unformat (i, "table %d", &classify_table_index))
10867 else if (unformat (i, "ip4"))
10869 else if (unformat (i, "ip6"))
10871 else if (unformat (i, "tcp"))
10872 transport_protocol = 6;
10873 else if (unformat (i, "udp"))
10874 transport_protocol = 17;
10877 errmsg ("unknown input `%U'", format_unformat_error, i);
10884 errmsg ("expecting: add|del");
10887 if (classify_table_index == ~0)
10889 errmsg ("classifier table not specified");
10892 if (ip_version == 0)
10894 errmsg ("IP version not specified");
10898 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10900 mp->is_add = is_add;
10901 mp->table_id = htonl (classify_table_index);
10902 mp->ip_version = ip_version;
10903 mp->transport_protocol = transport_protocol;
10911 api_get_node_index (vat_main_t * vam)
10913 unformat_input_t *i = vam->input;
10914 vl_api_get_node_index_t *mp;
10918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10920 if (unformat (i, "node %s", &name))
10927 errmsg ("node name required");
10930 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10932 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10936 M (GET_NODE_INDEX, mp);
10937 clib_memcpy (mp->node_name, name, vec_len (name));
10946 api_get_next_index (vat_main_t * vam)
10948 unformat_input_t *i = vam->input;
10949 vl_api_get_next_index_t *mp;
10950 u8 *node_name = 0, *next_node_name = 0;
10953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10955 if (unformat (i, "node-name %s", &node_name))
10957 else if (unformat (i, "next-node-name %s", &next_node_name))
10961 if (node_name == 0)
10963 errmsg ("node name required");
10966 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10968 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10972 if (next_node_name == 0)
10974 errmsg ("next node name required");
10977 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10979 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10983 M (GET_NEXT_INDEX, mp);
10984 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10985 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10986 vec_free (node_name);
10987 vec_free (next_node_name);
10995 api_add_node_next (vat_main_t * vam)
10997 unformat_input_t *i = vam->input;
10998 vl_api_add_node_next_t *mp;
11003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11005 if (unformat (i, "node %s", &name))
11007 else if (unformat (i, "next %s", &next))
11014 errmsg ("node name required");
11017 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11019 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11024 errmsg ("next node required");
11027 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11029 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11033 M (ADD_NODE_NEXT, mp);
11034 clib_memcpy (mp->node_name, name, vec_len (name));
11035 clib_memcpy (mp->next_name, next, vec_len (next));
11045 api_l2tpv3_create_tunnel (vat_main_t * vam)
11047 unformat_input_t *i = vam->input;
11048 ip6_address_t client_address, our_address;
11049 int client_address_set = 0;
11050 int our_address_set = 0;
11051 u32 local_session_id = 0;
11052 u32 remote_session_id = 0;
11053 u64 local_cookie = 0;
11054 u64 remote_cookie = 0;
11055 u8 l2_sublayer_present = 0;
11056 vl_api_l2tpv3_create_tunnel_t *mp;
11059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11061 if (unformat (i, "client_address %U", unformat_ip6_address,
11063 client_address_set = 1;
11064 else if (unformat (i, "our_address %U", unformat_ip6_address,
11066 our_address_set = 1;
11067 else if (unformat (i, "local_session_id %d", &local_session_id))
11069 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11071 else if (unformat (i, "local_cookie %lld", &local_cookie))
11073 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11075 else if (unformat (i, "l2-sublayer-present"))
11076 l2_sublayer_present = 1;
11081 if (client_address_set == 0)
11083 errmsg ("client_address required");
11087 if (our_address_set == 0)
11089 errmsg ("our_address required");
11093 M (L2TPV3_CREATE_TUNNEL, mp);
11095 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11096 sizeof (ip6_address_t));
11098 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11099 sizeof (ip6_address_t));
11101 mp->local_session_id = ntohl (local_session_id);
11102 mp->remote_session_id = ntohl (remote_session_id);
11103 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11104 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11105 mp->l2_sublayer_present = l2_sublayer_present;
11113 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11115 unformat_input_t *i = vam->input;
11117 u8 sw_if_index_set = 0;
11118 u64 new_local_cookie = 0;
11119 u64 new_remote_cookie = 0;
11120 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11123 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11125 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11126 sw_if_index_set = 1;
11127 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11128 sw_if_index_set = 1;
11129 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11131 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11137 if (sw_if_index_set == 0)
11139 errmsg ("missing interface name or sw_if_index");
11143 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11145 mp->sw_if_index = ntohl (sw_if_index);
11146 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11147 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11155 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11157 unformat_input_t *i = vam->input;
11158 vl_api_l2tpv3_interface_enable_disable_t *mp;
11160 u8 sw_if_index_set = 0;
11161 u8 enable_disable = 1;
11164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11166 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11167 sw_if_index_set = 1;
11168 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11169 sw_if_index_set = 1;
11170 else if (unformat (i, "enable"))
11171 enable_disable = 1;
11172 else if (unformat (i, "disable"))
11173 enable_disable = 0;
11178 if (sw_if_index_set == 0)
11180 errmsg ("missing interface name or sw_if_index");
11184 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11186 mp->sw_if_index = ntohl (sw_if_index);
11187 mp->enable_disable = enable_disable;
11195 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11197 unformat_input_t *i = vam->input;
11198 vl_api_l2tpv3_set_lookup_key_t *mp;
11202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11204 if (unformat (i, "lookup_v6_src"))
11205 key = L2T_LOOKUP_SRC_ADDRESS;
11206 else if (unformat (i, "lookup_v6_dst"))
11207 key = L2T_LOOKUP_DST_ADDRESS;
11208 else if (unformat (i, "lookup_session_id"))
11209 key = L2T_LOOKUP_SESSION_ID;
11214 if (key == (u8) ~ 0)
11216 errmsg ("l2tp session lookup key unset");
11220 M (L2TPV3_SET_LOOKUP_KEY, mp);
11229 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11230 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11232 vat_main_t *vam = &vat_main;
11234 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11235 format_ip6_address, mp->our_address,
11236 format_ip6_address, mp->client_address,
11237 clib_net_to_host_u32 (mp->sw_if_index));
11240 " local cookies %016llx %016llx remote cookie %016llx",
11241 clib_net_to_host_u64 (mp->local_cookie[0]),
11242 clib_net_to_host_u64 (mp->local_cookie[1]),
11243 clib_net_to_host_u64 (mp->remote_cookie));
11245 print (vam->ofp, " local session-id %d remote session-id %d",
11246 clib_net_to_host_u32 (mp->local_session_id),
11247 clib_net_to_host_u32 (mp->remote_session_id));
11249 print (vam->ofp, " l2 specific sublayer %s\n",
11250 mp->l2_sublayer_present ? "preset" : "absent");
11254 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11255 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11257 vat_main_t *vam = &vat_main;
11258 vat_json_node_t *node = NULL;
11259 struct in6_addr addr;
11261 if (VAT_JSON_ARRAY != vam->json_tree.type)
11263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11264 vat_json_init_array (&vam->json_tree);
11266 node = vat_json_array_add (&vam->json_tree);
11268 vat_json_init_object (node);
11270 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11271 vat_json_object_add_ip6 (node, "our_address", addr);
11272 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11273 vat_json_object_add_ip6 (node, "client_address", addr);
11275 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11276 vat_json_init_array (lc);
11277 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11278 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11279 vat_json_object_add_uint (node, "remote_cookie",
11280 clib_net_to_host_u64 (mp->remote_cookie));
11282 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11283 vat_json_object_add_uint (node, "local_session_id",
11284 clib_net_to_host_u32 (mp->local_session_id));
11285 vat_json_object_add_uint (node, "remote_session_id",
11286 clib_net_to_host_u32 (mp->remote_session_id));
11287 vat_json_object_add_string_copy (node, "l2_sublayer",
11288 mp->l2_sublayer_present ? (u8 *) "present"
11289 : (u8 *) "absent");
11293 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11295 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11296 vl_api_control_ping_t *mp_ping;
11299 /* Get list of l2tpv3-tunnel interfaces */
11300 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11303 /* Use a control ping for synchronization */
11304 MPING (CONTROL_PING, mp_ping);
11312 static void vl_api_sw_interface_tap_v2_details_t_handler
11313 (vl_api_sw_interface_tap_v2_details_t * mp)
11315 vat_main_t *vam = &vat_main;
11318 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11319 mp->host_ip4_prefix.len);
11321 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11322 mp->host_ip6_prefix.len);
11325 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11326 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11327 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11328 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11329 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11335 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11336 (vl_api_sw_interface_tap_v2_details_t * mp)
11338 vat_main_t *vam = &vat_main;
11339 vat_json_node_t *node = NULL;
11341 if (VAT_JSON_ARRAY != vam->json_tree.type)
11343 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11344 vat_json_init_array (&vam->json_tree);
11346 node = vat_json_array_add (&vam->json_tree);
11348 vat_json_init_object (node);
11349 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11350 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11351 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11352 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11353 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11354 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11355 vat_json_object_add_string_copy (node, "host_mac_addr",
11356 format (0, "%U", format_ethernet_address,
11357 &mp->host_mac_addr));
11358 vat_json_object_add_string_copy (node, "host_namespace",
11359 mp->host_namespace);
11360 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11361 vat_json_object_add_string_copy (node, "host_ip4_addr",
11362 format (0, "%U/%d", format_ip4_address,
11363 mp->host_ip4_prefix.address,
11364 mp->host_ip4_prefix.len));
11365 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11366 format (0, "%U/%d", format_ip6_address,
11367 mp->host_ip6_prefix.address,
11368 mp->host_ip6_prefix.len));
11373 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11375 vl_api_sw_interface_tap_v2_dump_t *mp;
11376 vl_api_control_ping_t *mp_ping;
11380 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11381 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11382 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11385 /* Get list of tap interfaces */
11386 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11389 /* Use a control ping for synchronization */
11390 MPING (CONTROL_PING, mp_ping);
11397 static void vl_api_sw_interface_virtio_pci_details_t_handler
11398 (vl_api_sw_interface_virtio_pci_details_t * mp)
11400 vat_main_t *vam = &vat_main;
11415 addr.domain = ntohs (mp->pci_addr.domain);
11416 addr.bus = mp->pci_addr.bus;
11417 addr.slot = mp->pci_addr.slot;
11418 addr.function = mp->pci_addr.function;
11420 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11421 addr.slot, addr.function);
11424 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11425 pci_addr, ntohl (mp->sw_if_index),
11426 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11427 format_ethernet_address, mp->mac_addr,
11428 clib_net_to_host_u64 (mp->features));
11429 vec_free (pci_addr);
11432 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11433 (vl_api_sw_interface_virtio_pci_details_t * mp)
11435 vat_main_t *vam = &vat_main;
11436 vat_json_node_t *node = NULL;
11437 vlib_pci_addr_t pci_addr;
11439 if (VAT_JSON_ARRAY != vam->json_tree.type)
11441 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11442 vat_json_init_array (&vam->json_tree);
11444 node = vat_json_array_add (&vam->json_tree);
11446 pci_addr.domain = ntohs (mp->pci_addr.domain);
11447 pci_addr.bus = mp->pci_addr.bus;
11448 pci_addr.slot = mp->pci_addr.slot;
11449 pci_addr.function = mp->pci_addr.function;
11451 vat_json_init_object (node);
11452 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11453 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11454 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11455 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11456 vat_json_object_add_uint (node, "features",
11457 clib_net_to_host_u64 (mp->features));
11458 vat_json_object_add_string_copy (node, "mac_addr",
11459 format (0, "%U", format_ethernet_address,
11464 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11466 vl_api_sw_interface_virtio_pci_dump_t *mp;
11467 vl_api_control_ping_t *mp_ping;
11471 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11472 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11473 "mac_addr", "features");
11475 /* Get list of tap interfaces */
11476 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11479 /* Use a control ping for synchronization */
11480 MPING (CONTROL_PING, mp_ping);
11488 api_vxlan_offload_rx (vat_main_t * vam)
11490 unformat_input_t *line_input = vam->input;
11491 vl_api_vxlan_offload_rx_t *mp;
11492 u32 hw_if_index = ~0, rx_if_index = ~0;
11496 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11498 if (unformat (line_input, "del"))
11500 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11503 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11505 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11508 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11512 errmsg ("parse error '%U'", format_unformat_error, line_input);
11517 if (hw_if_index == ~0)
11519 errmsg ("no hw interface");
11523 if (rx_if_index == ~0)
11525 errmsg ("no rx tunnel");
11529 M (VXLAN_OFFLOAD_RX, mp);
11531 mp->hw_if_index = ntohl (hw_if_index);
11532 mp->sw_if_index = ntohl (rx_if_index);
11533 mp->enable = is_add;
11540 static uword unformat_vxlan_decap_next
11541 (unformat_input_t * input, va_list * args)
11543 u32 *result = va_arg (*args, u32 *);
11546 if (unformat (input, "l2"))
11547 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11548 else if (unformat (input, "%d", &tmp))
11556 api_vxlan_add_del_tunnel (vat_main_t * vam)
11558 unformat_input_t *line_input = vam->input;
11559 vl_api_vxlan_add_del_tunnel_t *mp;
11560 ip46_address_t src, dst;
11562 u8 ipv4_set = 0, ipv6_set = 0;
11567 u32 mcast_sw_if_index = ~0;
11568 u32 encap_vrf_id = 0;
11569 u32 decap_next_index = ~0;
11573 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11574 clib_memset (&src, 0, sizeof src);
11575 clib_memset (&dst, 0, sizeof dst);
11577 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11579 if (unformat (line_input, "del"))
11581 else if (unformat (line_input, "instance %d", &instance))
11584 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11590 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11596 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11602 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11607 else if (unformat (line_input, "group %U %U",
11608 unformat_ip4_address, &dst.ip4,
11609 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11611 grp_set = dst_set = 1;
11614 else if (unformat (line_input, "group %U",
11615 unformat_ip4_address, &dst.ip4))
11617 grp_set = dst_set = 1;
11620 else if (unformat (line_input, "group %U %U",
11621 unformat_ip6_address, &dst.ip6,
11622 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11624 grp_set = dst_set = 1;
11627 else if (unformat (line_input, "group %U",
11628 unformat_ip6_address, &dst.ip6))
11630 grp_set = dst_set = 1;
11634 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11636 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11638 else if (unformat (line_input, "decap-next %U",
11639 unformat_vxlan_decap_next, &decap_next_index))
11641 else if (unformat (line_input, "vni %d", &vni))
11645 errmsg ("parse error '%U'", format_unformat_error, line_input);
11652 errmsg ("tunnel src address not specified");
11657 errmsg ("tunnel dst address not specified");
11661 if (grp_set && !ip46_address_is_multicast (&dst))
11663 errmsg ("tunnel group address not multicast");
11666 if (grp_set && mcast_sw_if_index == ~0)
11668 errmsg ("tunnel nonexistent multicast device");
11671 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11673 errmsg ("tunnel dst address must be unicast");
11678 if (ipv4_set && ipv6_set)
11680 errmsg ("both IPv4 and IPv6 addresses specified");
11684 if ((vni == 0) || (vni >> 24))
11686 errmsg ("vni not specified or out of range");
11690 M (VXLAN_ADD_DEL_TUNNEL, mp);
11694 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11695 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11699 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11700 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11703 mp->instance = htonl (instance);
11704 mp->encap_vrf_id = ntohl (encap_vrf_id);
11705 mp->decap_next_index = ntohl (decap_next_index);
11706 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11707 mp->vni = ntohl (vni);
11708 mp->is_add = is_add;
11709 mp->is_ipv6 = ipv6_set;
11716 static void vl_api_vxlan_tunnel_details_t_handler
11717 (vl_api_vxlan_tunnel_details_t * mp)
11719 vat_main_t *vam = &vat_main;
11720 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11721 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11723 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11724 ntohl (mp->sw_if_index),
11725 ntohl (mp->instance),
11726 format_ip46_address, &src, IP46_TYPE_ANY,
11727 format_ip46_address, &dst, IP46_TYPE_ANY,
11728 ntohl (mp->encap_vrf_id),
11729 ntohl (mp->decap_next_index), ntohl (mp->vni),
11730 ntohl (mp->mcast_sw_if_index));
11733 static void vl_api_vxlan_tunnel_details_t_handler_json
11734 (vl_api_vxlan_tunnel_details_t * mp)
11736 vat_main_t *vam = &vat_main;
11737 vat_json_node_t *node = NULL;
11739 if (VAT_JSON_ARRAY != vam->json_tree.type)
11741 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11742 vat_json_init_array (&vam->json_tree);
11744 node = vat_json_array_add (&vam->json_tree);
11746 vat_json_init_object (node);
11747 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11749 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11753 struct in6_addr ip6;
11755 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11756 vat_json_object_add_ip6 (node, "src_address", ip6);
11757 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11758 vat_json_object_add_ip6 (node, "dst_address", ip6);
11762 struct in_addr ip4;
11764 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11765 vat_json_object_add_ip4 (node, "src_address", ip4);
11766 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11767 vat_json_object_add_ip4 (node, "dst_address", ip4);
11769 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11770 vat_json_object_add_uint (node, "decap_next_index",
11771 ntohl (mp->decap_next_index));
11772 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11773 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11774 vat_json_object_add_uint (node, "mcast_sw_if_index",
11775 ntohl (mp->mcast_sw_if_index));
11779 api_vxlan_tunnel_dump (vat_main_t * vam)
11781 unformat_input_t *i = vam->input;
11782 vl_api_vxlan_tunnel_dump_t *mp;
11783 vl_api_control_ping_t *mp_ping;
11785 u8 sw_if_index_set = 0;
11788 /* Parse args required to build the message */
11789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11791 if (unformat (i, "sw_if_index %d", &sw_if_index))
11792 sw_if_index_set = 1;
11797 if (sw_if_index_set == 0)
11802 if (!vam->json_output)
11804 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11805 "sw_if_index", "instance", "src_address", "dst_address",
11806 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11809 /* Get list of vxlan-tunnel interfaces */
11810 M (VXLAN_TUNNEL_DUMP, mp);
11812 mp->sw_if_index = htonl (sw_if_index);
11816 /* Use a control ping for synchronization */
11817 MPING (CONTROL_PING, mp_ping);
11824 static uword unformat_geneve_decap_next
11825 (unformat_input_t * input, va_list * args)
11827 u32 *result = va_arg (*args, u32 *);
11830 if (unformat (input, "l2"))
11831 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11832 else if (unformat (input, "%d", &tmp))
11840 api_geneve_add_del_tunnel (vat_main_t * vam)
11842 unformat_input_t *line_input = vam->input;
11843 vl_api_geneve_add_del_tunnel_t *mp;
11844 ip46_address_t src, dst;
11846 u8 ipv4_set = 0, ipv6_set = 0;
11850 u32 mcast_sw_if_index = ~0;
11851 u32 encap_vrf_id = 0;
11852 u32 decap_next_index = ~0;
11856 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11857 clib_memset (&src, 0, sizeof src);
11858 clib_memset (&dst, 0, sizeof dst);
11860 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11862 if (unformat (line_input, "del"))
11865 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11871 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11877 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11883 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11888 else if (unformat (line_input, "group %U %U",
11889 unformat_ip4_address, &dst.ip4,
11890 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11892 grp_set = dst_set = 1;
11895 else if (unformat (line_input, "group %U",
11896 unformat_ip4_address, &dst.ip4))
11898 grp_set = dst_set = 1;
11901 else if (unformat (line_input, "group %U %U",
11902 unformat_ip6_address, &dst.ip6,
11903 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11905 grp_set = dst_set = 1;
11908 else if (unformat (line_input, "group %U",
11909 unformat_ip6_address, &dst.ip6))
11911 grp_set = dst_set = 1;
11915 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11917 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11919 else if (unformat (line_input, "decap-next %U",
11920 unformat_geneve_decap_next, &decap_next_index))
11922 else if (unformat (line_input, "vni %d", &vni))
11926 errmsg ("parse error '%U'", format_unformat_error, line_input);
11933 errmsg ("tunnel src address not specified");
11938 errmsg ("tunnel dst address not specified");
11942 if (grp_set && !ip46_address_is_multicast (&dst))
11944 errmsg ("tunnel group address not multicast");
11947 if (grp_set && mcast_sw_if_index == ~0)
11949 errmsg ("tunnel nonexistent multicast device");
11952 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11954 errmsg ("tunnel dst address must be unicast");
11959 if (ipv4_set && ipv6_set)
11961 errmsg ("both IPv4 and IPv6 addresses specified");
11965 if ((vni == 0) || (vni >> 24))
11967 errmsg ("vni not specified or out of range");
11971 M (GENEVE_ADD_DEL_TUNNEL, mp);
11975 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
11976 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11980 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
11981 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11983 mp->encap_vrf_id = ntohl (encap_vrf_id);
11984 mp->decap_next_index = ntohl (decap_next_index);
11985 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11986 mp->vni = ntohl (vni);
11987 mp->is_add = is_add;
11994 static void vl_api_geneve_tunnel_details_t_handler
11995 (vl_api_geneve_tunnel_details_t * mp)
11997 vat_main_t *vam = &vat_main;
11998 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
11999 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12001 if (mp->src_address.af == ADDRESS_IP6)
12003 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12004 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12008 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12009 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12012 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12013 ntohl (mp->sw_if_index),
12014 format_ip46_address, &src, IP46_TYPE_ANY,
12015 format_ip46_address, &dst, IP46_TYPE_ANY,
12016 ntohl (mp->encap_vrf_id),
12017 ntohl (mp->decap_next_index), ntohl (mp->vni),
12018 ntohl (mp->mcast_sw_if_index));
12021 static void vl_api_geneve_tunnel_details_t_handler_json
12022 (vl_api_geneve_tunnel_details_t * mp)
12024 vat_main_t *vam = &vat_main;
12025 vat_json_node_t *node = NULL;
12028 if (VAT_JSON_ARRAY != vam->json_tree.type)
12030 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12031 vat_json_init_array (&vam->json_tree);
12033 node = vat_json_array_add (&vam->json_tree);
12035 vat_json_init_object (node);
12036 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12037 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12040 struct in6_addr ip6;
12042 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12043 vat_json_object_add_ip6 (node, "src_address", ip6);
12044 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12045 vat_json_object_add_ip6 (node, "dst_address", ip6);
12049 struct in_addr ip4;
12051 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12052 vat_json_object_add_ip4 (node, "src_address", ip4);
12053 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12054 vat_json_object_add_ip4 (node, "dst_address", ip4);
12056 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12057 vat_json_object_add_uint (node, "decap_next_index",
12058 ntohl (mp->decap_next_index));
12059 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12060 vat_json_object_add_uint (node, "mcast_sw_if_index",
12061 ntohl (mp->mcast_sw_if_index));
12065 api_geneve_tunnel_dump (vat_main_t * vam)
12067 unformat_input_t *i = vam->input;
12068 vl_api_geneve_tunnel_dump_t *mp;
12069 vl_api_control_ping_t *mp_ping;
12071 u8 sw_if_index_set = 0;
12074 /* Parse args required to build the message */
12075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12077 if (unformat (i, "sw_if_index %d", &sw_if_index))
12078 sw_if_index_set = 1;
12083 if (sw_if_index_set == 0)
12088 if (!vam->json_output)
12090 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12091 "sw_if_index", "local_address", "remote_address",
12092 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12095 /* Get list of geneve-tunnel interfaces */
12096 M (GENEVE_TUNNEL_DUMP, mp);
12098 mp->sw_if_index = htonl (sw_if_index);
12102 /* Use a control ping for synchronization */
12103 M (CONTROL_PING, mp_ping);
12111 api_gre_tunnel_add_del (vat_main_t * vam)
12113 unformat_input_t *line_input = vam->input;
12114 vl_api_address_t src = { }, dst =
12117 vl_api_gre_tunnel_add_del_t *mp;
12118 vl_api_gre_tunnel_type_t t_type;
12122 u32 outer_table_id = 0;
12123 u32 session_id = 0;
12127 t_type = GRE_API_TUNNEL_TYPE_L3;
12129 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12131 if (unformat (line_input, "del"))
12133 else if (unformat (line_input, "instance %d", &instance))
12135 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12139 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12143 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12145 else if (unformat (line_input, "teb"))
12146 t_type = GRE_API_TUNNEL_TYPE_TEB;
12147 else if (unformat (line_input, "erspan %d", &session_id))
12148 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12151 errmsg ("parse error '%U'", format_unformat_error, line_input);
12158 errmsg ("tunnel src address not specified");
12163 errmsg ("tunnel dst address not specified");
12167 M (GRE_TUNNEL_ADD_DEL, mp);
12169 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12170 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12172 mp->tunnel.instance = htonl (instance);
12173 mp->tunnel.outer_table_id = htonl (outer_table_id);
12174 mp->is_add = is_add;
12175 mp->tunnel.session_id = htons ((u16) session_id);
12176 mp->tunnel.type = htonl (t_type);
12183 static void vl_api_gre_tunnel_details_t_handler
12184 (vl_api_gre_tunnel_details_t * mp)
12186 vat_main_t *vam = &vat_main;
12188 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12189 ntohl (mp->tunnel.sw_if_index),
12190 ntohl (mp->tunnel.instance),
12191 format_vl_api_address, &mp->tunnel.src,
12192 format_vl_api_address, &mp->tunnel.dst,
12193 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12194 ntohl (mp->tunnel.session_id));
12197 static void vl_api_gre_tunnel_details_t_handler_json
12198 (vl_api_gre_tunnel_details_t * mp)
12200 vat_main_t *vam = &vat_main;
12201 vat_json_node_t *node = NULL;
12203 if (VAT_JSON_ARRAY != vam->json_tree.type)
12205 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12206 vat_json_init_array (&vam->json_tree);
12208 node = vat_json_array_add (&vam->json_tree);
12210 vat_json_init_object (node);
12211 vat_json_object_add_uint (node, "sw_if_index",
12212 ntohl (mp->tunnel.sw_if_index));
12213 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12215 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12216 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12217 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12218 vat_json_object_add_uint (node, "outer_table_id",
12219 ntohl (mp->tunnel.outer_table_id));
12220 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12224 api_gre_tunnel_dump (vat_main_t * vam)
12226 unformat_input_t *i = vam->input;
12227 vl_api_gre_tunnel_dump_t *mp;
12228 vl_api_control_ping_t *mp_ping;
12230 u8 sw_if_index_set = 0;
12233 /* Parse args required to build the message */
12234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12236 if (unformat (i, "sw_if_index %d", &sw_if_index))
12237 sw_if_index_set = 1;
12242 if (sw_if_index_set == 0)
12247 if (!vam->json_output)
12249 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12250 "sw_if_index", "instance", "src_address", "dst_address",
12251 "tunnel_type", "outer_fib_id", "session_id");
12254 /* Get list of gre-tunnel interfaces */
12255 M (GRE_TUNNEL_DUMP, mp);
12257 mp->sw_if_index = htonl (sw_if_index);
12261 /* Use a control ping for synchronization */
12262 MPING (CONTROL_PING, mp_ping);
12270 api_l2_fib_clear_table (vat_main_t * vam)
12272 // unformat_input_t * i = vam->input;
12273 vl_api_l2_fib_clear_table_t *mp;
12276 M (L2_FIB_CLEAR_TABLE, mp);
12284 api_l2_interface_efp_filter (vat_main_t * vam)
12286 unformat_input_t *i = vam->input;
12287 vl_api_l2_interface_efp_filter_t *mp;
12290 u8 sw_if_index_set = 0;
12293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12295 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12296 sw_if_index_set = 1;
12297 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12298 sw_if_index_set = 1;
12299 else if (unformat (i, "enable"))
12301 else if (unformat (i, "disable"))
12305 clib_warning ("parse error '%U'", format_unformat_error, i);
12310 if (sw_if_index_set == 0)
12312 errmsg ("missing sw_if_index");
12316 M (L2_INTERFACE_EFP_FILTER, mp);
12318 mp->sw_if_index = ntohl (sw_if_index);
12319 mp->enable_disable = enable;
12326 #define foreach_vtr_op \
12327 _("disable", L2_VTR_DISABLED) \
12328 _("push-1", L2_VTR_PUSH_1) \
12329 _("push-2", L2_VTR_PUSH_2) \
12330 _("pop-1", L2_VTR_POP_1) \
12331 _("pop-2", L2_VTR_POP_2) \
12332 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12333 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12334 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12335 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12338 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12340 unformat_input_t *i = vam->input;
12341 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12343 u8 sw_if_index_set = 0;
12346 u32 push_dot1q = 1;
12351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12353 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12354 sw_if_index_set = 1;
12355 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12356 sw_if_index_set = 1;
12357 else if (unformat (i, "vtr_op %d", &vtr_op))
12359 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12362 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12364 else if (unformat (i, "tag1 %d", &tag1))
12366 else if (unformat (i, "tag2 %d", &tag2))
12370 clib_warning ("parse error '%U'", format_unformat_error, i);
12375 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12377 errmsg ("missing vtr operation or sw_if_index");
12381 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12382 mp->sw_if_index = ntohl (sw_if_index);
12383 mp->vtr_op = ntohl (vtr_op);
12384 mp->push_dot1q = ntohl (push_dot1q);
12385 mp->tag1 = ntohl (tag1);
12386 mp->tag2 = ntohl (tag2);
12394 api_create_vhost_user_if (vat_main_t * vam)
12396 unformat_input_t *i = vam->input;
12397 vl_api_create_vhost_user_if_t *mp;
12400 u8 file_name_set = 0;
12401 u32 custom_dev_instance = ~0;
12403 u8 use_custom_mac = 0;
12404 u8 disable_mrg_rxbuf = 0;
12405 u8 disable_indirect_desc = 0;
12410 /* Shut up coverity */
12411 clib_memset (hwaddr, 0, sizeof (hwaddr));
12413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12415 if (unformat (i, "socket %s", &file_name))
12419 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12421 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12422 use_custom_mac = 1;
12423 else if (unformat (i, "server"))
12425 else if (unformat (i, "disable_mrg_rxbuf"))
12426 disable_mrg_rxbuf = 1;
12427 else if (unformat (i, "disable_indirect_desc"))
12428 disable_indirect_desc = 1;
12429 else if (unformat (i, "gso"))
12431 else if (unformat (i, "tag %s", &tag))
12437 if (file_name_set == 0)
12439 errmsg ("missing socket file name");
12443 if (vec_len (file_name) > 255)
12445 errmsg ("socket file name too long");
12448 vec_add1 (file_name, 0);
12450 M (CREATE_VHOST_USER_IF, mp);
12452 mp->is_server = is_server;
12453 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12454 mp->disable_indirect_desc = disable_indirect_desc;
12455 mp->enable_gso = enable_gso;
12456 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12457 vec_free (file_name);
12458 if (custom_dev_instance != ~0)
12461 mp->custom_dev_instance = ntohl (custom_dev_instance);
12464 mp->use_custom_mac = use_custom_mac;
12465 clib_memcpy (mp->mac_address, hwaddr, 6);
12467 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12476 api_modify_vhost_user_if (vat_main_t * vam)
12478 unformat_input_t *i = vam->input;
12479 vl_api_modify_vhost_user_if_t *mp;
12482 u8 file_name_set = 0;
12483 u32 custom_dev_instance = ~0;
12484 u8 sw_if_index_set = 0;
12485 u32 sw_if_index = (u32) ~ 0;
12489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12491 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12492 sw_if_index_set = 1;
12493 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12494 sw_if_index_set = 1;
12495 else if (unformat (i, "socket %s", &file_name))
12499 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12501 else if (unformat (i, "server"))
12503 else if (unformat (i, "gso"))
12509 if (sw_if_index_set == 0)
12511 errmsg ("missing sw_if_index or interface name");
12515 if (file_name_set == 0)
12517 errmsg ("missing socket file name");
12521 if (vec_len (file_name) > 255)
12523 errmsg ("socket file name too long");
12526 vec_add1 (file_name, 0);
12528 M (MODIFY_VHOST_USER_IF, mp);
12530 mp->sw_if_index = ntohl (sw_if_index);
12531 mp->is_server = is_server;
12532 mp->enable_gso = enable_gso;
12533 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12534 vec_free (file_name);
12535 if (custom_dev_instance != ~0)
12538 mp->custom_dev_instance = ntohl (custom_dev_instance);
12547 api_delete_vhost_user_if (vat_main_t * vam)
12549 unformat_input_t *i = vam->input;
12550 vl_api_delete_vhost_user_if_t *mp;
12551 u32 sw_if_index = ~0;
12552 u8 sw_if_index_set = 0;
12555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12557 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12558 sw_if_index_set = 1;
12559 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12560 sw_if_index_set = 1;
12565 if (sw_if_index_set == 0)
12567 errmsg ("missing sw_if_index or interface name");
12572 M (DELETE_VHOST_USER_IF, mp);
12574 mp->sw_if_index = ntohl (sw_if_index);
12581 static void vl_api_sw_interface_vhost_user_details_t_handler
12582 (vl_api_sw_interface_vhost_user_details_t * mp)
12584 vat_main_t *vam = &vat_main;
12588 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12589 clib_net_to_host_u32
12590 (mp->features_last_32) <<
12593 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12594 (char *) mp->interface_name,
12595 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12596 features, mp->is_server,
12597 ntohl (mp->num_regions), (char *) mp->sock_filename);
12598 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12601 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12602 (vl_api_sw_interface_vhost_user_details_t * mp)
12604 vat_main_t *vam = &vat_main;
12605 vat_json_node_t *node = NULL;
12607 if (VAT_JSON_ARRAY != vam->json_tree.type)
12609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12610 vat_json_init_array (&vam->json_tree);
12612 node = vat_json_array_add (&vam->json_tree);
12614 vat_json_init_object (node);
12615 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12616 vat_json_object_add_string_copy (node, "interface_name",
12617 mp->interface_name);
12618 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12619 ntohl (mp->virtio_net_hdr_sz));
12620 vat_json_object_add_uint (node, "features_first_32",
12621 clib_net_to_host_u32 (mp->features_first_32));
12622 vat_json_object_add_uint (node, "features_last_32",
12623 clib_net_to_host_u32 (mp->features_last_32));
12624 vat_json_object_add_uint (node, "is_server", mp->is_server);
12625 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12626 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12627 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12631 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12633 vl_api_sw_interface_vhost_user_dump_t *mp;
12634 vl_api_control_ping_t *mp_ping;
12637 "Interface name idx hdr_sz features server regions filename");
12639 /* Get list of vhost-user interfaces */
12640 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12641 mp->sw_if_index = ntohl (~0);
12644 /* Use a control ping for synchronization */
12645 MPING (CONTROL_PING, mp_ping);
12653 api_show_version (vat_main_t * vam)
12655 vl_api_show_version_t *mp;
12658 M (SHOW_VERSION, mp);
12667 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12669 unformat_input_t *line_input = vam->input;
12670 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12671 ip4_address_t local4, remote4;
12672 ip6_address_t local6, remote6;
12674 u8 ipv4_set = 0, ipv6_set = 0;
12678 u32 mcast_sw_if_index = ~0;
12679 u32 encap_vrf_id = 0;
12680 u32 decap_vrf_id = 0;
12686 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12687 clib_memset (&local4, 0, sizeof local4);
12688 clib_memset (&remote4, 0, sizeof remote4);
12689 clib_memset (&local6, 0, sizeof local6);
12690 clib_memset (&remote6, 0, sizeof remote6);
12692 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12694 if (unformat (line_input, "del"))
12696 else if (unformat (line_input, "local %U",
12697 unformat_ip4_address, &local4))
12702 else if (unformat (line_input, "remote %U",
12703 unformat_ip4_address, &remote4))
12708 else if (unformat (line_input, "local %U",
12709 unformat_ip6_address, &local6))
12714 else if (unformat (line_input, "remote %U",
12715 unformat_ip6_address, &remote6))
12720 else if (unformat (line_input, "group %U %U",
12721 unformat_ip4_address, &remote4,
12722 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12724 grp_set = remote_set = 1;
12727 else if (unformat (line_input, "group %U",
12728 unformat_ip4_address, &remote4))
12730 grp_set = remote_set = 1;
12733 else if (unformat (line_input, "group %U %U",
12734 unformat_ip6_address, &remote6,
12735 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12737 grp_set = remote_set = 1;
12740 else if (unformat (line_input, "group %U",
12741 unformat_ip6_address, &remote6))
12743 grp_set = remote_set = 1;
12747 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12749 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12751 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12753 else if (unformat (line_input, "vni %d", &vni))
12755 else if (unformat (line_input, "next-ip4"))
12757 else if (unformat (line_input, "next-ip6"))
12759 else if (unformat (line_input, "next-ethernet"))
12761 else if (unformat (line_input, "next-nsh"))
12765 errmsg ("parse error '%U'", format_unformat_error, line_input);
12770 if (local_set == 0)
12772 errmsg ("tunnel local address not specified");
12775 if (remote_set == 0)
12777 errmsg ("tunnel remote address not specified");
12780 if (grp_set && mcast_sw_if_index == ~0)
12782 errmsg ("tunnel nonexistent multicast device");
12785 if (ipv4_set && ipv6_set)
12787 errmsg ("both IPv4 and IPv6 addresses specified");
12793 errmsg ("vni not specified");
12797 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12802 clib_memcpy (&mp->local, &local6, sizeof (local6));
12803 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12807 clib_memcpy (&mp->local, &local4, sizeof (local4));
12808 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12811 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12812 mp->encap_vrf_id = ntohl (encap_vrf_id);
12813 mp->decap_vrf_id = ntohl (decap_vrf_id);
12814 mp->protocol = protocol;
12815 mp->vni = ntohl (vni);
12816 mp->is_add = is_add;
12817 mp->is_ipv6 = ipv6_set;
12824 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12825 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12827 vat_main_t *vam = &vat_main;
12828 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12829 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12831 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12832 ntohl (mp->sw_if_index),
12833 format_ip46_address, &local, IP46_TYPE_ANY,
12834 format_ip46_address, &remote, IP46_TYPE_ANY,
12835 ntohl (mp->vni), mp->protocol,
12836 ntohl (mp->mcast_sw_if_index),
12837 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12841 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12842 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12844 vat_main_t *vam = &vat_main;
12845 vat_json_node_t *node = NULL;
12846 struct in_addr ip4;
12847 struct in6_addr ip6;
12849 if (VAT_JSON_ARRAY != vam->json_tree.type)
12851 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12852 vat_json_init_array (&vam->json_tree);
12854 node = vat_json_array_add (&vam->json_tree);
12856 vat_json_init_object (node);
12857 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12860 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12861 vat_json_object_add_ip6 (node, "local", ip6);
12862 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12863 vat_json_object_add_ip6 (node, "remote", ip6);
12867 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12868 vat_json_object_add_ip4 (node, "local", ip4);
12869 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12870 vat_json_object_add_ip4 (node, "remote", ip4);
12872 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12873 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12874 vat_json_object_add_uint (node, "mcast_sw_if_index",
12875 ntohl (mp->mcast_sw_if_index));
12876 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12877 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12878 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12882 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12884 unformat_input_t *i = vam->input;
12885 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12886 vl_api_control_ping_t *mp_ping;
12888 u8 sw_if_index_set = 0;
12891 /* Parse args required to build the message */
12892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12894 if (unformat (i, "sw_if_index %d", &sw_if_index))
12895 sw_if_index_set = 1;
12900 if (sw_if_index_set == 0)
12905 if (!vam->json_output)
12907 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12908 "sw_if_index", "local", "remote", "vni",
12909 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12912 /* Get list of vxlan-tunnel interfaces */
12913 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12915 mp->sw_if_index = htonl (sw_if_index);
12919 /* Use a control ping for synchronization */
12920 MPING (CONTROL_PING, mp_ping);
12927 static void vl_api_l2_fib_table_details_t_handler
12928 (vl_api_l2_fib_table_details_t * mp)
12930 vat_main_t *vam = &vat_main;
12932 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12934 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12935 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12939 static void vl_api_l2_fib_table_details_t_handler_json
12940 (vl_api_l2_fib_table_details_t * mp)
12942 vat_main_t *vam = &vat_main;
12943 vat_json_node_t *node = NULL;
12945 if (VAT_JSON_ARRAY != vam->json_tree.type)
12947 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12948 vat_json_init_array (&vam->json_tree);
12950 node = vat_json_array_add (&vam->json_tree);
12952 vat_json_init_object (node);
12953 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12954 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12955 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12956 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12957 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12958 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12962 api_l2_fib_table_dump (vat_main_t * vam)
12964 unformat_input_t *i = vam->input;
12965 vl_api_l2_fib_table_dump_t *mp;
12966 vl_api_control_ping_t *mp_ping;
12971 /* Parse args required to build the message */
12972 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12974 if (unformat (i, "bd_id %d", &bd_id))
12980 if (bd_id_set == 0)
12982 errmsg ("missing bridge domain");
12986 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12988 /* Get list of l2 fib entries */
12989 M (L2_FIB_TABLE_DUMP, mp);
12991 mp->bd_id = ntohl (bd_id);
12994 /* Use a control ping for synchronization */
12995 MPING (CONTROL_PING, mp_ping);
13004 api_interface_name_renumber (vat_main_t * vam)
13006 unformat_input_t *line_input = vam->input;
13007 vl_api_interface_name_renumber_t *mp;
13008 u32 sw_if_index = ~0;
13009 u32 new_show_dev_instance = ~0;
13012 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13014 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13017 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13019 else if (unformat (line_input, "new_show_dev_instance %d",
13020 &new_show_dev_instance))
13026 if (sw_if_index == ~0)
13028 errmsg ("missing interface name or sw_if_index");
13032 if (new_show_dev_instance == ~0)
13034 errmsg ("missing new_show_dev_instance");
13038 M (INTERFACE_NAME_RENUMBER, mp);
13040 mp->sw_if_index = ntohl (sw_if_index);
13041 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13049 api_want_l2_macs_events (vat_main_t * vam)
13051 unformat_input_t *line_input = vam->input;
13052 vl_api_want_l2_macs_events_t *mp;
13053 u8 enable_disable = 1;
13054 u32 scan_delay = 0;
13055 u32 max_macs_in_event = 0;
13056 u32 learn_limit = 0;
13059 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13061 if (unformat (line_input, "learn-limit %d", &learn_limit))
13063 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13065 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13067 else if (unformat (line_input, "disable"))
13068 enable_disable = 0;
13073 M (WANT_L2_MACS_EVENTS, mp);
13074 mp->enable_disable = enable_disable;
13075 mp->pid = htonl (getpid ());
13076 mp->learn_limit = htonl (learn_limit);
13077 mp->scan_delay = (u8) scan_delay;
13078 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13085 api_input_acl_set_interface (vat_main_t * vam)
13087 unformat_input_t *i = vam->input;
13088 vl_api_input_acl_set_interface_t *mp;
13090 int sw_if_index_set;
13091 u32 ip4_table_index = ~0;
13092 u32 ip6_table_index = ~0;
13093 u32 l2_table_index = ~0;
13097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13099 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13100 sw_if_index_set = 1;
13101 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13102 sw_if_index_set = 1;
13103 else if (unformat (i, "del"))
13105 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13107 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13109 else if (unformat (i, "l2-table %d", &l2_table_index))
13113 clib_warning ("parse error '%U'", format_unformat_error, i);
13118 if (sw_if_index_set == 0)
13120 errmsg ("missing interface name or sw_if_index");
13124 M (INPUT_ACL_SET_INTERFACE, mp);
13126 mp->sw_if_index = ntohl (sw_if_index);
13127 mp->ip4_table_index = ntohl (ip4_table_index);
13128 mp->ip6_table_index = ntohl (ip6_table_index);
13129 mp->l2_table_index = ntohl (l2_table_index);
13130 mp->is_add = is_add;
13138 api_output_acl_set_interface (vat_main_t * vam)
13140 unformat_input_t *i = vam->input;
13141 vl_api_output_acl_set_interface_t *mp;
13143 int sw_if_index_set;
13144 u32 ip4_table_index = ~0;
13145 u32 ip6_table_index = ~0;
13146 u32 l2_table_index = ~0;
13150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13152 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13153 sw_if_index_set = 1;
13154 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13155 sw_if_index_set = 1;
13156 else if (unformat (i, "del"))
13158 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13160 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13162 else if (unformat (i, "l2-table %d", &l2_table_index))
13166 clib_warning ("parse error '%U'", format_unformat_error, i);
13171 if (sw_if_index_set == 0)
13173 errmsg ("missing interface name or sw_if_index");
13177 M (OUTPUT_ACL_SET_INTERFACE, mp);
13179 mp->sw_if_index = ntohl (sw_if_index);
13180 mp->ip4_table_index = ntohl (ip4_table_index);
13181 mp->ip6_table_index = ntohl (ip6_table_index);
13182 mp->l2_table_index = ntohl (l2_table_index);
13183 mp->is_add = is_add;
13191 api_ip_address_dump (vat_main_t * vam)
13193 unformat_input_t *i = vam->input;
13194 vl_api_ip_address_dump_t *mp;
13195 vl_api_control_ping_t *mp_ping;
13196 u32 sw_if_index = ~0;
13197 u8 sw_if_index_set = 0;
13202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13204 if (unformat (i, "sw_if_index %d", &sw_if_index))
13205 sw_if_index_set = 1;
13207 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13208 sw_if_index_set = 1;
13209 else if (unformat (i, "ipv4"))
13211 else if (unformat (i, "ipv6"))
13217 if (ipv4_set && ipv6_set)
13219 errmsg ("ipv4 and ipv6 flags cannot be both set");
13223 if ((!ipv4_set) && (!ipv6_set))
13225 errmsg ("no ipv4 nor ipv6 flag set");
13229 if (sw_if_index_set == 0)
13231 errmsg ("missing interface name or sw_if_index");
13235 vam->current_sw_if_index = sw_if_index;
13236 vam->is_ipv6 = ipv6_set;
13238 M (IP_ADDRESS_DUMP, mp);
13239 mp->sw_if_index = ntohl (sw_if_index);
13240 mp->is_ipv6 = ipv6_set;
13243 /* Use a control ping for synchronization */
13244 MPING (CONTROL_PING, mp_ping);
13252 api_ip_dump (vat_main_t * vam)
13254 vl_api_ip_dump_t *mp;
13255 vl_api_control_ping_t *mp_ping;
13256 unformat_input_t *in = vam->input;
13263 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13265 if (unformat (in, "ipv4"))
13267 else if (unformat (in, "ipv6"))
13273 if (ipv4_set && ipv6_set)
13275 errmsg ("ipv4 and ipv6 flags cannot be both set");
13279 if ((!ipv4_set) && (!ipv6_set))
13281 errmsg ("no ipv4 nor ipv6 flag set");
13285 is_ipv6 = ipv6_set;
13286 vam->is_ipv6 = is_ipv6;
13288 /* free old data */
13289 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13291 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13293 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13296 mp->is_ipv6 = ipv6_set;
13299 /* Use a control ping for synchronization */
13300 MPING (CONTROL_PING, mp_ping);
13308 api_ipsec_spd_add_del (vat_main_t * vam)
13310 unformat_input_t *i = vam->input;
13311 vl_api_ipsec_spd_add_del_t *mp;
13316 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13318 if (unformat (i, "spd_id %d", &spd_id))
13320 else if (unformat (i, "del"))
13324 clib_warning ("parse error '%U'", format_unformat_error, i);
13330 errmsg ("spd_id must be set");
13334 M (IPSEC_SPD_ADD_DEL, mp);
13336 mp->spd_id = ntohl (spd_id);
13337 mp->is_add = is_add;
13345 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13347 unformat_input_t *i = vam->input;
13348 vl_api_ipsec_interface_add_del_spd_t *mp;
13350 u8 sw_if_index_set = 0;
13351 u32 spd_id = (u32) ~ 0;
13355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13357 if (unformat (i, "del"))
13359 else if (unformat (i, "spd_id %d", &spd_id))
13362 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13363 sw_if_index_set = 1;
13364 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13365 sw_if_index_set = 1;
13368 clib_warning ("parse error '%U'", format_unformat_error, i);
13374 if (spd_id == (u32) ~ 0)
13376 errmsg ("spd_id must be set");
13380 if (sw_if_index_set == 0)
13382 errmsg ("missing interface name or sw_if_index");
13386 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13388 mp->spd_id = ntohl (spd_id);
13389 mp->sw_if_index = ntohl (sw_if_index);
13390 mp->is_add = is_add;
13398 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13400 unformat_input_t *i = vam->input;
13401 vl_api_ipsec_spd_entry_add_del_t *mp;
13402 u8 is_add = 1, is_outbound = 0;
13403 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13405 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13406 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13407 vl_api_address_t laddr_start = { }, laddr_stop =
13416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13418 if (unformat (i, "del"))
13420 if (unformat (i, "outbound"))
13422 if (unformat (i, "inbound"))
13424 else if (unformat (i, "spd_id %d", &spd_id))
13426 else if (unformat (i, "sa_id %d", &sa_id))
13428 else if (unformat (i, "priority %d", &priority))
13430 else if (unformat (i, "protocol %d", &protocol))
13432 else if (unformat (i, "lport_start %d", &lport_start))
13434 else if (unformat (i, "lport_stop %d", &lport_stop))
13436 else if (unformat (i, "rport_start %d", &rport_start))
13438 else if (unformat (i, "rport_stop %d", &rport_stop))
13440 else if (unformat (i, "laddr_start %U",
13441 unformat_vl_api_address, &laddr_start))
13443 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13446 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13449 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13453 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13455 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13457 clib_warning ("unsupported action: 'resolve'");
13463 clib_warning ("parse error '%U'", format_unformat_error, i);
13469 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13471 mp->is_add = is_add;
13473 mp->entry.spd_id = ntohl (spd_id);
13474 mp->entry.priority = ntohl (priority);
13475 mp->entry.is_outbound = is_outbound;
13477 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13478 sizeof (vl_api_address_t));
13479 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13480 sizeof (vl_api_address_t));
13481 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13482 sizeof (vl_api_address_t));
13483 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13484 sizeof (vl_api_address_t));
13486 mp->entry.protocol = (u8) protocol;
13487 mp->entry.local_port_start = ntohs ((u16) lport_start);
13488 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13489 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13490 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13491 mp->entry.policy = (u8) policy;
13492 mp->entry.sa_id = ntohl (sa_id);
13500 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13502 unformat_input_t *i = vam->input;
13503 vl_api_ipsec_sad_entry_add_del_t *mp;
13504 u32 sad_id = 0, spi = 0;
13505 u8 *ck = 0, *ik = 0;
13508 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13509 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13510 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13511 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13512 vl_api_address_t tun_src, tun_dst;
13515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13517 if (unformat (i, "del"))
13519 else if (unformat (i, "sad_id %d", &sad_id))
13521 else if (unformat (i, "spi %d", &spi))
13523 else if (unformat (i, "esp"))
13524 protocol = IPSEC_API_PROTO_ESP;
13526 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13528 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13529 if (ADDRESS_IP6 == tun_src.af)
13530 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13533 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13535 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13536 if (ADDRESS_IP6 == tun_src.af)
13537 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13540 if (unformat (i, "crypto_alg %U",
13541 unformat_ipsec_api_crypto_alg, &crypto_alg))
13543 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13545 else if (unformat (i, "integ_alg %U",
13546 unformat_ipsec_api_integ_alg, &integ_alg))
13548 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13552 clib_warning ("parse error '%U'", format_unformat_error, i);
13558 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13560 mp->is_add = is_add;
13561 mp->entry.sad_id = ntohl (sad_id);
13562 mp->entry.protocol = protocol;
13563 mp->entry.spi = ntohl (spi);
13564 mp->entry.flags = flags;
13566 mp->entry.crypto_algorithm = crypto_alg;
13567 mp->entry.integrity_algorithm = integ_alg;
13568 mp->entry.crypto_key.length = vec_len (ck);
13569 mp->entry.integrity_key.length = vec_len (ik);
13571 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13572 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13574 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13575 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13578 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13580 clib_memcpy (mp->entry.integrity_key.data, ik,
13581 mp->entry.integrity_key.length);
13583 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13585 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13586 sizeof (mp->entry.tunnel_src));
13587 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13588 sizeof (mp->entry.tunnel_dst));
13597 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13599 unformat_input_t *i = vam->input;
13600 vl_api_ipsec_tunnel_if_add_del_t *mp;
13601 u32 local_spi = 0, remote_spi = 0;
13602 u32 crypto_alg = 0, integ_alg = 0;
13603 u8 *lck = NULL, *rck = NULL;
13604 u8 *lik = NULL, *rik = NULL;
13605 vl_api_address_t local_ip = { 0 };
13606 vl_api_address_t remote_ip = { 0 };
13610 u8 anti_replay = 0;
13616 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13618 if (unformat (i, "del"))
13620 else if (unformat (i, "esn"))
13622 else if (unformat (i, "anti-replay"))
13624 else if (unformat (i, "count %d", &count))
13626 else if (unformat (i, "local_spi %d", &local_spi))
13628 else if (unformat (i, "remote_spi %d", &remote_spi))
13631 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13634 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13636 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13639 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13641 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13643 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13647 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13649 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13651 errmsg ("unsupported crypto-alg: '%U'\n",
13652 format_ipsec_crypto_alg, crypto_alg);
13658 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13660 if (integ_alg >= IPSEC_INTEG_N_ALG)
13662 errmsg ("unsupported integ-alg: '%U'\n",
13663 format_ipsec_integ_alg, integ_alg);
13667 else if (unformat (i, "instance %u", &instance))
13671 errmsg ("parse error '%U'\n", format_unformat_error, i);
13678 /* Turn on async mode */
13679 vam->async_mode = 1;
13680 vam->async_errors = 0;
13681 before = vat_time_now (vam);
13684 for (jj = 0; jj < count; jj++)
13686 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13688 mp->is_add = is_add;
13690 mp->anti_replay = anti_replay;
13693 increment_address (&remote_ip);
13695 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13696 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13698 mp->local_spi = htonl (local_spi + jj);
13699 mp->remote_spi = htonl (remote_spi + jj);
13700 mp->crypto_alg = (u8) crypto_alg;
13702 mp->local_crypto_key_len = 0;
13705 mp->local_crypto_key_len = vec_len (lck);
13706 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13707 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13708 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13711 mp->remote_crypto_key_len = 0;
13714 mp->remote_crypto_key_len = vec_len (rck);
13715 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13716 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13717 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13720 mp->integ_alg = (u8) integ_alg;
13722 mp->local_integ_key_len = 0;
13725 mp->local_integ_key_len = vec_len (lik);
13726 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13727 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13728 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13731 mp->remote_integ_key_len = 0;
13734 mp->remote_integ_key_len = vec_len (rik);
13735 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13736 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13737 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13742 mp->renumber = renumber;
13743 mp->show_instance = ntohl (instance);
13748 /* When testing multiple add/del ops, use a control-ping to sync */
13751 vl_api_control_ping_t *mp_ping;
13755 /* Shut off async mode */
13756 vam->async_mode = 0;
13758 MPING (CONTROL_PING, mp_ping);
13761 timeout = vat_time_now (vam) + 1.0;
13762 while (vat_time_now (vam) < timeout)
13763 if (vam->result_ready == 1)
13768 if (vam->retval == -99)
13769 errmsg ("timeout");
13771 if (vam->async_errors > 0)
13773 errmsg ("%d asynchronous errors", vam->async_errors);
13776 vam->async_errors = 0;
13777 after = vat_time_now (vam);
13779 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13783 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13784 count, after - before, count / (after - before));
13788 /* Wait for a reply... */
13797 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13799 vat_main_t *vam = &vat_main;
13801 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13802 "crypto_key %U integ_alg %u integ_key %U flags %x "
13803 "tunnel_src_addr %U tunnel_dst_addr %U "
13804 "salt %u seq_outbound %lu last_seq_inbound %lu "
13805 "replay_window %lu\n",
13806 ntohl (mp->entry.sad_id),
13807 ntohl (mp->sw_if_index),
13808 ntohl (mp->entry.spi),
13809 ntohl (mp->entry.protocol),
13810 ntohl (mp->entry.crypto_algorithm),
13811 format_hex_bytes, mp->entry.crypto_key.data,
13812 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13813 format_hex_bytes, mp->entry.integrity_key.data,
13814 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13815 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13816 &mp->entry.tunnel_dst, ntohl (mp->salt),
13817 clib_net_to_host_u64 (mp->seq_outbound),
13818 clib_net_to_host_u64 (mp->last_seq_inbound),
13819 clib_net_to_host_u64 (mp->replay_window));
13822 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13823 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13825 static void vl_api_ipsec_sa_details_t_handler_json
13826 (vl_api_ipsec_sa_details_t * mp)
13828 vat_main_t *vam = &vat_main;
13829 vat_json_node_t *node = NULL;
13830 vl_api_ipsec_sad_flags_t flags;
13832 if (VAT_JSON_ARRAY != vam->json_tree.type)
13834 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13835 vat_json_init_array (&vam->json_tree);
13837 node = vat_json_array_add (&vam->json_tree);
13839 vat_json_init_object (node);
13840 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13841 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13842 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13843 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13844 vat_json_object_add_uint (node, "crypto_alg",
13845 ntohl (mp->entry.crypto_algorithm));
13846 vat_json_object_add_uint (node, "integ_alg",
13847 ntohl (mp->entry.integrity_algorithm));
13848 flags = ntohl (mp->entry.flags);
13849 vat_json_object_add_uint (node, "use_esn",
13850 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13851 vat_json_object_add_uint (node, "use_anti_replay",
13852 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13853 vat_json_object_add_uint (node, "is_tunnel",
13854 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13855 vat_json_object_add_uint (node, "is_tunnel_ip6",
13856 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13857 vat_json_object_add_uint (node, "udp_encap",
13858 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13859 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13860 mp->entry.crypto_key.length);
13861 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13862 mp->entry.integrity_key.length);
13863 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13864 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13865 vat_json_object_add_uint (node, "replay_window",
13866 clib_net_to_host_u64 (mp->replay_window));
13870 api_ipsec_sa_dump (vat_main_t * vam)
13872 unformat_input_t *i = vam->input;
13873 vl_api_ipsec_sa_dump_t *mp;
13874 vl_api_control_ping_t *mp_ping;
13878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13880 if (unformat (i, "sa_id %d", &sa_id))
13884 clib_warning ("parse error '%U'", format_unformat_error, i);
13889 M (IPSEC_SA_DUMP, mp);
13891 mp->sa_id = ntohl (sa_id);
13895 /* Use a control ping for synchronization */
13896 M (CONTROL_PING, mp_ping);
13904 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13906 unformat_input_t *i = vam->input;
13907 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13908 u32 sw_if_index = ~0;
13910 u8 is_outbound = (u8) ~ 0;
13913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13915 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13917 else if (unformat (i, "sa_id %d", &sa_id))
13919 else if (unformat (i, "outbound"))
13921 else if (unformat (i, "inbound"))
13925 clib_warning ("parse error '%U'", format_unformat_error, i);
13930 if (sw_if_index == ~0)
13932 errmsg ("interface must be specified");
13938 errmsg ("SA ID must be specified");
13942 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13944 mp->sw_if_index = htonl (sw_if_index);
13945 mp->sa_id = htonl (sa_id);
13946 mp->is_outbound = is_outbound;
13955 api_get_first_msg_id (vat_main_t * vam)
13957 vl_api_get_first_msg_id_t *mp;
13958 unformat_input_t *i = vam->input;
13963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13965 if (unformat (i, "client %s", &name))
13973 errmsg ("missing client name");
13976 vec_add1 (name, 0);
13978 if (vec_len (name) > 63)
13980 errmsg ("client name too long");
13984 M (GET_FIRST_MSG_ID, mp);
13985 clib_memcpy (mp->name, name, vec_len (name));
13992 api_cop_interface_enable_disable (vat_main_t * vam)
13994 unformat_input_t *line_input = vam->input;
13995 vl_api_cop_interface_enable_disable_t *mp;
13996 u32 sw_if_index = ~0;
13997 u8 enable_disable = 1;
14000 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14002 if (unformat (line_input, "disable"))
14003 enable_disable = 0;
14004 if (unformat (line_input, "enable"))
14005 enable_disable = 1;
14006 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14007 vam, &sw_if_index))
14009 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14015 if (sw_if_index == ~0)
14017 errmsg ("missing interface name or sw_if_index");
14021 /* Construct the API message */
14022 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14023 mp->sw_if_index = ntohl (sw_if_index);
14024 mp->enable_disable = enable_disable;
14028 /* Wait for the reply */
14034 api_cop_whitelist_enable_disable (vat_main_t * vam)
14036 unformat_input_t *line_input = vam->input;
14037 vl_api_cop_whitelist_enable_disable_t *mp;
14038 u32 sw_if_index = ~0;
14039 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14043 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14045 if (unformat (line_input, "ip4"))
14047 else if (unformat (line_input, "ip6"))
14049 else if (unformat (line_input, "default"))
14051 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14052 vam, &sw_if_index))
14054 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14056 else if (unformat (line_input, "fib-id %d", &fib_id))
14062 if (sw_if_index == ~0)
14064 errmsg ("missing interface name or sw_if_index");
14068 /* Construct the API message */
14069 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14070 mp->sw_if_index = ntohl (sw_if_index);
14071 mp->fib_id = ntohl (fib_id);
14074 mp->default_cop = default_cop;
14078 /* Wait for the reply */
14084 api_get_node_graph (vat_main_t * vam)
14086 vl_api_get_node_graph_t *mp;
14089 M (GET_NODE_GRAPH, mp);
14093 /* Wait for the reply */
14099 /** Used for parsing LISP eids */
14100 typedef CLIB_PACKED(struct{
14101 u8 addr[16]; /**< eid address */
14102 u32 len; /**< prefix length if IP */
14103 u8 type; /**< type of eid */
14108 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14110 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14112 clib_memset (a, 0, sizeof (a[0]));
14114 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14116 a->type = 0; /* ipv4 type */
14118 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14120 a->type = 1; /* ipv6 type */
14122 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14124 a->type = 2; /* mac type */
14126 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14128 a->type = 3; /* NSH type */
14129 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14130 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14137 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14146 lisp_eid_size_vat (u8 type)
14163 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14165 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14169 api_one_add_del_locator_set (vat_main_t * vam)
14171 unformat_input_t *input = vam->input;
14172 vl_api_one_add_del_locator_set_t *mp;
14174 u8 *locator_set_name = NULL;
14175 u8 locator_set_name_set = 0;
14176 vl_api_local_locator_t locator, *locators = 0;
14177 u32 sw_if_index, priority, weight;
14181 /* Parse args required to build the message */
14182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14184 if (unformat (input, "del"))
14188 else if (unformat (input, "locator-set %s", &locator_set_name))
14190 locator_set_name_set = 1;
14192 else if (unformat (input, "sw_if_index %u p %u w %u",
14193 &sw_if_index, &priority, &weight))
14195 locator.sw_if_index = htonl (sw_if_index);
14196 locator.priority = priority;
14197 locator.weight = weight;
14198 vec_add1 (locators, locator);
14202 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14203 &sw_if_index, &priority, &weight))
14205 locator.sw_if_index = htonl (sw_if_index);
14206 locator.priority = priority;
14207 locator.weight = weight;
14208 vec_add1 (locators, locator);
14214 if (locator_set_name_set == 0)
14216 errmsg ("missing locator-set name");
14217 vec_free (locators);
14221 if (vec_len (locator_set_name) > 64)
14223 errmsg ("locator-set name too long");
14224 vec_free (locator_set_name);
14225 vec_free (locators);
14228 vec_add1 (locator_set_name, 0);
14230 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14232 /* Construct the API message */
14233 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14235 mp->is_add = is_add;
14236 clib_memcpy (mp->locator_set_name, locator_set_name,
14237 vec_len (locator_set_name));
14238 vec_free (locator_set_name);
14240 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14242 clib_memcpy (mp->locators, locators, data_len);
14243 vec_free (locators);
14248 /* Wait for a reply... */
14253 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14256 api_one_add_del_locator (vat_main_t * vam)
14258 unformat_input_t *input = vam->input;
14259 vl_api_one_add_del_locator_t *mp;
14260 u32 tmp_if_index = ~0;
14261 u32 sw_if_index = ~0;
14262 u8 sw_if_index_set = 0;
14263 u8 sw_if_index_if_name_set = 0;
14265 u8 priority_set = 0;
14269 u8 *locator_set_name = NULL;
14270 u8 locator_set_name_set = 0;
14273 /* Parse args required to build the message */
14274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14276 if (unformat (input, "del"))
14280 else if (unformat (input, "locator-set %s", &locator_set_name))
14282 locator_set_name_set = 1;
14284 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14287 sw_if_index_if_name_set = 1;
14288 sw_if_index = tmp_if_index;
14290 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14292 sw_if_index_set = 1;
14293 sw_if_index = tmp_if_index;
14295 else if (unformat (input, "p %d", &priority))
14299 else if (unformat (input, "w %d", &weight))
14307 if (locator_set_name_set == 0)
14309 errmsg ("missing locator-set name");
14313 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14315 errmsg ("missing sw_if_index");
14316 vec_free (locator_set_name);
14320 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14322 errmsg ("cannot use both params interface name and sw_if_index");
14323 vec_free (locator_set_name);
14327 if (priority_set == 0)
14329 errmsg ("missing locator-set priority");
14330 vec_free (locator_set_name);
14334 if (weight_set == 0)
14336 errmsg ("missing locator-set weight");
14337 vec_free (locator_set_name);
14341 if (vec_len (locator_set_name) > 64)
14343 errmsg ("locator-set name too long");
14344 vec_free (locator_set_name);
14347 vec_add1 (locator_set_name, 0);
14349 /* Construct the API message */
14350 M (ONE_ADD_DEL_LOCATOR, mp);
14352 mp->is_add = is_add;
14353 mp->sw_if_index = ntohl (sw_if_index);
14354 mp->priority = priority;
14355 mp->weight = weight;
14356 clib_memcpy (mp->locator_set_name, locator_set_name,
14357 vec_len (locator_set_name));
14358 vec_free (locator_set_name);
14363 /* Wait for a reply... */
14368 #define api_lisp_add_del_locator api_one_add_del_locator
14371 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14373 u32 *key_id = va_arg (*args, u32 *);
14376 if (unformat (input, "%s", &s))
14378 if (!strcmp ((char *) s, "sha1"))
14379 key_id[0] = HMAC_SHA_1_96;
14380 else if (!strcmp ((char *) s, "sha256"))
14381 key_id[0] = HMAC_SHA_256_128;
14384 clib_warning ("invalid key_id: '%s'", s);
14385 key_id[0] = HMAC_NO_KEY;
14396 api_one_add_del_local_eid (vat_main_t * vam)
14398 unformat_input_t *input = vam->input;
14399 vl_api_one_add_del_local_eid_t *mp;
14402 lisp_eid_vat_t _eid, *eid = &_eid;
14403 u8 *locator_set_name = 0;
14404 u8 locator_set_name_set = 0;
14410 /* Parse args required to build the message */
14411 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14413 if (unformat (input, "del"))
14417 else if (unformat (input, "vni %d", &vni))
14421 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14425 else if (unformat (input, "locator-set %s", &locator_set_name))
14427 locator_set_name_set = 1;
14429 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14431 else if (unformat (input, "secret-key %_%v%_", &key))
14437 if (locator_set_name_set == 0)
14439 errmsg ("missing locator-set name");
14445 errmsg ("EID address not set!");
14446 vec_free (locator_set_name);
14450 if (key && (0 == key_id))
14452 errmsg ("invalid key_id!");
14456 if (vec_len (key) > 64)
14458 errmsg ("key too long");
14463 if (vec_len (locator_set_name) > 64)
14465 errmsg ("locator-set name too long");
14466 vec_free (locator_set_name);
14469 vec_add1 (locator_set_name, 0);
14471 /* Construct the API message */
14472 M (ONE_ADD_DEL_LOCAL_EID, mp);
14474 mp->is_add = is_add;
14475 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14476 mp->eid_type = eid->type;
14477 mp->prefix_len = eid->len;
14478 mp->vni = clib_host_to_net_u32 (vni);
14479 mp->key_id = clib_host_to_net_u16 (key_id);
14480 clib_memcpy (mp->locator_set_name, locator_set_name,
14481 vec_len (locator_set_name));
14482 clib_memcpy (mp->key, key, vec_len (key));
14484 vec_free (locator_set_name);
14490 /* Wait for a reply... */
14495 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14498 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14500 u32 dp_table = 0, vni = 0;;
14501 unformat_input_t *input = vam->input;
14502 vl_api_gpe_add_del_fwd_entry_t *mp;
14504 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14505 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14506 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14507 u32 action = ~0, w;
14508 ip4_address_t rmt_rloc4, lcl_rloc4;
14509 ip6_address_t rmt_rloc6, lcl_rloc6;
14510 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14513 clib_memset (&rloc, 0, sizeof (rloc));
14515 /* Parse args required to build the message */
14516 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14518 if (unformat (input, "del"))
14520 else if (unformat (input, "add"))
14522 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14526 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14530 else if (unformat (input, "vrf %d", &dp_table))
14532 else if (unformat (input, "bd %d", &dp_table))
14534 else if (unformat (input, "vni %d", &vni))
14536 else if (unformat (input, "w %d", &w))
14540 errmsg ("No RLOC configured for setting priority/weight!");
14543 curr_rloc->weight = w;
14545 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14546 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14550 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14552 vec_add1 (lcl_locs, rloc);
14554 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14555 vec_add1 (rmt_locs, rloc);
14556 /* weight saved in rmt loc */
14557 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14559 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14560 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14563 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14565 vec_add1 (lcl_locs, rloc);
14567 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14568 vec_add1 (rmt_locs, rloc);
14569 /* weight saved in rmt loc */
14570 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14572 else if (unformat (input, "action %d", &action))
14578 clib_warning ("parse error '%U'", format_unformat_error, input);
14585 errmsg ("remote eid addresses not set");
14589 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14591 errmsg ("eid types don't match");
14595 if (0 == rmt_locs && (u32) ~ 0 == action)
14597 errmsg ("action not set for negative mapping");
14601 /* Construct the API message */
14602 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14603 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14605 mp->is_add = is_add;
14606 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14607 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14608 mp->eid_type = rmt_eid->type;
14609 mp->dp_table = clib_host_to_net_u32 (dp_table);
14610 mp->vni = clib_host_to_net_u32 (vni);
14611 mp->rmt_len = rmt_eid->len;
14612 mp->lcl_len = lcl_eid->len;
14613 mp->action = action;
14615 if (0 != rmt_locs && 0 != lcl_locs)
14617 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14618 clib_memcpy (mp->locs, lcl_locs,
14619 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14621 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14622 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14623 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14625 vec_free (lcl_locs);
14626 vec_free (rmt_locs);
14631 /* Wait for a reply... */
14637 api_one_add_del_map_server (vat_main_t * vam)
14639 unformat_input_t *input = vam->input;
14640 vl_api_one_add_del_map_server_t *mp;
14644 ip4_address_t ipv4;
14645 ip6_address_t ipv6;
14648 /* Parse args required to build the message */
14649 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14651 if (unformat (input, "del"))
14655 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14659 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14667 if (ipv4_set && ipv6_set)
14669 errmsg ("both eid v4 and v6 addresses set");
14673 if (!ipv4_set && !ipv6_set)
14675 errmsg ("eid addresses not set");
14679 /* Construct the API message */
14680 M (ONE_ADD_DEL_MAP_SERVER, mp);
14682 mp->is_add = is_add;
14686 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14691 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14697 /* Wait for a reply... */
14702 #define api_lisp_add_del_map_server api_one_add_del_map_server
14705 api_one_add_del_map_resolver (vat_main_t * vam)
14707 unformat_input_t *input = vam->input;
14708 vl_api_one_add_del_map_resolver_t *mp;
14712 ip4_address_t ipv4;
14713 ip6_address_t ipv6;
14716 /* Parse args required to build the message */
14717 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14719 if (unformat (input, "del"))
14723 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14727 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14735 if (ipv4_set && ipv6_set)
14737 errmsg ("both eid v4 and v6 addresses set");
14741 if (!ipv4_set && !ipv6_set)
14743 errmsg ("eid addresses not set");
14747 /* Construct the API message */
14748 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14750 mp->is_add = is_add;
14754 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14759 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14765 /* Wait for a reply... */
14770 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14773 api_lisp_gpe_enable_disable (vat_main_t * vam)
14775 unformat_input_t *input = vam->input;
14776 vl_api_gpe_enable_disable_t *mp;
14781 /* Parse args required to build the message */
14782 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14784 if (unformat (input, "enable"))
14789 else if (unformat (input, "disable"))
14800 errmsg ("Value not set");
14804 /* Construct the API message */
14805 M (GPE_ENABLE_DISABLE, mp);
14812 /* Wait for a reply... */
14818 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14820 unformat_input_t *input = vam->input;
14821 vl_api_one_rloc_probe_enable_disable_t *mp;
14826 /* Parse args required to build the message */
14827 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14829 if (unformat (input, "enable"))
14834 else if (unformat (input, "disable"))
14842 errmsg ("Value not set");
14846 /* Construct the API message */
14847 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14849 mp->is_enabled = is_en;
14854 /* Wait for a reply... */
14859 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14862 api_one_map_register_enable_disable (vat_main_t * vam)
14864 unformat_input_t *input = vam->input;
14865 vl_api_one_map_register_enable_disable_t *mp;
14870 /* Parse args required to build the message */
14871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14873 if (unformat (input, "enable"))
14878 else if (unformat (input, "disable"))
14886 errmsg ("Value not set");
14890 /* Construct the API message */
14891 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14893 mp->is_enabled = is_en;
14898 /* Wait for a reply... */
14903 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14906 api_one_enable_disable (vat_main_t * vam)
14908 unformat_input_t *input = vam->input;
14909 vl_api_one_enable_disable_t *mp;
14914 /* Parse args required to build the message */
14915 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14917 if (unformat (input, "enable"))
14922 else if (unformat (input, "disable"))
14932 errmsg ("Value not set");
14936 /* Construct the API message */
14937 M (ONE_ENABLE_DISABLE, mp);
14944 /* Wait for a reply... */
14949 #define api_lisp_enable_disable api_one_enable_disable
14952 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14954 unformat_input_t *input = vam->input;
14955 vl_api_one_enable_disable_xtr_mode_t *mp;
14960 /* Parse args required to build the message */
14961 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14963 if (unformat (input, "enable"))
14968 else if (unformat (input, "disable"))
14978 errmsg ("Value not set");
14982 /* Construct the API message */
14983 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
14990 /* Wait for a reply... */
14996 api_one_show_xtr_mode (vat_main_t * vam)
14998 vl_api_one_show_xtr_mode_t *mp;
15001 /* Construct the API message */
15002 M (ONE_SHOW_XTR_MODE, mp);
15007 /* Wait for a reply... */
15013 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15015 unformat_input_t *input = vam->input;
15016 vl_api_one_enable_disable_pitr_mode_t *mp;
15021 /* Parse args required to build the message */
15022 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15024 if (unformat (input, "enable"))
15029 else if (unformat (input, "disable"))
15039 errmsg ("Value not set");
15043 /* Construct the API message */
15044 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15051 /* Wait for a reply... */
15057 api_one_show_pitr_mode (vat_main_t * vam)
15059 vl_api_one_show_pitr_mode_t *mp;
15062 /* Construct the API message */
15063 M (ONE_SHOW_PITR_MODE, mp);
15068 /* Wait for a reply... */
15074 api_one_enable_disable_petr_mode (vat_main_t * vam)
15076 unformat_input_t *input = vam->input;
15077 vl_api_one_enable_disable_petr_mode_t *mp;
15082 /* Parse args required to build the message */
15083 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15085 if (unformat (input, "enable"))
15090 else if (unformat (input, "disable"))
15100 errmsg ("Value not set");
15104 /* Construct the API message */
15105 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15112 /* Wait for a reply... */
15118 api_one_show_petr_mode (vat_main_t * vam)
15120 vl_api_one_show_petr_mode_t *mp;
15123 /* Construct the API message */
15124 M (ONE_SHOW_PETR_MODE, mp);
15129 /* Wait for a reply... */
15135 api_show_one_map_register_state (vat_main_t * vam)
15137 vl_api_show_one_map_register_state_t *mp;
15140 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15145 /* wait for reply */
15150 #define api_show_lisp_map_register_state api_show_one_map_register_state
15153 api_show_one_rloc_probe_state (vat_main_t * vam)
15155 vl_api_show_one_rloc_probe_state_t *mp;
15158 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15163 /* wait for reply */
15168 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15171 api_one_add_del_ndp_entry (vat_main_t * vam)
15173 vl_api_one_add_del_ndp_entry_t *mp;
15174 unformat_input_t *input = vam->input;
15179 u8 mac[6] = { 0, };
15180 u8 ip6[16] = { 0, };
15184 /* Parse args required to build the message */
15185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15187 if (unformat (input, "del"))
15189 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15191 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15193 else if (unformat (input, "bd %d", &bd))
15197 errmsg ("parse error '%U'", format_unformat_error, input);
15202 if (!bd_set || !ip_set || (!mac_set && is_add))
15204 errmsg ("Missing BD, IP or MAC!");
15208 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15209 mp->is_add = is_add;
15210 clib_memcpy (mp->mac, mac, 6);
15211 mp->bd = clib_host_to_net_u32 (bd);
15212 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15217 /* wait for reply */
15223 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15225 vl_api_one_add_del_l2_arp_entry_t *mp;
15226 unformat_input_t *input = vam->input;
15231 u8 mac[6] = { 0, };
15232 u32 ip4 = 0, bd = ~0;
15235 /* Parse args required to build the message */
15236 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15238 if (unformat (input, "del"))
15240 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15242 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15244 else if (unformat (input, "bd %d", &bd))
15248 errmsg ("parse error '%U'", format_unformat_error, input);
15253 if (!bd_set || !ip_set || (!mac_set && is_add))
15255 errmsg ("Missing BD, IP or MAC!");
15259 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15260 mp->is_add = is_add;
15261 clib_memcpy (mp->mac, mac, 6);
15262 mp->bd = clib_host_to_net_u32 (bd);
15268 /* wait for reply */
15274 api_one_ndp_bd_get (vat_main_t * vam)
15276 vl_api_one_ndp_bd_get_t *mp;
15279 M (ONE_NDP_BD_GET, mp);
15284 /* wait for reply */
15290 api_one_ndp_entries_get (vat_main_t * vam)
15292 vl_api_one_ndp_entries_get_t *mp;
15293 unformat_input_t *input = vam->input;
15298 /* Parse args required to build the message */
15299 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15301 if (unformat (input, "bd %d", &bd))
15305 errmsg ("parse error '%U'", format_unformat_error, input);
15312 errmsg ("Expected bridge domain!");
15316 M (ONE_NDP_ENTRIES_GET, mp);
15317 mp->bd = clib_host_to_net_u32 (bd);
15322 /* wait for reply */
15328 api_one_l2_arp_bd_get (vat_main_t * vam)
15330 vl_api_one_l2_arp_bd_get_t *mp;
15333 M (ONE_L2_ARP_BD_GET, mp);
15338 /* wait for reply */
15344 api_one_l2_arp_entries_get (vat_main_t * vam)
15346 vl_api_one_l2_arp_entries_get_t *mp;
15347 unformat_input_t *input = vam->input;
15352 /* Parse args required to build the message */
15353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15355 if (unformat (input, "bd %d", &bd))
15359 errmsg ("parse error '%U'", format_unformat_error, input);
15366 errmsg ("Expected bridge domain!");
15370 M (ONE_L2_ARP_ENTRIES_GET, mp);
15371 mp->bd = clib_host_to_net_u32 (bd);
15376 /* wait for reply */
15382 api_one_stats_enable_disable (vat_main_t * vam)
15384 vl_api_one_stats_enable_disable_t *mp;
15385 unformat_input_t *input = vam->input;
15390 /* Parse args required to build the message */
15391 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15393 if (unformat (input, "enable"))
15398 else if (unformat (input, "disable"))
15408 errmsg ("Value not set");
15412 M (ONE_STATS_ENABLE_DISABLE, mp);
15418 /* wait for reply */
15424 api_show_one_stats_enable_disable (vat_main_t * vam)
15426 vl_api_show_one_stats_enable_disable_t *mp;
15429 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15434 /* wait for reply */
15440 api_show_one_map_request_mode (vat_main_t * vam)
15442 vl_api_show_one_map_request_mode_t *mp;
15445 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15450 /* wait for reply */
15455 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15458 api_one_map_request_mode (vat_main_t * vam)
15460 unformat_input_t *input = vam->input;
15461 vl_api_one_map_request_mode_t *mp;
15465 /* Parse args required to build the message */
15466 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15468 if (unformat (input, "dst-only"))
15470 else if (unformat (input, "src-dst"))
15474 errmsg ("parse error '%U'", format_unformat_error, input);
15479 M (ONE_MAP_REQUEST_MODE, mp);
15486 /* wait for reply */
15491 #define api_lisp_map_request_mode api_one_map_request_mode
15494 * Enable/disable ONE proxy ITR.
15496 * @param vam vpp API test context
15497 * @return return code
15500 api_one_pitr_set_locator_set (vat_main_t * vam)
15502 u8 ls_name_set = 0;
15503 unformat_input_t *input = vam->input;
15504 vl_api_one_pitr_set_locator_set_t *mp;
15509 /* Parse args required to build the message */
15510 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15512 if (unformat (input, "del"))
15514 else if (unformat (input, "locator-set %s", &ls_name))
15518 errmsg ("parse error '%U'", format_unformat_error, input);
15525 errmsg ("locator-set name not set!");
15529 M (ONE_PITR_SET_LOCATOR_SET, mp);
15531 mp->is_add = is_add;
15532 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15533 vec_free (ls_name);
15538 /* wait for reply */
15543 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15546 api_one_nsh_set_locator_set (vat_main_t * vam)
15548 u8 ls_name_set = 0;
15549 unformat_input_t *input = vam->input;
15550 vl_api_one_nsh_set_locator_set_t *mp;
15555 /* Parse args required to build the message */
15556 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15558 if (unformat (input, "del"))
15560 else if (unformat (input, "ls %s", &ls_name))
15564 errmsg ("parse error '%U'", format_unformat_error, input);
15569 if (!ls_name_set && is_add)
15571 errmsg ("locator-set name not set!");
15575 M (ONE_NSH_SET_LOCATOR_SET, mp);
15577 mp->is_add = is_add;
15578 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15579 vec_free (ls_name);
15584 /* wait for reply */
15590 api_show_one_pitr (vat_main_t * vam)
15592 vl_api_show_one_pitr_t *mp;
15595 if (!vam->json_output)
15597 print (vam->ofp, "%=20s", "lisp status:");
15600 M (SHOW_ONE_PITR, mp);
15604 /* Wait for a reply... */
15609 #define api_show_lisp_pitr api_show_one_pitr
15612 api_one_use_petr (vat_main_t * vam)
15614 unformat_input_t *input = vam->input;
15615 vl_api_one_use_petr_t *mp;
15620 clib_memset (&ip, 0, sizeof (ip));
15622 /* Parse args required to build the message */
15623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15625 if (unformat (input, "disable"))
15628 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15631 ip_addr_version (&ip) = AF_IP4;
15634 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15637 ip_addr_version (&ip) = AF_IP6;
15641 errmsg ("parse error '%U'", format_unformat_error, input);
15646 M (ONE_USE_PETR, mp);
15648 mp->is_add = is_add;
15651 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15653 clib_memcpy (mp->address, &ip, 4);
15655 clib_memcpy (mp->address, &ip, 16);
15661 /* wait for reply */
15666 #define api_lisp_use_petr api_one_use_petr
15669 api_show_one_nsh_mapping (vat_main_t * vam)
15671 vl_api_show_one_use_petr_t *mp;
15674 if (!vam->json_output)
15676 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15679 M (SHOW_ONE_NSH_MAPPING, mp);
15683 /* Wait for a reply... */
15689 api_show_one_use_petr (vat_main_t * vam)
15691 vl_api_show_one_use_petr_t *mp;
15694 if (!vam->json_output)
15696 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15699 M (SHOW_ONE_USE_PETR, mp);
15703 /* Wait for a reply... */
15708 #define api_show_lisp_use_petr api_show_one_use_petr
15711 * Add/delete mapping between vni and vrf
15714 api_one_eid_table_add_del_map (vat_main_t * vam)
15716 unformat_input_t *input = vam->input;
15717 vl_api_one_eid_table_add_del_map_t *mp;
15718 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15719 u32 vni, vrf, bd_index;
15722 /* Parse args required to build the message */
15723 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15725 if (unformat (input, "del"))
15727 else if (unformat (input, "vrf %d", &vrf))
15729 else if (unformat (input, "bd_index %d", &bd_index))
15731 else if (unformat (input, "vni %d", &vni))
15737 if (!vni_set || (!vrf_set && !bd_index_set))
15739 errmsg ("missing arguments!");
15743 if (vrf_set && bd_index_set)
15745 errmsg ("error: both vrf and bd entered!");
15749 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15751 mp->is_add = is_add;
15752 mp->vni = htonl (vni);
15753 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15754 mp->is_l2 = bd_index_set;
15759 /* wait for reply */
15764 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15767 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15769 u32 *action = va_arg (*args, u32 *);
15772 if (unformat (input, "%s", &s))
15774 if (!strcmp ((char *) s, "no-action"))
15776 else if (!strcmp ((char *) s, "natively-forward"))
15778 else if (!strcmp ((char *) s, "send-map-request"))
15780 else if (!strcmp ((char *) s, "drop"))
15784 clib_warning ("invalid action: '%s'", s);
15796 * Add/del remote mapping to/from ONE control plane
15798 * @param vam vpp API test context
15799 * @return return code
15802 api_one_add_del_remote_mapping (vat_main_t * vam)
15804 unformat_input_t *input = vam->input;
15805 vl_api_one_add_del_remote_mapping_t *mp;
15807 lisp_eid_vat_t _eid, *eid = &_eid;
15808 lisp_eid_vat_t _seid, *seid = &_seid;
15809 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15810 u32 action = ~0, p, w, data_len;
15811 ip4_address_t rloc4;
15812 ip6_address_t rloc6;
15813 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15816 clib_memset (&rloc, 0, sizeof (rloc));
15818 /* Parse args required to build the message */
15819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15821 if (unformat (input, "del-all"))
15825 else if (unformat (input, "del"))
15829 else if (unformat (input, "add"))
15833 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15837 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15841 else if (unformat (input, "vni %d", &vni))
15845 else if (unformat (input, "p %d w %d", &p, &w))
15849 errmsg ("No RLOC configured for setting priority/weight!");
15852 curr_rloc->priority = p;
15853 curr_rloc->weight = w;
15855 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15858 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15859 vec_add1 (rlocs, rloc);
15860 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15862 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15865 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15866 vec_add1 (rlocs, rloc);
15867 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15869 else if (unformat (input, "action %U",
15870 unformat_negative_mapping_action, &action))
15876 clib_warning ("parse error '%U'", format_unformat_error, input);
15883 errmsg ("missing params!");
15887 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15889 errmsg ("no action set for negative map-reply!");
15893 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15895 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15896 mp->is_add = is_add;
15897 mp->vni = htonl (vni);
15898 mp->action = (u8) action;
15899 mp->is_src_dst = seid_set;
15900 mp->eid_len = eid->len;
15901 mp->seid_len = seid->len;
15902 mp->del_all = del_all;
15903 mp->eid_type = eid->type;
15904 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15905 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15907 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15908 clib_memcpy (mp->rlocs, rlocs, data_len);
15914 /* Wait for a reply... */
15919 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15922 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15923 * forwarding entries in data-plane accordingly.
15925 * @param vam vpp API test context
15926 * @return return code
15929 api_one_add_del_adjacency (vat_main_t * vam)
15931 unformat_input_t *input = vam->input;
15932 vl_api_one_add_del_adjacency_t *mp;
15934 ip4_address_t leid4, reid4;
15935 ip6_address_t leid6, reid6;
15936 u8 reid_mac[6] = { 0 };
15937 u8 leid_mac[6] = { 0 };
15938 u8 reid_type, leid_type;
15939 u32 leid_len = 0, reid_len = 0, len;
15943 leid_type = reid_type = (u8) ~ 0;
15945 /* Parse args required to build the message */
15946 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15948 if (unformat (input, "del"))
15952 else if (unformat (input, "add"))
15956 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15959 reid_type = 0; /* ipv4 */
15962 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15965 reid_type = 1; /* ipv6 */
15968 else if (unformat (input, "reid %U", unformat_ethernet_address,
15971 reid_type = 2; /* mac */
15973 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15976 leid_type = 0; /* ipv4 */
15979 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15982 leid_type = 1; /* ipv6 */
15985 else if (unformat (input, "leid %U", unformat_ethernet_address,
15988 leid_type = 2; /* mac */
15990 else if (unformat (input, "vni %d", &vni))
15996 errmsg ("parse error '%U'", format_unformat_error, input);
16001 if ((u8) ~ 0 == reid_type)
16003 errmsg ("missing params!");
16007 if (leid_type != reid_type)
16009 errmsg ("remote and local EIDs are of different types!");
16013 M (ONE_ADD_DEL_ADJACENCY, mp);
16014 mp->is_add = is_add;
16015 mp->vni = htonl (vni);
16016 mp->leid_len = leid_len;
16017 mp->reid_len = reid_len;
16018 mp->eid_type = reid_type;
16020 switch (mp->eid_type)
16023 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16024 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16027 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16028 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16031 clib_memcpy (mp->leid, leid_mac, 6);
16032 clib_memcpy (mp->reid, reid_mac, 6);
16035 errmsg ("unknown EID type %d!", mp->eid_type);
16042 /* Wait for a reply... */
16047 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16050 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16052 u32 *mode = va_arg (*args, u32 *);
16054 if (unformat (input, "lisp"))
16056 else if (unformat (input, "vxlan"))
16065 api_gpe_get_encap_mode (vat_main_t * vam)
16067 vl_api_gpe_get_encap_mode_t *mp;
16070 /* Construct the API message */
16071 M (GPE_GET_ENCAP_MODE, mp);
16076 /* Wait for a reply... */
16082 api_gpe_set_encap_mode (vat_main_t * vam)
16084 unformat_input_t *input = vam->input;
16085 vl_api_gpe_set_encap_mode_t *mp;
16089 /* Parse args required to build the message */
16090 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16092 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16098 /* Construct the API message */
16099 M (GPE_SET_ENCAP_MODE, mp);
16106 /* Wait for a reply... */
16112 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16114 unformat_input_t *input = vam->input;
16115 vl_api_gpe_add_del_iface_t *mp;
16116 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16117 u32 dp_table = 0, vni = 0;
16120 /* Parse args required to build the message */
16121 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16123 if (unformat (input, "up"))
16128 else if (unformat (input, "down"))
16133 else if (unformat (input, "table_id %d", &dp_table))
16137 else if (unformat (input, "bd_id %d", &dp_table))
16142 else if (unformat (input, "vni %d", &vni))
16150 if (action_set == 0)
16152 errmsg ("Action not set");
16155 if (dp_table_set == 0 || vni_set == 0)
16157 errmsg ("vni and dp_table must be set");
16161 /* Construct the API message */
16162 M (GPE_ADD_DEL_IFACE, mp);
16164 mp->is_add = is_add;
16165 mp->dp_table = clib_host_to_net_u32 (dp_table);
16167 mp->vni = clib_host_to_net_u32 (vni);
16172 /* Wait for a reply... */
16178 api_one_map_register_fallback_threshold (vat_main_t * vam)
16180 unformat_input_t *input = vam->input;
16181 vl_api_one_map_register_fallback_threshold_t *mp;
16186 /* Parse args required to build the message */
16187 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16189 if (unformat (input, "%u", &value))
16193 clib_warning ("parse error '%U'", format_unformat_error, input);
16200 errmsg ("fallback threshold value is missing!");
16204 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16205 mp->value = clib_host_to_net_u32 (value);
16210 /* Wait for a reply... */
16216 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16218 vl_api_show_one_map_register_fallback_threshold_t *mp;
16221 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16226 /* Wait for a reply... */
16232 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16234 u32 *proto = va_arg (*args, u32 *);
16236 if (unformat (input, "udp"))
16238 else if (unformat (input, "api"))
16247 api_one_set_transport_protocol (vat_main_t * vam)
16249 unformat_input_t *input = vam->input;
16250 vl_api_one_set_transport_protocol_t *mp;
16255 /* Parse args required to build the message */
16256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16258 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16262 clib_warning ("parse error '%U'", format_unformat_error, input);
16269 errmsg ("Transport protocol missing!");
16273 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16274 mp->protocol = (u8) protocol;
16279 /* Wait for a reply... */
16285 api_one_get_transport_protocol (vat_main_t * vam)
16287 vl_api_one_get_transport_protocol_t *mp;
16290 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16295 /* Wait for a reply... */
16301 api_one_map_register_set_ttl (vat_main_t * vam)
16303 unformat_input_t *input = vam->input;
16304 vl_api_one_map_register_set_ttl_t *mp;
16309 /* Parse args required to build the message */
16310 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16312 if (unformat (input, "%u", &ttl))
16316 clib_warning ("parse error '%U'", format_unformat_error, input);
16323 errmsg ("TTL value missing!");
16327 M (ONE_MAP_REGISTER_SET_TTL, mp);
16328 mp->ttl = clib_host_to_net_u32 (ttl);
16333 /* Wait for a reply... */
16339 api_show_one_map_register_ttl (vat_main_t * vam)
16341 vl_api_show_one_map_register_ttl_t *mp;
16344 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16349 /* Wait for a reply... */
16355 * Add/del map request itr rlocs from ONE control plane and updates
16357 * @param vam vpp API test context
16358 * @return return code
16361 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16363 unformat_input_t *input = vam->input;
16364 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16365 u8 *locator_set_name = 0;
16366 u8 locator_set_name_set = 0;
16370 /* Parse args required to build the message */
16371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16373 if (unformat (input, "del"))
16377 else if (unformat (input, "%_%v%_", &locator_set_name))
16379 locator_set_name_set = 1;
16383 clib_warning ("parse error '%U'", format_unformat_error, input);
16388 if (is_add && !locator_set_name_set)
16390 errmsg ("itr-rloc is not set!");
16394 if (is_add && vec_len (locator_set_name) > 64)
16396 errmsg ("itr-rloc locator-set name too long");
16397 vec_free (locator_set_name);
16401 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16402 mp->is_add = is_add;
16405 clib_memcpy (mp->locator_set_name, locator_set_name,
16406 vec_len (locator_set_name));
16410 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16412 vec_free (locator_set_name);
16417 /* Wait for a reply... */
16422 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16425 api_one_locator_dump (vat_main_t * vam)
16427 unformat_input_t *input = vam->input;
16428 vl_api_one_locator_dump_t *mp;
16429 vl_api_control_ping_t *mp_ping;
16430 u8 is_index_set = 0, is_name_set = 0;
16435 /* Parse args required to build the message */
16436 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16438 if (unformat (input, "ls_name %_%v%_", &ls_name))
16442 else if (unformat (input, "ls_index %d", &ls_index))
16448 errmsg ("parse error '%U'", format_unformat_error, input);
16453 if (!is_index_set && !is_name_set)
16455 errmsg ("error: expected one of index or name!");
16459 if (is_index_set && is_name_set)
16461 errmsg ("error: only one param expected!");
16465 if (vec_len (ls_name) > 62)
16467 errmsg ("error: locator set name too long!");
16471 if (!vam->json_output)
16473 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16476 M (ONE_LOCATOR_DUMP, mp);
16477 mp->is_index_set = is_index_set;
16480 mp->ls_index = clib_host_to_net_u32 (ls_index);
16483 vec_add1 (ls_name, 0);
16484 strncpy ((char *) mp->ls_name, (char *) ls_name,
16485 sizeof (mp->ls_name) - 1);
16491 /* Use a control ping for synchronization */
16492 MPING (CONTROL_PING, mp_ping);
16495 /* Wait for a reply... */
16500 #define api_lisp_locator_dump api_one_locator_dump
16503 api_one_locator_set_dump (vat_main_t * vam)
16505 vl_api_one_locator_set_dump_t *mp;
16506 vl_api_control_ping_t *mp_ping;
16507 unformat_input_t *input = vam->input;
16511 /* Parse args required to build the message */
16512 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16514 if (unformat (input, "local"))
16518 else if (unformat (input, "remote"))
16524 errmsg ("parse error '%U'", format_unformat_error, input);
16529 if (!vam->json_output)
16531 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16534 M (ONE_LOCATOR_SET_DUMP, mp);
16536 mp->filter = filter;
16541 /* Use a control ping for synchronization */
16542 MPING (CONTROL_PING, mp_ping);
16545 /* Wait for a reply... */
16550 #define api_lisp_locator_set_dump api_one_locator_set_dump
16553 api_one_eid_table_map_dump (vat_main_t * vam)
16557 unformat_input_t *input = vam->input;
16558 vl_api_one_eid_table_map_dump_t *mp;
16559 vl_api_control_ping_t *mp_ping;
16562 /* Parse args required to build the message */
16563 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16565 if (unformat (input, "l2"))
16570 else if (unformat (input, "l3"))
16577 errmsg ("parse error '%U'", format_unformat_error, input);
16584 errmsg ("expected one of 'l2' or 'l3' parameter!");
16588 if (!vam->json_output)
16590 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16593 M (ONE_EID_TABLE_MAP_DUMP, mp);
16599 /* Use a control ping for synchronization */
16600 MPING (CONTROL_PING, mp_ping);
16603 /* Wait for a reply... */
16608 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16611 api_one_eid_table_vni_dump (vat_main_t * vam)
16613 vl_api_one_eid_table_vni_dump_t *mp;
16614 vl_api_control_ping_t *mp_ping;
16617 if (!vam->json_output)
16619 print (vam->ofp, "VNI");
16622 M (ONE_EID_TABLE_VNI_DUMP, mp);
16627 /* Use a control ping for synchronization */
16628 MPING (CONTROL_PING, mp_ping);
16631 /* Wait for a reply... */
16636 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16639 api_one_eid_table_dump (vat_main_t * vam)
16641 unformat_input_t *i = vam->input;
16642 vl_api_one_eid_table_dump_t *mp;
16643 vl_api_control_ping_t *mp_ping;
16644 struct in_addr ip4;
16645 struct in6_addr ip6;
16647 u8 eid_type = ~0, eid_set = 0;
16648 u32 prefix_length = ~0, t, vni = 0;
16651 lisp_nsh_api_t nsh;
16653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16655 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16661 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16667 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16672 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16677 else if (unformat (i, "vni %d", &t))
16681 else if (unformat (i, "local"))
16685 else if (unformat (i, "remote"))
16691 errmsg ("parse error '%U'", format_unformat_error, i);
16696 if (!vam->json_output)
16698 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16699 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16702 M (ONE_EID_TABLE_DUMP, mp);
16704 mp->filter = filter;
16708 mp->vni = htonl (vni);
16709 mp->eid_type = eid_type;
16713 mp->prefix_length = prefix_length;
16714 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16717 mp->prefix_length = prefix_length;
16718 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16721 clib_memcpy (mp->eid, mac, sizeof (mac));
16724 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16727 errmsg ("unknown EID type %d!", eid_type);
16735 /* Use a control ping for synchronization */
16736 MPING (CONTROL_PING, mp_ping);
16739 /* Wait for a reply... */
16744 #define api_lisp_eid_table_dump api_one_eid_table_dump
16747 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16749 unformat_input_t *i = vam->input;
16750 vl_api_gpe_fwd_entries_get_t *mp;
16755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16757 if (unformat (i, "vni %d", &vni))
16763 errmsg ("parse error '%U'", format_unformat_error, i);
16770 errmsg ("vni not set!");
16774 if (!vam->json_output)
16776 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16780 M (GPE_FWD_ENTRIES_GET, mp);
16781 mp->vni = clib_host_to_net_u32 (vni);
16786 /* Wait for a reply... */
16791 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16792 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16793 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16794 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16795 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16796 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16797 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16798 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16801 api_one_adjacencies_get (vat_main_t * vam)
16803 unformat_input_t *i = vam->input;
16804 vl_api_one_adjacencies_get_t *mp;
16809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16811 if (unformat (i, "vni %d", &vni))
16817 errmsg ("parse error '%U'", format_unformat_error, i);
16824 errmsg ("vni not set!");
16828 if (!vam->json_output)
16830 print (vam->ofp, "%s %40s", "leid", "reid");
16833 M (ONE_ADJACENCIES_GET, mp);
16834 mp->vni = clib_host_to_net_u32 (vni);
16839 /* Wait for a reply... */
16844 #define api_lisp_adjacencies_get api_one_adjacencies_get
16847 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16849 unformat_input_t *i = vam->input;
16850 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16852 u8 ip_family_set = 0, is_ip4 = 1;
16854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16856 if (unformat (i, "ip4"))
16861 else if (unformat (i, "ip6"))
16868 errmsg ("parse error '%U'", format_unformat_error, i);
16873 if (!ip_family_set)
16875 errmsg ("ip family not set!");
16879 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16880 mp->is_ip4 = is_ip4;
16885 /* Wait for a reply... */
16891 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16893 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16896 if (!vam->json_output)
16898 print (vam->ofp, "VNIs");
16901 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16906 /* Wait for a reply... */
16912 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16914 unformat_input_t *i = vam->input;
16915 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16917 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16918 struct in_addr ip4;
16919 struct in6_addr ip6;
16920 u32 table_id = 0, nh_sw_if_index = ~0;
16922 clib_memset (&ip4, 0, sizeof (ip4));
16923 clib_memset (&ip6, 0, sizeof (ip6));
16925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16927 if (unformat (i, "del"))
16929 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16930 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16935 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16936 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16941 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16945 nh_sw_if_index = ~0;
16947 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16951 nh_sw_if_index = ~0;
16953 else if (unformat (i, "table %d", &table_id))
16957 errmsg ("parse error '%U'", format_unformat_error, i);
16964 errmsg ("nh addr not set!");
16968 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16969 mp->is_add = is_add;
16970 mp->table_id = clib_host_to_net_u32 (table_id);
16971 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16972 mp->is_ip4 = is_ip4;
16974 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16976 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16981 /* Wait for a reply... */
16987 api_one_map_server_dump (vat_main_t * vam)
16989 vl_api_one_map_server_dump_t *mp;
16990 vl_api_control_ping_t *mp_ping;
16993 if (!vam->json_output)
16995 print (vam->ofp, "%=20s", "Map server");
16998 M (ONE_MAP_SERVER_DUMP, mp);
17002 /* Use a control ping for synchronization */
17003 MPING (CONTROL_PING, mp_ping);
17006 /* Wait for a reply... */
17011 #define api_lisp_map_server_dump api_one_map_server_dump
17014 api_one_map_resolver_dump (vat_main_t * vam)
17016 vl_api_one_map_resolver_dump_t *mp;
17017 vl_api_control_ping_t *mp_ping;
17020 if (!vam->json_output)
17022 print (vam->ofp, "%=20s", "Map resolver");
17025 M (ONE_MAP_RESOLVER_DUMP, mp);
17029 /* Use a control ping for synchronization */
17030 MPING (CONTROL_PING, mp_ping);
17033 /* Wait for a reply... */
17038 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17041 api_one_stats_flush (vat_main_t * vam)
17043 vl_api_one_stats_flush_t *mp;
17046 M (ONE_STATS_FLUSH, mp);
17053 api_one_stats_dump (vat_main_t * vam)
17055 vl_api_one_stats_dump_t *mp;
17056 vl_api_control_ping_t *mp_ping;
17059 M (ONE_STATS_DUMP, mp);
17063 /* Use a control ping for synchronization */
17064 MPING (CONTROL_PING, mp_ping);
17067 /* Wait for a reply... */
17073 api_show_one_status (vat_main_t * vam)
17075 vl_api_show_one_status_t *mp;
17078 if (!vam->json_output)
17080 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17083 M (SHOW_ONE_STATUS, mp);
17086 /* Wait for a reply... */
17091 #define api_show_lisp_status api_show_one_status
17094 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17096 vl_api_gpe_fwd_entry_path_dump_t *mp;
17097 vl_api_control_ping_t *mp_ping;
17098 unformat_input_t *i = vam->input;
17099 u32 fwd_entry_index = ~0;
17102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17104 if (unformat (i, "index %d", &fwd_entry_index))
17110 if (~0 == fwd_entry_index)
17112 errmsg ("no index specified!");
17116 if (!vam->json_output)
17118 print (vam->ofp, "first line");
17121 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17125 /* Use a control ping for synchronization */
17126 MPING (CONTROL_PING, mp_ping);
17129 /* Wait for a reply... */
17135 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17137 vl_api_one_get_map_request_itr_rlocs_t *mp;
17140 if (!vam->json_output)
17142 print (vam->ofp, "%=20s", "itr-rlocs:");
17145 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17148 /* Wait for a reply... */
17153 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17156 api_af_packet_create (vat_main_t * vam)
17158 unformat_input_t *i = vam->input;
17159 vl_api_af_packet_create_t *mp;
17160 u8 *host_if_name = 0;
17162 u8 random_hw_addr = 1;
17165 clib_memset (hw_addr, 0, sizeof (hw_addr));
17167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17169 if (unformat (i, "name %s", &host_if_name))
17170 vec_add1 (host_if_name, 0);
17171 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17172 random_hw_addr = 0;
17177 if (!vec_len (host_if_name))
17179 errmsg ("host-interface name must be specified");
17183 if (vec_len (host_if_name) > 64)
17185 errmsg ("host-interface name too long");
17189 M (AF_PACKET_CREATE, mp);
17191 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17192 clib_memcpy (mp->hw_addr, hw_addr, 6);
17193 mp->use_random_hw_addr = random_hw_addr;
17194 vec_free (host_if_name);
17202 fprintf (vam->ofp ? vam->ofp : stderr,
17203 " new sw_if_index = %d\n", vam->sw_if_index);
17210 api_af_packet_delete (vat_main_t * vam)
17212 unformat_input_t *i = vam->input;
17213 vl_api_af_packet_delete_t *mp;
17214 u8 *host_if_name = 0;
17217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17219 if (unformat (i, "name %s", &host_if_name))
17220 vec_add1 (host_if_name, 0);
17225 if (!vec_len (host_if_name))
17227 errmsg ("host-interface name must be specified");
17231 if (vec_len (host_if_name) > 64)
17233 errmsg ("host-interface name too long");
17237 M (AF_PACKET_DELETE, mp);
17239 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17240 vec_free (host_if_name);
17247 static void vl_api_af_packet_details_t_handler
17248 (vl_api_af_packet_details_t * mp)
17250 vat_main_t *vam = &vat_main;
17252 print (vam->ofp, "%-16s %d",
17253 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17256 static void vl_api_af_packet_details_t_handler_json
17257 (vl_api_af_packet_details_t * mp)
17259 vat_main_t *vam = &vat_main;
17260 vat_json_node_t *node = NULL;
17262 if (VAT_JSON_ARRAY != vam->json_tree.type)
17264 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17265 vat_json_init_array (&vam->json_tree);
17267 node = vat_json_array_add (&vam->json_tree);
17269 vat_json_init_object (node);
17270 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17271 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17275 api_af_packet_dump (vat_main_t * vam)
17277 vl_api_af_packet_dump_t *mp;
17278 vl_api_control_ping_t *mp_ping;
17281 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17282 /* Get list of tap interfaces */
17283 M (AF_PACKET_DUMP, mp);
17286 /* Use a control ping for synchronization */
17287 MPING (CONTROL_PING, mp_ping);
17295 api_policer_add_del (vat_main_t * vam)
17297 unformat_input_t *i = vam->input;
17298 vl_api_policer_add_del_t *mp;
17308 u8 color_aware = 0;
17309 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17312 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17313 conform_action.dscp = 0;
17314 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17315 exceed_action.dscp = 0;
17316 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17317 violate_action.dscp = 0;
17319 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17321 if (unformat (i, "del"))
17323 else if (unformat (i, "name %s", &name))
17324 vec_add1 (name, 0);
17325 else if (unformat (i, "cir %u", &cir))
17327 else if (unformat (i, "eir %u", &eir))
17329 else if (unformat (i, "cb %u", &cb))
17331 else if (unformat (i, "eb %u", &eb))
17333 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17336 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17339 else if (unformat (i, "type %U", unformat_policer_type, &type))
17341 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17344 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17347 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17350 else if (unformat (i, "color-aware"))
17356 if (!vec_len (name))
17358 errmsg ("policer name must be specified");
17362 if (vec_len (name) > 64)
17364 errmsg ("policer name too long");
17368 M (POLICER_ADD_DEL, mp);
17370 clib_memcpy (mp->name, name, vec_len (name));
17372 mp->is_add = is_add;
17373 mp->cir = ntohl (cir);
17374 mp->eir = ntohl (eir);
17375 mp->cb = clib_net_to_host_u64 (cb);
17376 mp->eb = clib_net_to_host_u64 (eb);
17377 mp->rate_type = rate_type;
17378 mp->round_type = round_type;
17380 mp->conform_action_type = conform_action.action_type;
17381 mp->conform_dscp = conform_action.dscp;
17382 mp->exceed_action_type = exceed_action.action_type;
17383 mp->exceed_dscp = exceed_action.dscp;
17384 mp->violate_action_type = violate_action.action_type;
17385 mp->violate_dscp = violate_action.dscp;
17386 mp->color_aware = color_aware;
17394 api_policer_dump (vat_main_t * vam)
17396 unformat_input_t *i = vam->input;
17397 vl_api_policer_dump_t *mp;
17398 vl_api_control_ping_t *mp_ping;
17399 u8 *match_name = 0;
17400 u8 match_name_valid = 0;
17403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17405 if (unformat (i, "name %s", &match_name))
17407 vec_add1 (match_name, 0);
17408 match_name_valid = 1;
17414 M (POLICER_DUMP, mp);
17415 mp->match_name_valid = match_name_valid;
17416 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17417 vec_free (match_name);
17421 /* Use a control ping for synchronization */
17422 MPING (CONTROL_PING, mp_ping);
17425 /* Wait for a reply... */
17431 api_policer_classify_set_interface (vat_main_t * vam)
17433 unformat_input_t *i = vam->input;
17434 vl_api_policer_classify_set_interface_t *mp;
17436 int sw_if_index_set;
17437 u32 ip4_table_index = ~0;
17438 u32 ip6_table_index = ~0;
17439 u32 l2_table_index = ~0;
17443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17445 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17446 sw_if_index_set = 1;
17447 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17448 sw_if_index_set = 1;
17449 else if (unformat (i, "del"))
17451 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17453 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17455 else if (unformat (i, "l2-table %d", &l2_table_index))
17459 clib_warning ("parse error '%U'", format_unformat_error, i);
17464 if (sw_if_index_set == 0)
17466 errmsg ("missing interface name or sw_if_index");
17470 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17472 mp->sw_if_index = ntohl (sw_if_index);
17473 mp->ip4_table_index = ntohl (ip4_table_index);
17474 mp->ip6_table_index = ntohl (ip6_table_index);
17475 mp->l2_table_index = ntohl (l2_table_index);
17476 mp->is_add = is_add;
17484 api_policer_classify_dump (vat_main_t * vam)
17486 unformat_input_t *i = vam->input;
17487 vl_api_policer_classify_dump_t *mp;
17488 vl_api_control_ping_t *mp_ping;
17489 u8 type = POLICER_CLASSIFY_N_TABLES;
17492 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17496 errmsg ("classify table type must be specified");
17500 if (!vam->json_output)
17502 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17505 M (POLICER_CLASSIFY_DUMP, mp);
17510 /* Use a control ping for synchronization */
17511 MPING (CONTROL_PING, mp_ping);
17514 /* Wait for a reply... */
17520 api_netmap_create (vat_main_t * vam)
17522 unformat_input_t *i = vam->input;
17523 vl_api_netmap_create_t *mp;
17526 u8 random_hw_addr = 1;
17531 clib_memset (hw_addr, 0, sizeof (hw_addr));
17533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17535 if (unformat (i, "name %s", &if_name))
17536 vec_add1 (if_name, 0);
17537 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17538 random_hw_addr = 0;
17539 else if (unformat (i, "pipe"))
17541 else if (unformat (i, "master"))
17543 else if (unformat (i, "slave"))
17549 if (!vec_len (if_name))
17551 errmsg ("interface name must be specified");
17555 if (vec_len (if_name) > 64)
17557 errmsg ("interface name too long");
17561 M (NETMAP_CREATE, mp);
17563 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17564 clib_memcpy (mp->hw_addr, hw_addr, 6);
17565 mp->use_random_hw_addr = random_hw_addr;
17566 mp->is_pipe = is_pipe;
17567 mp->is_master = is_master;
17568 vec_free (if_name);
17576 api_netmap_delete (vat_main_t * vam)
17578 unformat_input_t *i = vam->input;
17579 vl_api_netmap_delete_t *mp;
17583 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17585 if (unformat (i, "name %s", &if_name))
17586 vec_add1 (if_name, 0);
17591 if (!vec_len (if_name))
17593 errmsg ("interface name must be specified");
17597 if (vec_len (if_name) > 64)
17599 errmsg ("interface name too long");
17603 M (NETMAP_DELETE, mp);
17605 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
17606 vec_free (if_name);
17614 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17616 vl_api_fib_path_nh_proto_t proto =
17617 va_arg (*args, vl_api_fib_path_nh_proto_t);
17621 case FIB_API_PATH_NH_PROTO_IP4:
17622 s = format (s, "ip4");
17624 case FIB_API_PATH_NH_PROTO_IP6:
17625 s = format (s, "ip6");
17627 case FIB_API_PATH_NH_PROTO_MPLS:
17628 s = format (s, "mpls");
17630 case FIB_API_PATH_NH_PROTO_BIER:
17631 s = format (s, "bier");
17633 case FIB_API_PATH_NH_PROTO_ETHERNET:
17634 s = format (s, "ethernet");
17642 format_vl_api_ip_address_union (u8 * s, va_list * args)
17644 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
17645 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17650 s = format (s, "%U", format_ip4_address, u->ip4);
17653 s = format (s, "%U", format_ip6_address, u->ip6);
17660 format_vl_api_fib_path_type (u8 * s, va_list * args)
17662 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17666 case FIB_API_PATH_TYPE_NORMAL:
17667 s = format (s, "normal");
17669 case FIB_API_PATH_TYPE_LOCAL:
17670 s = format (s, "local");
17672 case FIB_API_PATH_TYPE_DROP:
17673 s = format (s, "drop");
17675 case FIB_API_PATH_TYPE_UDP_ENCAP:
17676 s = format (s, "udp-encap");
17678 case FIB_API_PATH_TYPE_BIER_IMP:
17679 s = format (s, "bier-imp");
17681 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17682 s = format (s, "unreach");
17684 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17685 s = format (s, "prohibit");
17687 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17688 s = format (s, "src-lookup");
17690 case FIB_API_PATH_TYPE_DVR:
17691 s = format (s, "dvr");
17693 case FIB_API_PATH_TYPE_INTERFACE_RX:
17694 s = format (s, "interface-rx");
17696 case FIB_API_PATH_TYPE_CLASSIFY:
17697 s = format (s, "classify");
17705 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17708 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17709 ntohl (fp->weight), ntohl (fp->sw_if_index),
17710 format_vl_api_fib_path_type, fp->type,
17711 format_fib_api_path_nh_proto, fp->proto,
17712 format_vl_api_ip_address_union, &fp->nh.address);
17716 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17717 vl_api_fib_path_t * fp)
17719 struct in_addr ip4;
17720 struct in6_addr ip6;
17722 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17723 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17724 vat_json_object_add_uint (node, "type", fp->type);
17725 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17726 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17728 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17729 vat_json_object_add_ip4 (node, "next_hop", ip4);
17731 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17733 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17734 vat_json_object_add_ip6 (node, "next_hop", ip6);
17739 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17741 vat_main_t *vam = &vat_main;
17742 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17743 vl_api_fib_path_t *fp;
17746 print (vam->ofp, "sw_if_index %d via:",
17747 ntohl (mp->mt_tunnel.mt_sw_if_index));
17748 fp = mp->mt_tunnel.mt_paths;
17749 for (i = 0; i < count; i++)
17751 vl_api_fib_path_print (vam, fp);
17755 print (vam->ofp, "");
17758 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17759 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17762 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17764 vat_main_t *vam = &vat_main;
17765 vat_json_node_t *node = NULL;
17766 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17767 vl_api_fib_path_t *fp;
17770 if (VAT_JSON_ARRAY != vam->json_tree.type)
17772 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17773 vat_json_init_array (&vam->json_tree);
17775 node = vat_json_array_add (&vam->json_tree);
17777 vat_json_init_object (node);
17778 vat_json_object_add_uint (node, "sw_if_index",
17779 ntohl (mp->mt_tunnel.mt_sw_if_index));
17781 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17783 fp = mp->mt_tunnel.mt_paths;
17784 for (i = 0; i < count; i++)
17786 vl_api_mpls_fib_path_json_print (node, fp);
17792 api_mpls_tunnel_dump (vat_main_t * vam)
17794 vl_api_mpls_tunnel_dump_t *mp;
17795 vl_api_control_ping_t *mp_ping;
17798 M (MPLS_TUNNEL_DUMP, mp);
17802 /* Use a control ping for synchronization */
17803 MPING (CONTROL_PING, mp_ping);
17810 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17811 #define vl_api_mpls_table_details_t_print vl_noop_handler
17815 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17817 vat_main_t *vam = &vat_main;
17819 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17822 static void vl_api_mpls_table_details_t_handler_json
17823 (vl_api_mpls_table_details_t * mp)
17825 vat_main_t *vam = &vat_main;
17826 vat_json_node_t *node = NULL;
17828 if (VAT_JSON_ARRAY != vam->json_tree.type)
17830 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17831 vat_json_init_array (&vam->json_tree);
17833 node = vat_json_array_add (&vam->json_tree);
17835 vat_json_init_object (node);
17836 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17840 api_mpls_table_dump (vat_main_t * vam)
17842 vl_api_mpls_table_dump_t *mp;
17843 vl_api_control_ping_t *mp_ping;
17846 M (MPLS_TABLE_DUMP, mp);
17849 /* Use a control ping for synchronization */
17850 MPING (CONTROL_PING, mp_ping);
17857 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17858 #define vl_api_mpls_route_details_t_print vl_noop_handler
17861 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17863 vat_main_t *vam = &vat_main;
17864 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17865 vl_api_fib_path_t *fp;
17869 "table-id %d, label %u, ess_bit %u",
17870 ntohl (mp->mr_route.mr_table_id),
17871 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17872 fp = mp->mr_route.mr_paths;
17873 for (i = 0; i < count; i++)
17875 vl_api_fib_path_print (vam, fp);
17880 static void vl_api_mpls_route_details_t_handler_json
17881 (vl_api_mpls_route_details_t * mp)
17883 vat_main_t *vam = &vat_main;
17884 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17885 vat_json_node_t *node = NULL;
17886 vl_api_fib_path_t *fp;
17889 if (VAT_JSON_ARRAY != vam->json_tree.type)
17891 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17892 vat_json_init_array (&vam->json_tree);
17894 node = vat_json_array_add (&vam->json_tree);
17896 vat_json_init_object (node);
17897 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17898 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17899 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17900 vat_json_object_add_uint (node, "path_count", count);
17901 fp = mp->mr_route.mr_paths;
17902 for (i = 0; i < count; i++)
17904 vl_api_mpls_fib_path_json_print (node, fp);
17910 api_mpls_route_dump (vat_main_t * vam)
17912 unformat_input_t *input = vam->input;
17913 vl_api_mpls_route_dump_t *mp;
17914 vl_api_control_ping_t *mp_ping;
17918 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17920 if (unformat (input, "table_id %d", &table_id))
17925 if (table_id == ~0)
17927 errmsg ("missing table id");
17931 M (MPLS_ROUTE_DUMP, mp);
17933 mp->table.mt_table_id = ntohl (table_id);
17936 /* Use a control ping for synchronization */
17937 MPING (CONTROL_PING, mp_ping);
17944 #define vl_api_ip_table_details_t_endian vl_noop_handler
17945 #define vl_api_ip_table_details_t_print vl_noop_handler
17948 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17950 vat_main_t *vam = &vat_main;
17953 "%s; table-id %d, prefix %U/%d",
17954 mp->table.name, ntohl (mp->table.table_id));
17958 static void vl_api_ip_table_details_t_handler_json
17959 (vl_api_ip_table_details_t * mp)
17961 vat_main_t *vam = &vat_main;
17962 vat_json_node_t *node = NULL;
17964 if (VAT_JSON_ARRAY != vam->json_tree.type)
17966 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17967 vat_json_init_array (&vam->json_tree);
17969 node = vat_json_array_add (&vam->json_tree);
17971 vat_json_init_object (node);
17972 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17976 api_ip_table_dump (vat_main_t * vam)
17978 vl_api_ip_table_dump_t *mp;
17979 vl_api_control_ping_t *mp_ping;
17982 M (IP_TABLE_DUMP, mp);
17985 /* Use a control ping for synchronization */
17986 MPING (CONTROL_PING, mp_ping);
17994 api_ip_mtable_dump (vat_main_t * vam)
17996 vl_api_ip_mtable_dump_t *mp;
17997 vl_api_control_ping_t *mp_ping;
18000 M (IP_MTABLE_DUMP, mp);
18003 /* Use a control ping for synchronization */
18004 MPING (CONTROL_PING, mp_ping);
18012 api_ip_mroute_dump (vat_main_t * vam)
18014 unformat_input_t *input = vam->input;
18015 vl_api_control_ping_t *mp_ping;
18016 vl_api_ip_mroute_dump_t *mp;
18021 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18023 if (unformat (input, "table_id %d", &table_id))
18025 else if (unformat (input, "ip6"))
18027 else if (unformat (input, "ip4"))
18032 if (table_id == ~0)
18034 errmsg ("missing table id");
18038 M (IP_MROUTE_DUMP, mp);
18039 mp->table.table_id = table_id;
18040 mp->table.is_ip6 = is_ip6;
18043 /* Use a control ping for synchronization */
18044 MPING (CONTROL_PING, mp_ping);
18051 #define vl_api_ip_route_details_t_endian vl_noop_handler
18052 #define vl_api_ip_route_details_t_print vl_noop_handler
18055 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
18057 vat_main_t *vam = &vat_main;
18058 u8 count = mp->route.n_paths;
18059 vl_api_fib_path_t *fp;
18063 "table-id %d, prefix %U/%d",
18064 ntohl (mp->route.table_id),
18065 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
18066 for (i = 0; i < count; i++)
18068 fp = &mp->route.paths[i];
18070 vl_api_fib_path_print (vam, fp);
18075 static void vl_api_ip_route_details_t_handler_json
18076 (vl_api_ip_route_details_t * mp)
18078 vat_main_t *vam = &vat_main;
18079 u8 count = mp->route.n_paths;
18080 vat_json_node_t *node = NULL;
18081 struct in_addr ip4;
18082 struct in6_addr ip6;
18083 vl_api_fib_path_t *fp;
18086 if (VAT_JSON_ARRAY != vam->json_tree.type)
18088 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18089 vat_json_init_array (&vam->json_tree);
18091 node = vat_json_array_add (&vam->json_tree);
18093 vat_json_init_object (node);
18094 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18095 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18097 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18098 vat_json_object_add_ip6 (node, "prefix", ip6);
18102 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18103 vat_json_object_add_ip4 (node, "prefix", ip4);
18105 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18106 vat_json_object_add_uint (node, "path_count", count);
18107 for (i = 0; i < count; i++)
18109 fp = &mp->route.paths[i];
18110 vl_api_mpls_fib_path_json_print (node, fp);
18115 api_ip_route_dump (vat_main_t * vam)
18117 unformat_input_t *input = vam->input;
18118 vl_api_ip_route_dump_t *mp;
18119 vl_api_control_ping_t *mp_ping;
18125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18127 if (unformat (input, "table_id %d", &table_id))
18129 else if (unformat (input, "ip6"))
18131 else if (unformat (input, "ip4"))
18136 if (table_id == ~0)
18138 errmsg ("missing table id");
18142 M (IP_ROUTE_DUMP, mp);
18144 mp->table.table_id = table_id;
18145 mp->table.is_ip6 = is_ip6;
18149 /* Use a control ping for synchronization */
18150 MPING (CONTROL_PING, mp_ping);
18158 api_classify_table_ids (vat_main_t * vam)
18160 vl_api_classify_table_ids_t *mp;
18163 /* Construct the API message */
18164 M (CLASSIFY_TABLE_IDS, mp);
18173 api_classify_table_by_interface (vat_main_t * vam)
18175 unformat_input_t *input = vam->input;
18176 vl_api_classify_table_by_interface_t *mp;
18178 u32 sw_if_index = ~0;
18180 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18182 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18184 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18189 if (sw_if_index == ~0)
18191 errmsg ("missing interface name or sw_if_index");
18195 /* Construct the API message */
18196 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18198 mp->sw_if_index = ntohl (sw_if_index);
18206 api_classify_table_info (vat_main_t * vam)
18208 unformat_input_t *input = vam->input;
18209 vl_api_classify_table_info_t *mp;
18213 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18215 if (unformat (input, "table_id %d", &table_id))
18220 if (table_id == ~0)
18222 errmsg ("missing table id");
18226 /* Construct the API message */
18227 M (CLASSIFY_TABLE_INFO, mp);
18229 mp->table_id = ntohl (table_id);
18237 api_classify_session_dump (vat_main_t * vam)
18239 unformat_input_t *input = vam->input;
18240 vl_api_classify_session_dump_t *mp;
18241 vl_api_control_ping_t *mp_ping;
18245 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18247 if (unformat (input, "table_id %d", &table_id))
18252 if (table_id == ~0)
18254 errmsg ("missing table id");
18258 /* Construct the API message */
18259 M (CLASSIFY_SESSION_DUMP, mp);
18261 mp->table_id = ntohl (table_id);
18264 /* Use a control ping for synchronization */
18265 MPING (CONTROL_PING, mp_ping);
18273 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18275 vat_main_t *vam = &vat_main;
18277 print (vam->ofp, "collector_address %U, collector_port %d, "
18278 "src_address %U, vrf_id %d, path_mtu %u, "
18279 "template_interval %u, udp_checksum %d",
18280 format_ip4_address, mp->collector_address,
18281 ntohs (mp->collector_port),
18282 format_ip4_address, mp->src_address,
18283 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18284 ntohl (mp->template_interval), mp->udp_checksum);
18287 vam->result_ready = 1;
18291 vl_api_ipfix_exporter_details_t_handler_json
18292 (vl_api_ipfix_exporter_details_t * mp)
18294 vat_main_t *vam = &vat_main;
18295 vat_json_node_t node;
18296 struct in_addr collector_address;
18297 struct in_addr src_address;
18299 vat_json_init_object (&node);
18300 clib_memcpy (&collector_address, &mp->collector_address,
18301 sizeof (collector_address));
18302 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18303 vat_json_object_add_uint (&node, "collector_port",
18304 ntohs (mp->collector_port));
18305 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18306 vat_json_object_add_ip4 (&node, "src_address", src_address);
18307 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18308 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18309 vat_json_object_add_uint (&node, "template_interval",
18310 ntohl (mp->template_interval));
18311 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18313 vat_json_print (vam->ofp, &node);
18314 vat_json_free (&node);
18316 vam->result_ready = 1;
18320 api_ipfix_exporter_dump (vat_main_t * vam)
18322 vl_api_ipfix_exporter_dump_t *mp;
18325 /* Construct the API message */
18326 M (IPFIX_EXPORTER_DUMP, mp);
18335 api_ipfix_classify_stream_dump (vat_main_t * vam)
18337 vl_api_ipfix_classify_stream_dump_t *mp;
18340 /* Construct the API message */
18341 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18352 vl_api_ipfix_classify_stream_details_t_handler
18353 (vl_api_ipfix_classify_stream_details_t * mp)
18355 vat_main_t *vam = &vat_main;
18356 print (vam->ofp, "domain_id %d, src_port %d",
18357 ntohl (mp->domain_id), ntohs (mp->src_port));
18359 vam->result_ready = 1;
18363 vl_api_ipfix_classify_stream_details_t_handler_json
18364 (vl_api_ipfix_classify_stream_details_t * mp)
18366 vat_main_t *vam = &vat_main;
18367 vat_json_node_t node;
18369 vat_json_init_object (&node);
18370 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18371 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18373 vat_json_print (vam->ofp, &node);
18374 vat_json_free (&node);
18376 vam->result_ready = 1;
18380 api_ipfix_classify_table_dump (vat_main_t * vam)
18382 vl_api_ipfix_classify_table_dump_t *mp;
18383 vl_api_control_ping_t *mp_ping;
18386 if (!vam->json_output)
18388 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18389 "transport_protocol");
18392 /* Construct the API message */
18393 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18398 /* Use a control ping for synchronization */
18399 MPING (CONTROL_PING, mp_ping);
18407 vl_api_ipfix_classify_table_details_t_handler
18408 (vl_api_ipfix_classify_table_details_t * mp)
18410 vat_main_t *vam = &vat_main;
18411 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18412 mp->transport_protocol);
18416 vl_api_ipfix_classify_table_details_t_handler_json
18417 (vl_api_ipfix_classify_table_details_t * mp)
18419 vat_json_node_t *node = NULL;
18420 vat_main_t *vam = &vat_main;
18422 if (VAT_JSON_ARRAY != vam->json_tree.type)
18424 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18425 vat_json_init_array (&vam->json_tree);
18428 node = vat_json_array_add (&vam->json_tree);
18429 vat_json_init_object (node);
18431 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18432 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18433 vat_json_object_add_uint (node, "transport_protocol",
18434 mp->transport_protocol);
18438 api_sw_interface_span_enable_disable (vat_main_t * vam)
18440 unformat_input_t *i = vam->input;
18441 vl_api_sw_interface_span_enable_disable_t *mp;
18442 u32 src_sw_if_index = ~0;
18443 u32 dst_sw_if_index = ~0;
18448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18451 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18453 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18457 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18459 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18461 else if (unformat (i, "disable"))
18463 else if (unformat (i, "rx"))
18465 else if (unformat (i, "tx"))
18467 else if (unformat (i, "both"))
18469 else if (unformat (i, "l2"))
18475 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18477 mp->sw_if_index_from = htonl (src_sw_if_index);
18478 mp->sw_if_index_to = htonl (dst_sw_if_index);
18488 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18491 vat_main_t *vam = &vat_main;
18492 u8 *sw_if_from_name = 0;
18493 u8 *sw_if_to_name = 0;
18494 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18495 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18496 char *states[] = { "none", "rx", "tx", "both" };
18500 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18502 if ((u32) p->value[0] == sw_if_index_from)
18504 sw_if_from_name = (u8 *)(p->key);
18508 if ((u32) p->value[0] == sw_if_index_to)
18510 sw_if_to_name = (u8 *)(p->key);
18511 if (sw_if_from_name)
18516 print (vam->ofp, "%20s => %20s (%s) %s",
18517 sw_if_from_name, sw_if_to_name, states[mp->state],
18518 mp->is_l2 ? "l2" : "device");
18522 vl_api_sw_interface_span_details_t_handler_json
18523 (vl_api_sw_interface_span_details_t * mp)
18525 vat_main_t *vam = &vat_main;
18526 vat_json_node_t *node = NULL;
18527 u8 *sw_if_from_name = 0;
18528 u8 *sw_if_to_name = 0;
18529 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18530 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18534 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18536 if ((u32) p->value[0] == sw_if_index_from)
18538 sw_if_from_name = (u8 *)(p->key);
18542 if ((u32) p->value[0] == sw_if_index_to)
18544 sw_if_to_name = (u8 *)(p->key);
18545 if (sw_if_from_name)
18551 if (VAT_JSON_ARRAY != vam->json_tree.type)
18553 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18554 vat_json_init_array (&vam->json_tree);
18556 node = vat_json_array_add (&vam->json_tree);
18558 vat_json_init_object (node);
18559 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18560 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18561 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18562 if (0 != sw_if_to_name)
18564 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18566 vat_json_object_add_uint (node, "state", mp->state);
18567 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18571 api_sw_interface_span_dump (vat_main_t * vam)
18573 unformat_input_t *input = vam->input;
18574 vl_api_sw_interface_span_dump_t *mp;
18575 vl_api_control_ping_t *mp_ping;
18579 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18581 if (unformat (input, "l2"))
18587 M (SW_INTERFACE_SPAN_DUMP, mp);
18591 /* Use a control ping for synchronization */
18592 MPING (CONTROL_PING, mp_ping);
18600 api_pg_create_interface (vat_main_t * vam)
18602 unformat_input_t *input = vam->input;
18603 vl_api_pg_create_interface_t *mp;
18605 u32 if_id = ~0, gso_size = 0;
18606 u8 gso_enabled = 0;
18608 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18610 if (unformat (input, "if_id %d", &if_id))
18612 else if (unformat (input, "gso-enabled"))
18615 if (unformat (input, "gso-size %u", &gso_size))
18619 errmsg ("missing gso-size");
18628 errmsg ("missing pg interface index");
18632 /* Construct the API message */
18633 M (PG_CREATE_INTERFACE, mp);
18635 mp->interface_id = ntohl (if_id);
18636 mp->gso_enabled = gso_enabled;
18644 api_pg_capture (vat_main_t * vam)
18646 unformat_input_t *input = vam->input;
18647 vl_api_pg_capture_t *mp;
18652 u8 pcap_file_set = 0;
18655 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18657 if (unformat (input, "if_id %d", &if_id))
18659 else if (unformat (input, "pcap %s", &pcap_file))
18661 else if (unformat (input, "count %d", &count))
18663 else if (unformat (input, "disable"))
18670 errmsg ("missing pg interface index");
18673 if (pcap_file_set > 0)
18675 if (vec_len (pcap_file) > 255)
18677 errmsg ("pcap file name is too long");
18682 u32 name_len = vec_len (pcap_file);
18683 /* Construct the API message */
18684 M (PG_CAPTURE, mp);
18686 mp->interface_id = ntohl (if_id);
18687 mp->is_enabled = enable;
18688 mp->count = ntohl (count);
18689 mp->pcap_name_length = ntohl (name_len);
18690 if (pcap_file_set != 0)
18692 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
18694 vec_free (pcap_file);
18702 api_pg_enable_disable (vat_main_t * vam)
18704 unformat_input_t *input = vam->input;
18705 vl_api_pg_enable_disable_t *mp;
18708 u8 stream_name_set = 0;
18709 u8 *stream_name = 0;
18711 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18713 if (unformat (input, "stream %s", &stream_name))
18714 stream_name_set = 1;
18715 else if (unformat (input, "disable"))
18721 if (stream_name_set > 0)
18723 if (vec_len (stream_name) > 255)
18725 errmsg ("stream name too long");
18730 u32 name_len = vec_len (stream_name);
18731 /* Construct the API message */
18732 M (PG_ENABLE_DISABLE, mp);
18734 mp->is_enabled = enable;
18735 if (stream_name_set != 0)
18737 mp->stream_name_length = ntohl (name_len);
18738 clib_memcpy (mp->stream_name, stream_name, name_len);
18740 vec_free (stream_name);
18748 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18750 unformat_input_t *input = vam->input;
18751 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18753 u16 *low_ports = 0;
18754 u16 *high_ports = 0;
18757 vl_api_prefix_t prefix;
18764 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18766 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18768 else if (unformat (input, "vrf %d", &vrf_id))
18770 else if (unformat (input, "del"))
18772 else if (unformat (input, "port %d", &tmp))
18774 if (tmp == 0 || tmp > 65535)
18776 errmsg ("port %d out of range", tmp);
18780 this_hi = this_low + 1;
18781 vec_add1 (low_ports, this_low);
18782 vec_add1 (high_ports, this_hi);
18784 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18786 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18788 errmsg ("incorrect range parameters");
18792 /* Note: in debug CLI +1 is added to high before
18793 passing to real fn that does "the work"
18794 (ip_source_and_port_range_check_add_del).
18795 This fn is a wrapper around the binary API fn a
18796 control plane will call, which expects this increment
18797 to have occurred. Hence letting the binary API control
18798 plane fn do the increment for consistency between VAT
18799 and other control planes.
18802 vec_add1 (low_ports, this_low);
18803 vec_add1 (high_ports, this_hi);
18809 if (prefix_set == 0)
18811 errmsg ("<address>/<mask> not specified");
18817 errmsg ("VRF ID required, not specified");
18824 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18828 if (vec_len (low_ports) == 0)
18830 errmsg ("At least one port or port range required");
18834 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18836 mp->is_add = is_add;
18838 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18840 mp->number_of_ranges = vec_len (low_ports);
18842 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18843 vec_free (low_ports);
18845 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18846 vec_free (high_ports);
18848 mp->vrf_id = ntohl (vrf_id);
18856 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18858 unformat_input_t *input = vam->input;
18859 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18860 u32 sw_if_index = ~0;
18862 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18863 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18867 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18869 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18871 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18873 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18875 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18877 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18879 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18881 else if (unformat (input, "del"))
18887 if (sw_if_index == ~0)
18889 errmsg ("Interface required but not specified");
18895 errmsg ("VRF ID required but not specified");
18899 if (tcp_out_vrf_id == 0
18900 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18903 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18907 /* Construct the API message */
18908 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18910 mp->sw_if_index = ntohl (sw_if_index);
18911 mp->is_add = is_add;
18912 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18913 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18914 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18915 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18920 /* Wait for a reply... */
18926 api_set_punt (vat_main_t * vam)
18928 unformat_input_t *i = vam->input;
18929 vl_api_address_family_t af;
18930 vl_api_set_punt_t *mp;
18936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18938 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18940 else if (unformat (i, "protocol %d", &protocol))
18942 else if (unformat (i, "port %d", &port))
18944 else if (unformat (i, "del"))
18948 clib_warning ("parse error '%U'", format_unformat_error, i);
18955 mp->is_add = (u8) is_add;
18956 mp->punt.type = PUNT_API_TYPE_L4;
18957 mp->punt.punt.l4.af = af;
18958 mp->punt.punt.l4.protocol = (u8) protocol;
18959 mp->punt.punt.l4.port = htons ((u16) port);
18967 api_delete_subif (vat_main_t * vam)
18969 unformat_input_t *i = vam->input;
18970 vl_api_delete_subif_t *mp;
18971 u32 sw_if_index = ~0;
18974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18976 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18978 if (unformat (i, "sw_if_index %d", &sw_if_index))
18984 if (sw_if_index == ~0)
18986 errmsg ("missing sw_if_index");
18990 /* Construct the API message */
18991 M (DELETE_SUBIF, mp);
18992 mp->sw_if_index = ntohl (sw_if_index);
18999 #define foreach_pbb_vtr_op \
19000 _("disable", L2_VTR_DISABLED) \
19001 _("pop", L2_VTR_POP_2) \
19002 _("push", L2_VTR_PUSH_2)
19005 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
19007 unformat_input_t *i = vam->input;
19008 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
19009 u32 sw_if_index = ~0, vtr_op = ~0;
19010 u16 outer_tag = ~0;
19011 u8 dmac[6], smac[6];
19012 u8 dmac_set = 0, smac_set = 0;
19018 /* Shut up coverity */
19019 clib_memset (dmac, 0, sizeof (dmac));
19020 clib_memset (smac, 0, sizeof (smac));
19022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19024 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19026 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19028 else if (unformat (i, "vtr_op %d", &vtr_op))
19030 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
19033 else if (unformat (i, "translate_pbb_stag"))
19035 if (unformat (i, "%d", &tmp))
19037 vtr_op = L2_VTR_TRANSLATE_2_1;
19043 ("translate_pbb_stag operation requires outer tag definition");
19047 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
19049 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
19051 else if (unformat (i, "sid %d", &sid))
19053 else if (unformat (i, "vlanid %d", &tmp))
19057 clib_warning ("parse error '%U'", format_unformat_error, i);
19062 if ((sw_if_index == ~0) || (vtr_op == ~0))
19064 errmsg ("missing sw_if_index or vtr operation");
19067 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19068 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19071 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19075 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19076 mp->sw_if_index = ntohl (sw_if_index);
19077 mp->vtr_op = ntohl (vtr_op);
19078 mp->outer_tag = ntohs (outer_tag);
19079 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19080 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19081 mp->b_vlanid = ntohs (vlanid);
19082 mp->i_sid = ntohl (sid);
19090 api_flow_classify_set_interface (vat_main_t * vam)
19092 unformat_input_t *i = vam->input;
19093 vl_api_flow_classify_set_interface_t *mp;
19095 int sw_if_index_set;
19096 u32 ip4_table_index = ~0;
19097 u32 ip6_table_index = ~0;
19101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19103 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19104 sw_if_index_set = 1;
19105 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19106 sw_if_index_set = 1;
19107 else if (unformat (i, "del"))
19109 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19111 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19115 clib_warning ("parse error '%U'", format_unformat_error, i);
19120 if (sw_if_index_set == 0)
19122 errmsg ("missing interface name or sw_if_index");
19126 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19128 mp->sw_if_index = ntohl (sw_if_index);
19129 mp->ip4_table_index = ntohl (ip4_table_index);
19130 mp->ip6_table_index = ntohl (ip6_table_index);
19131 mp->is_add = is_add;
19139 api_flow_classify_dump (vat_main_t * vam)
19141 unformat_input_t *i = vam->input;
19142 vl_api_flow_classify_dump_t *mp;
19143 vl_api_control_ping_t *mp_ping;
19144 u8 type = FLOW_CLASSIFY_N_TABLES;
19147 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19151 errmsg ("classify table type must be specified");
19155 if (!vam->json_output)
19157 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19160 M (FLOW_CLASSIFY_DUMP, mp);
19165 /* Use a control ping for synchronization */
19166 MPING (CONTROL_PING, mp_ping);
19169 /* Wait for a reply... */
19175 api_feature_enable_disable (vat_main_t * vam)
19177 unformat_input_t *i = vam->input;
19178 vl_api_feature_enable_disable_t *mp;
19180 u8 *feature_name = 0;
19181 u32 sw_if_index = ~0;
19185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19187 if (unformat (i, "arc_name %s", &arc_name))
19189 else if (unformat (i, "feature_name %s", &feature_name))
19192 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19194 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19196 else if (unformat (i, "disable"))
19204 errmsg ("missing arc name");
19207 if (vec_len (arc_name) > 63)
19209 errmsg ("arc name too long");
19212 if (feature_name == 0)
19214 errmsg ("missing feature name");
19217 if (vec_len (feature_name) > 63)
19219 errmsg ("feature name too long");
19222 if (sw_if_index == ~0)
19224 errmsg ("missing interface name or sw_if_index");
19228 /* Construct the API message */
19229 M (FEATURE_ENABLE_DISABLE, mp);
19230 mp->sw_if_index = ntohl (sw_if_index);
19231 mp->enable = enable;
19232 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19233 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19234 vec_free (arc_name);
19235 vec_free (feature_name);
19243 api_feature_gso_enable_disable (vat_main_t * vam)
19245 unformat_input_t *i = vam->input;
19246 vl_api_feature_gso_enable_disable_t *mp;
19247 u32 sw_if_index = ~0;
19251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19253 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19255 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19257 else if (unformat (i, "enable"))
19259 else if (unformat (i, "disable"))
19265 if (sw_if_index == ~0)
19267 errmsg ("missing interface name or sw_if_index");
19271 /* Construct the API message */
19272 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19273 mp->sw_if_index = ntohl (sw_if_index);
19274 mp->enable_disable = enable;
19282 api_sw_interface_tag_add_del (vat_main_t * vam)
19284 unformat_input_t *i = vam->input;
19285 vl_api_sw_interface_tag_add_del_t *mp;
19286 u32 sw_if_index = ~0;
19291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19293 if (unformat (i, "tag %s", &tag))
19295 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19297 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19299 else if (unformat (i, "del"))
19305 if (sw_if_index == ~0)
19307 errmsg ("missing interface name or sw_if_index");
19311 if (enable && (tag == 0))
19313 errmsg ("no tag specified");
19317 /* Construct the API message */
19318 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19319 mp->sw_if_index = ntohl (sw_if_index);
19320 mp->is_add = enable;
19322 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19331 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19333 unformat_input_t *i = vam->input;
19334 vl_api_mac_address_t mac = { 0 };
19335 vl_api_sw_interface_add_del_mac_address_t *mp;
19336 u32 sw_if_index = ~0;
19341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19343 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19345 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19347 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19349 else if (unformat (i, "del"))
19355 if (sw_if_index == ~0)
19357 errmsg ("missing interface name or sw_if_index");
19363 errmsg ("missing MAC address");
19367 /* Construct the API message */
19368 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19369 mp->sw_if_index = ntohl (sw_if_index);
19370 mp->is_add = is_add;
19371 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19378 static void vl_api_l2_xconnect_details_t_handler
19379 (vl_api_l2_xconnect_details_t * mp)
19381 vat_main_t *vam = &vat_main;
19383 print (vam->ofp, "%15d%15d",
19384 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19387 static void vl_api_l2_xconnect_details_t_handler_json
19388 (vl_api_l2_xconnect_details_t * mp)
19390 vat_main_t *vam = &vat_main;
19391 vat_json_node_t *node = NULL;
19393 if (VAT_JSON_ARRAY != vam->json_tree.type)
19395 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19396 vat_json_init_array (&vam->json_tree);
19398 node = vat_json_array_add (&vam->json_tree);
19400 vat_json_init_object (node);
19401 vat_json_object_add_uint (node, "rx_sw_if_index",
19402 ntohl (mp->rx_sw_if_index));
19403 vat_json_object_add_uint (node, "tx_sw_if_index",
19404 ntohl (mp->tx_sw_if_index));
19408 api_l2_xconnect_dump (vat_main_t * vam)
19410 vl_api_l2_xconnect_dump_t *mp;
19411 vl_api_control_ping_t *mp_ping;
19414 if (!vam->json_output)
19416 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19419 M (L2_XCONNECT_DUMP, mp);
19423 /* Use a control ping for synchronization */
19424 MPING (CONTROL_PING, mp_ping);
19432 api_hw_interface_set_mtu (vat_main_t * vam)
19434 unformat_input_t *i = vam->input;
19435 vl_api_hw_interface_set_mtu_t *mp;
19436 u32 sw_if_index = ~0;
19440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19442 if (unformat (i, "mtu %d", &mtu))
19444 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19446 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19452 if (sw_if_index == ~0)
19454 errmsg ("missing interface name or sw_if_index");
19460 errmsg ("no mtu specified");
19464 /* Construct the API message */
19465 M (HW_INTERFACE_SET_MTU, mp);
19466 mp->sw_if_index = ntohl (sw_if_index);
19467 mp->mtu = ntohs ((u16) mtu);
19475 api_p2p_ethernet_add (vat_main_t * vam)
19477 unformat_input_t *i = vam->input;
19478 vl_api_p2p_ethernet_add_t *mp;
19479 u32 parent_if_index = ~0;
19485 clib_memset (remote_mac, 0, sizeof (remote_mac));
19486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19488 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19490 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19494 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19496 else if (unformat (i, "sub_id %d", &sub_id))
19500 clib_warning ("parse error '%U'", format_unformat_error, i);
19505 if (parent_if_index == ~0)
19507 errmsg ("missing interface name or sw_if_index");
19512 errmsg ("missing remote mac address");
19517 errmsg ("missing sub-interface id");
19521 M (P2P_ETHERNET_ADD, mp);
19522 mp->parent_if_index = ntohl (parent_if_index);
19523 mp->subif_id = ntohl (sub_id);
19524 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19532 api_p2p_ethernet_del (vat_main_t * vam)
19534 unformat_input_t *i = vam->input;
19535 vl_api_p2p_ethernet_del_t *mp;
19536 u32 parent_if_index = ~0;
19541 clib_memset (remote_mac, 0, sizeof (remote_mac));
19542 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19544 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19546 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19550 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19554 clib_warning ("parse error '%U'", format_unformat_error, i);
19559 if (parent_if_index == ~0)
19561 errmsg ("missing interface name or sw_if_index");
19566 errmsg ("missing remote mac address");
19570 M (P2P_ETHERNET_DEL, mp);
19571 mp->parent_if_index = ntohl (parent_if_index);
19572 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19580 api_lldp_config (vat_main_t * vam)
19582 unformat_input_t *i = vam->input;
19583 vl_api_lldp_config_t *mp;
19585 int tx_interval = 0;
19586 u8 *sys_name = NULL;
19589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19591 if (unformat (i, "system-name %s", &sys_name))
19593 else if (unformat (i, "tx-hold %d", &tx_hold))
19595 else if (unformat (i, "tx-interval %d", &tx_interval))
19599 clib_warning ("parse error '%U'", format_unformat_error, i);
19604 vec_add1 (sys_name, 0);
19606 M (LLDP_CONFIG, mp);
19607 mp->tx_hold = htonl (tx_hold);
19608 mp->tx_interval = htonl (tx_interval);
19609 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
19610 vec_free (sys_name);
19618 api_sw_interface_set_lldp (vat_main_t * vam)
19620 unformat_input_t *i = vam->input;
19621 vl_api_sw_interface_set_lldp_t *mp;
19622 u32 sw_if_index = ~0;
19624 u8 *port_desc = NULL, *mgmt_oid = NULL;
19625 ip4_address_t ip4_addr;
19626 ip6_address_t ip6_addr;
19629 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19630 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19634 if (unformat (i, "disable"))
19637 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19639 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19641 else if (unformat (i, "port-desc %s", &port_desc))
19643 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19645 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19647 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19653 if (sw_if_index == ~0)
19655 errmsg ("missing interface name or sw_if_index");
19659 /* Construct the API message */
19660 vec_add1 (port_desc, 0);
19661 vec_add1 (mgmt_oid, 0);
19662 M (SW_INTERFACE_SET_LLDP, mp);
19663 mp->sw_if_index = ntohl (sw_if_index);
19664 mp->enable = enable;
19665 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
19666 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19667 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19668 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19669 vec_free (port_desc);
19670 vec_free (mgmt_oid);
19678 api_tcp_configure_src_addresses (vat_main_t * vam)
19680 vl_api_tcp_configure_src_addresses_t *mp;
19681 unformat_input_t *i = vam->input;
19682 vl_api_address_t first, last;
19687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19689 if (unformat (i, "%U - %U",
19690 unformat_vl_api_address, &first,
19691 unformat_vl_api_address, &last))
19695 errmsg ("one range per message (range already set)");
19700 else if (unformat (i, "vrf %d", &vrf_id))
19706 if (range_set == 0)
19708 errmsg ("address range not set");
19712 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19714 mp->vrf_id = ntohl (vrf_id);
19715 clib_memcpy (&mp->first_address, &first, sizeof (first));
19716 clib_memcpy (&mp->last_address, &last, sizeof (last));
19723 static void vl_api_app_namespace_add_del_reply_t_handler
19724 (vl_api_app_namespace_add_del_reply_t * mp)
19726 vat_main_t *vam = &vat_main;
19727 i32 retval = ntohl (mp->retval);
19728 if (vam->async_mode)
19730 vam->async_errors += (retval < 0);
19734 vam->retval = retval;
19736 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19737 vam->result_ready = 1;
19741 static void vl_api_app_namespace_add_del_reply_t_handler_json
19742 (vl_api_app_namespace_add_del_reply_t * mp)
19744 vat_main_t *vam = &vat_main;
19745 vat_json_node_t node;
19747 vat_json_init_object (&node);
19748 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19749 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19751 vat_json_print (vam->ofp, &node);
19752 vat_json_free (&node);
19754 vam->retval = ntohl (mp->retval);
19755 vam->result_ready = 1;
19759 api_app_namespace_add_del (vat_main_t * vam)
19761 vl_api_app_namespace_add_del_t *mp;
19762 unformat_input_t *i = vam->input;
19763 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19764 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19770 if (unformat (i, "id %_%v%_", &ns_id))
19772 else if (unformat (i, "secret %lu", &secret))
19774 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19775 sw_if_index_set = 1;
19776 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19778 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19783 if (!ns_id || !secret_set || !sw_if_index_set)
19785 errmsg ("namespace id, secret and sw_if_index must be set");
19788 if (vec_len (ns_id) > 64)
19790 errmsg ("namespace id too long");
19793 M (APP_NAMESPACE_ADD_DEL, mp);
19795 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
19796 mp->namespace_id_len = vec_len (ns_id);
19797 mp->secret = clib_host_to_net_u64 (secret);
19798 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19799 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19800 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19808 api_sock_init_shm (vat_main_t * vam)
19810 #if VPP_API_TEST_BUILTIN == 0
19811 unformat_input_t *i = vam->input;
19812 vl_api_shm_elem_config_t *config = 0;
19813 u64 size = 64 << 20;
19816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19818 if (unformat (i, "size %U", unformat_memory_size, &size))
19825 * Canned custom ring allocator config.
19826 * Should probably parse all of this
19828 vec_validate (config, 6);
19829 config[0].type = VL_API_VLIB_RING;
19830 config[0].size = 256;
19831 config[0].count = 32;
19833 config[1].type = VL_API_VLIB_RING;
19834 config[1].size = 1024;
19835 config[1].count = 16;
19837 config[2].type = VL_API_VLIB_RING;
19838 config[2].size = 4096;
19839 config[2].count = 2;
19841 config[3].type = VL_API_CLIENT_RING;
19842 config[3].size = 256;
19843 config[3].count = 32;
19845 config[4].type = VL_API_CLIENT_RING;
19846 config[4].size = 1024;
19847 config[4].count = 16;
19849 config[5].type = VL_API_CLIENT_RING;
19850 config[5].size = 4096;
19851 config[5].count = 2;
19853 config[6].type = VL_API_QUEUE;
19854 config[6].count = 128;
19855 config[6].size = sizeof (uword);
19857 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19859 vam->client_index_invalid = 1;
19867 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19869 vat_main_t *vam = &vat_main;
19874 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19875 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19876 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
19877 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19878 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19879 clib_net_to_host_u32 (mp->action_index), mp->tag);
19884 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19885 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19886 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
19887 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19888 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19889 clib_net_to_host_u32 (mp->action_index), mp->tag);
19894 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19897 vat_main_t *vam = &vat_main;
19898 vat_json_node_t *node = NULL;
19899 struct in6_addr ip6;
19900 struct in_addr ip4;
19902 if (VAT_JSON_ARRAY != vam->json_tree.type)
19904 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19905 vat_json_init_array (&vam->json_tree);
19907 node = vat_json_array_add (&vam->json_tree);
19908 vat_json_init_object (node);
19910 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
19911 vat_json_object_add_uint (node, "appns_index",
19912 clib_net_to_host_u32 (mp->appns_index));
19913 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19914 vat_json_object_add_uint (node, "scope", mp->scope);
19915 vat_json_object_add_uint (node, "action_index",
19916 clib_net_to_host_u32 (mp->action_index));
19917 vat_json_object_add_uint (node, "lcl_port",
19918 clib_net_to_host_u16 (mp->lcl_port));
19919 vat_json_object_add_uint (node, "rmt_port",
19920 clib_net_to_host_u16 (mp->rmt_port));
19921 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
19922 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
19923 vat_json_object_add_string_copy (node, "tag", mp->tag);
19926 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
19927 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19928 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
19929 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19933 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
19934 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19935 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
19936 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19941 api_session_rule_add_del (vat_main_t * vam)
19943 vl_api_session_rule_add_del_t *mp;
19944 unformat_input_t *i = vam->input;
19945 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19946 u32 appns_index = 0, scope = 0;
19947 ip4_address_t lcl_ip4, rmt_ip4;
19948 ip6_address_t lcl_ip6, rmt_ip6;
19949 u8 is_ip4 = 1, conn_set = 0;
19950 u8 is_add = 1, *tag = 0;
19953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19955 if (unformat (i, "del"))
19957 else if (unformat (i, "add"))
19959 else if (unformat (i, "proto tcp"))
19961 else if (unformat (i, "proto udp"))
19963 else if (unformat (i, "appns %d", &appns_index))
19965 else if (unformat (i, "scope %d", &scope))
19967 else if (unformat (i, "tag %_%v%_", &tag))
19971 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19972 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19980 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19981 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19987 else if (unformat (i, "action %d", &action))
19992 if (proto == ~0 || !conn_set || action == ~0)
19994 errmsg ("transport proto, connection and action must be set");
20000 errmsg ("scope should be 0-3");
20004 M (SESSION_RULE_ADD_DEL, mp);
20006 mp->is_ip4 = is_ip4;
20007 mp->transport_proto = proto;
20008 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
20009 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
20010 mp->lcl_plen = lcl_plen;
20011 mp->rmt_plen = rmt_plen;
20012 mp->action_index = clib_host_to_net_u32 (action);
20013 mp->appns_index = clib_host_to_net_u32 (appns_index);
20015 mp->is_add = is_add;
20018 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
20019 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
20023 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
20024 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
20028 clib_memcpy (mp->tag, tag, vec_len (tag));
20038 api_session_rules_dump (vat_main_t * vam)
20040 vl_api_session_rules_dump_t *mp;
20041 vl_api_control_ping_t *mp_ping;
20044 if (!vam->json_output)
20046 print (vam->ofp, "%=20s", "Session Rules");
20049 M (SESSION_RULES_DUMP, mp);
20053 /* Use a control ping for synchronization */
20054 MPING (CONTROL_PING, mp_ping);
20057 /* Wait for a reply... */
20063 api_ip_container_proxy_add_del (vat_main_t * vam)
20065 vl_api_ip_container_proxy_add_del_t *mp;
20066 unformat_input_t *i = vam->input;
20067 u32 sw_if_index = ~0;
20068 vl_api_prefix_t pfx = { };
20072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20074 if (unformat (i, "del"))
20076 else if (unformat (i, "add"))
20078 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20080 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20085 if (sw_if_index == ~0 || pfx.len == 0)
20087 errmsg ("address and sw_if_index must be set");
20091 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20093 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20094 mp->is_add = is_add;
20095 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20103 api_qos_record_enable_disable (vat_main_t * vam)
20105 unformat_input_t *i = vam->input;
20106 vl_api_qos_record_enable_disable_t *mp;
20107 u32 sw_if_index, qs = 0xff;
20108 u8 sw_if_index_set = 0;
20112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20114 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20115 sw_if_index_set = 1;
20116 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20117 sw_if_index_set = 1;
20118 else if (unformat (i, "%U", unformat_qos_source, &qs))
20120 else if (unformat (i, "disable"))
20124 clib_warning ("parse error '%U'", format_unformat_error, i);
20129 if (sw_if_index_set == 0)
20131 errmsg ("missing interface name or sw_if_index");
20136 errmsg ("input location must be specified");
20140 M (QOS_RECORD_ENABLE_DISABLE, mp);
20142 mp->record.sw_if_index = ntohl (sw_if_index);
20143 mp->record.input_source = qs;
20144 mp->enable = enable;
20153 q_or_quit (vat_main_t * vam)
20155 #if VPP_API_TEST_BUILTIN == 0
20156 longjmp (vam->jump_buf, 1);
20158 return 0; /* not so much */
20162 q (vat_main_t * vam)
20164 return q_or_quit (vam);
20168 quit (vat_main_t * vam)
20170 return q_or_quit (vam);
20174 comment (vat_main_t * vam)
20180 elog_save (vat_main_t * vam)
20182 #if VPP_API_TEST_BUILTIN == 0
20183 elog_main_t *em = &vam->elog_main;
20184 unformat_input_t *i = vam->input;
20185 char *file, *chroot_file;
20186 clib_error_t *error;
20188 if (!unformat (i, "%s", &file))
20190 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20194 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20195 if (strstr (file, "..") || index (file, '/'))
20197 errmsg ("illegal characters in filename '%s'", file);
20201 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20205 errmsg ("Saving %wd of %wd events to %s",
20206 elog_n_events_in_buffer (em),
20207 elog_buffer_capacity (em), chroot_file);
20209 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20210 vec_free (chroot_file);
20213 clib_error_report (error);
20215 errmsg ("Use the vpp event loger...");
20222 elog_setup (vat_main_t * vam)
20224 #if VPP_API_TEST_BUILTIN == 0
20225 elog_main_t *em = &vam->elog_main;
20226 unformat_input_t *i = vam->input;
20227 u32 nevents = 128 << 10;
20229 (void) unformat (i, "nevents %d", &nevents);
20231 elog_init (em, nevents);
20232 vl_api_set_elog_main (em);
20233 vl_api_set_elog_trace_api_messages (1);
20234 errmsg ("Event logger initialized with %u events", nevents);
20236 errmsg ("Use the vpp event loger...");
20242 elog_enable (vat_main_t * vam)
20244 #if VPP_API_TEST_BUILTIN == 0
20245 elog_main_t *em = &vam->elog_main;
20247 elog_enable_disable (em, 1 /* enable */ );
20248 vl_api_set_elog_trace_api_messages (1);
20249 errmsg ("Event logger enabled...");
20251 errmsg ("Use the vpp event loger...");
20257 elog_disable (vat_main_t * vam)
20259 #if VPP_API_TEST_BUILTIN == 0
20260 elog_main_t *em = &vam->elog_main;
20262 elog_enable_disable (em, 0 /* enable */ );
20263 vl_api_set_elog_trace_api_messages (1);
20264 errmsg ("Event logger disabled...");
20266 errmsg ("Use the vpp event loger...");
20272 statseg (vat_main_t * vam)
20274 ssvm_private_t *ssvmp = &vam->stat_segment;
20275 ssvm_shared_header_t *shared_header = ssvmp->sh;
20276 vlib_counter_t **counters;
20277 u64 thread0_index1_packets;
20278 u64 thread0_index1_bytes;
20279 f64 vector_rate, input_rate;
20282 uword *counter_vector_by_name;
20283 if (vam->stat_segment_lockp == 0)
20285 errmsg ("Stat segment not mapped...");
20289 /* look up "/if/rx for sw_if_index 1 as a test */
20291 clib_spinlock_lock (vam->stat_segment_lockp);
20293 counter_vector_by_name = (uword *) shared_header->opaque[1];
20295 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20298 clib_spinlock_unlock (vam->stat_segment_lockp);
20299 errmsg ("/if/tx not found?");
20303 /* Fish per-thread vector of combined counters from shared memory */
20304 counters = (vlib_counter_t **) p[0];
20306 if (vec_len (counters[0]) < 2)
20308 clib_spinlock_unlock (vam->stat_segment_lockp);
20309 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20313 /* Read thread 0 sw_if_index 1 counter */
20314 thread0_index1_packets = counters[0][1].packets;
20315 thread0_index1_bytes = counters[0][1].bytes;
20317 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20320 clib_spinlock_unlock (vam->stat_segment_lockp);
20321 errmsg ("vector_rate not found?");
20325 vector_rate = *(f64 *) (p[0]);
20326 p = hash_get_mem (counter_vector_by_name, "input_rate");
20329 clib_spinlock_unlock (vam->stat_segment_lockp);
20330 errmsg ("input_rate not found?");
20333 input_rate = *(f64 *) (p[0]);
20335 clib_spinlock_unlock (vam->stat_segment_lockp);
20337 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20338 vector_rate, input_rate);
20339 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20340 thread0_index1_packets, thread0_index1_bytes);
20346 cmd_cmp (void *a1, void *a2)
20351 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20355 help (vat_main_t * vam)
20360 unformat_input_t *i = vam->input;
20363 if (unformat (i, "%s", &name))
20367 vec_add1 (name, 0);
20369 hs = hash_get_mem (vam->help_by_name, name);
20371 print (vam->ofp, "usage: %s %s", name, hs[0]);
20373 print (vam->ofp, "No such msg / command '%s'", name);
20378 print (vam->ofp, "Help is available for the following:");
20381 hash_foreach_pair (p, vam->function_by_name,
20383 vec_add1 (cmds, (u8 *)(p->key));
20387 vec_sort_with_function (cmds, cmd_cmp);
20389 for (j = 0; j < vec_len (cmds); j++)
20390 print (vam->ofp, "%s", cmds[j]);
20397 set (vat_main_t * vam)
20399 u8 *name = 0, *value = 0;
20400 unformat_input_t *i = vam->input;
20402 if (unformat (i, "%s", &name))
20404 /* The input buffer is a vector, not a string. */
20405 value = vec_dup (i->buffer);
20406 vec_delete (value, i->index, 0);
20407 /* Almost certainly has a trailing newline */
20408 if (value[vec_len (value) - 1] == '\n')
20409 value[vec_len (value) - 1] = 0;
20410 /* Make sure it's a proper string, one way or the other */
20411 vec_add1 (value, 0);
20412 (void) clib_macro_set_value (&vam->macro_main,
20413 (char *) name, (char *) value);
20416 errmsg ("usage: set <name> <value>");
20424 unset (vat_main_t * vam)
20428 if (unformat (vam->input, "%s", &name))
20429 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20430 errmsg ("unset: %s wasn't set", name);
20443 macro_sort_cmp (void *a1, void *a2)
20445 macro_sort_t *s1 = a1;
20446 macro_sort_t *s2 = a2;
20448 return strcmp ((char *) (s1->name), (char *) (s2->name));
20452 dump_macro_table (vat_main_t * vam)
20454 macro_sort_t *sort_me = 0, *sm;
20459 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20461 vec_add2 (sort_me, sm, 1);
20462 sm->name = (u8 *)(p->key);
20463 sm->value = (u8 *) (p->value[0]);
20467 vec_sort_with_function (sort_me, macro_sort_cmp);
20469 if (vec_len (sort_me))
20470 print (vam->ofp, "%-15s%s", "Name", "Value");
20472 print (vam->ofp, "The macro table is empty...");
20474 for (i = 0; i < vec_len (sort_me); i++)
20475 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20480 dump_node_table (vat_main_t * vam)
20483 vlib_node_t *node, *next_node;
20485 if (vec_len (vam->graph_nodes) == 0)
20487 print (vam->ofp, "Node table empty, issue get_node_graph...");
20491 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20493 node = vam->graph_nodes[0][i];
20494 print (vam->ofp, "[%d] %s", i, node->name);
20495 for (j = 0; j < vec_len (node->next_nodes); j++)
20497 if (node->next_nodes[j] != ~0)
20499 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20500 print (vam->ofp, " [%d] %s", j, next_node->name);
20508 value_sort_cmp (void *a1, void *a2)
20510 name_sort_t *n1 = a1;
20511 name_sort_t *n2 = a2;
20513 if (n1->value < n2->value)
20515 if (n1->value > n2->value)
20522 dump_msg_api_table (vat_main_t * vam)
20524 api_main_t *am = vlibapi_get_main ();
20525 name_sort_t *nses = 0, *ns;
20530 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20532 vec_add2 (nses, ns, 1);
20533 ns->name = (u8 *)(hp->key);
20534 ns->value = (u32) hp->value[0];
20538 vec_sort_with_function (nses, value_sort_cmp);
20540 for (i = 0; i < vec_len (nses); i++)
20541 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20547 get_msg_id (vat_main_t * vam)
20552 if (unformat (vam->input, "%s", &name_and_crc))
20554 message_index = vl_msg_api_get_msg_index (name_and_crc);
20555 if (message_index == ~0)
20557 print (vam->ofp, " '%s' not found", name_and_crc);
20560 print (vam->ofp, " '%s' has message index %d",
20561 name_and_crc, message_index);
20564 errmsg ("name_and_crc required...");
20569 search_node_table (vat_main_t * vam)
20571 unformat_input_t *line_input = vam->input;
20574 vlib_node_t *node, *next_node;
20577 if (vam->graph_node_index_by_name == 0)
20579 print (vam->ofp, "Node table empty, issue get_node_graph...");
20583 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20585 if (unformat (line_input, "%s", &node_to_find))
20587 vec_add1 (node_to_find, 0);
20588 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20591 print (vam->ofp, "%s not found...", node_to_find);
20594 node = vam->graph_nodes[0][p[0]];
20595 print (vam->ofp, "[%d] %s", p[0], node->name);
20596 for (j = 0; j < vec_len (node->next_nodes); j++)
20598 if (node->next_nodes[j] != ~0)
20600 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20601 print (vam->ofp, " [%d] %s", j, next_node->name);
20608 clib_warning ("parse error '%U'", format_unformat_error,
20614 vec_free (node_to_find);
20623 script (vat_main_t * vam)
20625 #if (VPP_API_TEST_BUILTIN==0)
20627 char *save_current_file;
20628 unformat_input_t save_input;
20629 jmp_buf save_jump_buf;
20630 u32 save_line_number;
20632 FILE *new_fp, *save_ifp;
20634 if (unformat (vam->input, "%s", &s))
20636 new_fp = fopen ((char *) s, "r");
20639 errmsg ("Couldn't open script file %s", s);
20646 errmsg ("Missing script name");
20650 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20651 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20652 save_ifp = vam->ifp;
20653 save_line_number = vam->input_line_number;
20654 save_current_file = (char *) vam->current_file;
20656 vam->input_line_number = 0;
20658 vam->current_file = s;
20661 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20662 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20663 vam->ifp = save_ifp;
20664 vam->input_line_number = save_line_number;
20665 vam->current_file = (u8 *) save_current_file;
20670 clib_warning ("use the exec command...");
20676 echo (vat_main_t * vam)
20678 print (vam->ofp, "%v", vam->input->buffer);
20682 /* List of API message constructors, CLI names map to api_xxx */
20683 #define foreach_vpe_api_msg \
20684 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20685 _(sw_interface_dump,"") \
20686 _(sw_interface_set_flags, \
20687 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20688 _(sw_interface_add_del_address, \
20689 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20690 _(sw_interface_set_rx_mode, \
20691 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20692 _(sw_interface_set_rx_placement, \
20693 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20694 _(sw_interface_rx_placement_dump, \
20695 "[<intfc> | sw_if_index <id>]") \
20696 _(sw_interface_set_table, \
20697 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20698 _(sw_interface_set_mpls_enable, \
20699 "<intfc> | sw_if_index [disable | dis]") \
20700 _(sw_interface_set_vpath, \
20701 "<intfc> | sw_if_index <id> enable | disable") \
20702 _(sw_interface_set_vxlan_bypass, \
20703 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20704 _(sw_interface_set_geneve_bypass, \
20705 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20706 _(sw_interface_set_l2_xconnect, \
20707 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20708 "enable | disable") \
20709 _(sw_interface_set_l2_bridge, \
20710 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20711 "[shg <split-horizon-group>] [bvi]\n" \
20712 "enable | disable") \
20713 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20714 _(bridge_domain_add_del, \
20715 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [mac-age 0-255] [bd-tag <text>] [del]\n") \
20716 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20718 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20719 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20720 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20722 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20724 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20726 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
20728 "<vpp-if-name> | sw_if_index <id>") \
20729 _(sw_interface_tap_v2_dump, "") \
20730 _(virtio_pci_create, \
20731 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20732 _(virtio_pci_delete, \
20733 "<vpp-if-name> | sw_if_index <id>") \
20734 _(sw_interface_virtio_pci_dump, "") \
20736 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20737 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20740 "<vpp-if-name> | sw_if_index <id>") \
20742 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20743 _(bond_detach_slave, \
20744 "sw_if_index <n>") \
20745 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20746 _(sw_interface_bond_dump, "") \
20747 _(sw_interface_slave_dump, \
20748 "<vpp-if-name> | sw_if_index <id>") \
20749 _(ip_table_add_del, \
20750 "table <n> [ipv6] [add | del]\n") \
20751 _(ip_route_add_del, \
20752 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20753 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20754 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20755 "[multipath] [count <n>] [del]") \
20756 _(ip_mroute_add_del, \
20757 "<src> <grp>/<mask> [table-id <n>]\n" \
20758 "[<intfc> | sw_if_index <id>] [local] [del]") \
20759 _(mpls_table_add_del, \
20760 "table <n> [add | del]\n") \
20761 _(mpls_route_add_del, \
20762 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20763 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20764 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20765 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20766 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20767 "[count <n>] [del]") \
20768 _(mpls_ip_bind_unbind, \
20769 "<label> <addr/len>") \
20770 _(mpls_tunnel_add_del, \
20771 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20772 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20773 "[l2-only] [out-label <n>]") \
20774 _(sr_mpls_policy_add, \
20775 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20776 _(sr_mpls_policy_del, \
20778 _(bier_table_add_del, \
20779 "<label> <sub-domain> <set> <bsl> [del]") \
20780 _(bier_route_add_del, \
20781 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20782 "[<intfc> | sw_if_index <id>]" \
20783 "[weight <n>] [del] [multipath]") \
20784 _(sw_interface_set_unnumbered, \
20785 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20786 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20787 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20788 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20789 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20790 "[outer_vlan_id_any][inner_vlan_id_any]") \
20791 _(ip_table_replace_begin, "table <n> [ipv6]") \
20792 _(ip_table_flush, "table <n> [ipv6]") \
20793 _(ip_table_replace_end, "table <n> [ipv6]") \
20794 _(set_ip_flow_hash, \
20795 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20796 _(sw_interface_ip6_enable_disable, \
20797 "<intfc> | sw_if_index <id> enable | disable") \
20798 _(l2_patch_add_del, \
20799 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20800 "enable | disable") \
20801 _(sr_localsid_add_del, \
20802 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20803 "fib-table <num> (end.psp) sw_if_index <num>") \
20804 _(classify_add_del_table, \
20805 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20806 " [del] [del-chain] mask <mask-value>\n" \
20807 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20808 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20809 _(classify_add_del_session, \
20810 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20811 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20812 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20813 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20814 _(classify_set_interface_ip_table, \
20815 "<intfc> | sw_if_index <nn> table <nn>") \
20816 _(classify_set_interface_l2_tables, \
20817 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20818 " [other-table <nn>]") \
20819 _(get_node_index, "node <node-name") \
20820 _(add_node_next, "node <node-name> next <next-node-name>") \
20821 _(l2tpv3_create_tunnel, \
20822 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20823 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20824 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20825 _(l2tpv3_set_tunnel_cookies, \
20826 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20827 "[new_remote_cookie <nn>]\n") \
20828 _(l2tpv3_interface_enable_disable, \
20829 "<intfc> | sw_if_index <nn> enable | disable") \
20830 _(l2tpv3_set_lookup_key, \
20831 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20832 _(sw_if_l2tpv3_tunnel_dump, "") \
20833 _(vxlan_offload_rx, \
20834 "hw { <interface name> | hw_if_index <nn>} " \
20835 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20836 _(vxlan_add_del_tunnel, \
20837 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20838 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20839 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20840 _(geneve_add_del_tunnel, \
20841 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20842 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20843 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20844 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20845 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20846 _(gre_tunnel_add_del, \
20847 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20848 "[teb | erspan <session-id>] [del]") \
20849 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20850 _(l2_fib_clear_table, "") \
20851 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20852 _(l2_interface_vlan_tag_rewrite, \
20853 "<intfc> | sw_if_index <nn> \n" \
20854 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20855 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20856 _(create_vhost_user_if, \
20857 "socket <filename> [server] [renumber <dev_instance>] " \
20858 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20859 "[mac <mac_address>]") \
20860 _(modify_vhost_user_if, \
20861 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20862 "[server] [renumber <dev_instance>] [gso]") \
20863 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20864 _(sw_interface_vhost_user_dump, "") \
20865 _(show_version, "") \
20866 _(show_threads, "") \
20867 _(vxlan_gpe_add_del_tunnel, \
20868 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20869 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20870 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20871 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20872 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20873 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20874 _(interface_name_renumber, \
20875 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20876 _(input_acl_set_interface, \
20877 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20878 " [l2-table <nn>] [del]") \
20879 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20880 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20881 _(ip_dump, "ipv4 | ipv6") \
20882 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20883 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20885 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20886 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20887 " integ_alg <alg> integ_key <hex>") \
20888 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20889 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20890 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20891 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20892 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20893 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20894 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20895 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20896 " [instance <n>]") \
20897 _(ipsec_sa_dump, "[sa_id <n>]") \
20898 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20899 _(delete_loopback,"sw_if_index <nn>") \
20900 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20901 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20902 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20903 _(want_interface_events, "enable|disable") \
20904 _(get_first_msg_id, "client <name>") \
20905 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20906 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20907 "fib-id <nn> [ip4][ip6][default]") \
20908 _(get_node_graph, " ") \
20909 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20910 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20911 _(ioam_disable, "") \
20912 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20913 " sw_if_index <sw_if_index> p <priority> " \
20914 "w <weight>] [del]") \
20915 _(one_add_del_locator, "locator-set <locator_name> " \
20916 "iface <intf> | sw_if_index <sw_if_index> " \
20917 "p <priority> w <weight> [del]") \
20918 _(one_add_del_local_eid,"vni <vni> eid " \
20919 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20920 "locator-set <locator_name> [del]" \
20921 "[key-id sha1|sha256 secret-key <secret-key>]")\
20922 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20923 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20924 _(one_enable_disable, "enable|disable") \
20925 _(one_map_register_enable_disable, "enable|disable") \
20926 _(one_map_register_fallback_threshold, "<value>") \
20927 _(one_rloc_probe_enable_disable, "enable|disable") \
20928 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20930 "rloc <locator> p <prio> " \
20931 "w <weight> [rloc <loc> ... ] " \
20932 "action <action> [del-all]") \
20933 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20935 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20936 _(one_use_petr, "ip-address> | disable") \
20937 _(one_map_request_mode, "src-dst|dst-only") \
20938 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20939 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20940 _(one_locator_set_dump, "[local | remote]") \
20941 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20942 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20943 "[local] | [remote]") \
20944 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20945 _(one_ndp_bd_get, "") \
20946 _(one_ndp_entries_get, "bd <bridge-domain>") \
20947 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20948 _(one_l2_arp_bd_get, "") \
20949 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20950 _(one_stats_enable_disable, "enable|disable") \
20951 _(show_one_stats_enable_disable, "") \
20952 _(one_eid_table_vni_dump, "") \
20953 _(one_eid_table_map_dump, "l2|l3") \
20954 _(one_map_resolver_dump, "") \
20955 _(one_map_server_dump, "") \
20956 _(one_adjacencies_get, "vni <vni>") \
20957 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20958 _(show_one_rloc_probe_state, "") \
20959 _(show_one_map_register_state, "") \
20960 _(show_one_status, "") \
20961 _(one_stats_dump, "") \
20962 _(one_stats_flush, "") \
20963 _(one_get_map_request_itr_rlocs, "") \
20964 _(one_map_register_set_ttl, "<ttl>") \
20965 _(one_set_transport_protocol, "udp|api") \
20966 _(one_get_transport_protocol, "") \
20967 _(one_enable_disable_xtr_mode, "enable|disable") \
20968 _(one_show_xtr_mode, "") \
20969 _(one_enable_disable_pitr_mode, "enable|disable") \
20970 _(one_show_pitr_mode, "") \
20971 _(one_enable_disable_petr_mode, "enable|disable") \
20972 _(one_show_petr_mode, "") \
20973 _(show_one_nsh_mapping, "") \
20974 _(show_one_pitr, "") \
20975 _(show_one_use_petr, "") \
20976 _(show_one_map_request_mode, "") \
20977 _(show_one_map_register_ttl, "") \
20978 _(show_one_map_register_fallback_threshold, "") \
20979 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20980 " sw_if_index <sw_if_index> p <priority> " \
20981 "w <weight>] [del]") \
20982 _(lisp_add_del_locator, "locator-set <locator_name> " \
20983 "iface <intf> | sw_if_index <sw_if_index> " \
20984 "p <priority> w <weight> [del]") \
20985 _(lisp_add_del_local_eid,"vni <vni> eid " \
20986 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20987 "locator-set <locator_name> [del]" \
20988 "[key-id sha1|sha256 secret-key <secret-key>]") \
20989 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20990 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20991 _(lisp_enable_disable, "enable|disable") \
20992 _(lisp_map_register_enable_disable, "enable|disable") \
20993 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20994 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20996 "rloc <locator> p <prio> " \
20997 "w <weight> [rloc <loc> ... ] " \
20998 "action <action> [del-all]") \
20999 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21001 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21002 _(lisp_use_petr, "<ip-address> | disable") \
21003 _(lisp_map_request_mode, "src-dst|dst-only") \
21004 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21005 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21006 _(lisp_locator_set_dump, "[local | remote]") \
21007 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
21008 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21009 "[local] | [remote]") \
21010 _(lisp_eid_table_vni_dump, "") \
21011 _(lisp_eid_table_map_dump, "l2|l3") \
21012 _(lisp_map_resolver_dump, "") \
21013 _(lisp_map_server_dump, "") \
21014 _(lisp_adjacencies_get, "vni <vni>") \
21015 _(gpe_fwd_entry_vnis_get, "") \
21016 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
21017 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
21018 "[table <table-id>]") \
21019 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
21020 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
21021 _(gpe_set_encap_mode, "lisp|vxlan") \
21022 _(gpe_get_encap_mode, "") \
21023 _(lisp_gpe_add_del_iface, "up|down") \
21024 _(lisp_gpe_enable_disable, "enable|disable") \
21025 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
21026 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
21027 _(show_lisp_rloc_probe_state, "") \
21028 _(show_lisp_map_register_state, "") \
21029 _(show_lisp_status, "") \
21030 _(lisp_get_map_request_itr_rlocs, "") \
21031 _(show_lisp_pitr, "") \
21032 _(show_lisp_use_petr, "") \
21033 _(show_lisp_map_request_mode, "") \
21034 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
21035 _(af_packet_delete, "name <host interface name>") \
21036 _(af_packet_dump, "") \
21037 _(policer_add_del, "name <policer name> <params> [del]") \
21038 _(policer_dump, "[name <policer name>]") \
21039 _(policer_classify_set_interface, \
21040 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21041 " [l2-table <nn>] [del]") \
21042 _(policer_classify_dump, "type [ip4|ip6|l2]") \
21043 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
21044 "[master|slave]") \
21045 _(netmap_delete, "name <interface name>") \
21046 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
21047 _(mpls_table_dump, "") \
21048 _(mpls_route_dump, "table-id <ID>") \
21049 _(classify_table_ids, "") \
21050 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
21051 _(classify_table_info, "table_id <nn>") \
21052 _(classify_session_dump, "table_id <nn>") \
21053 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
21054 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
21055 "[template_interval <nn>] [udp_checksum]") \
21056 _(ipfix_exporter_dump, "") \
21057 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
21058 _(ipfix_classify_stream_dump, "") \
21059 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
21060 _(ipfix_classify_table_dump, "") \
21061 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
21062 _(sw_interface_span_dump, "[l2]") \
21063 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
21064 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
21065 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
21066 _(pg_enable_disable, "[stream <id>] disable") \
21067 _(ip_source_and_port_range_check_add_del, \
21068 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21069 _(ip_source_and_port_range_check_interface_add_del, \
21070 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21071 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21072 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21073 _(l2_interface_pbb_tag_rewrite, \
21074 "<intfc> | sw_if_index <nn> \n" \
21075 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21076 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21077 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21078 _(flow_classify_set_interface, \
21079 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21080 _(flow_classify_dump, "type [ip4|ip6]") \
21081 _(ip_table_dump, "") \
21082 _(ip_route_dump, "table-id [ip4|ip6]") \
21083 _(ip_mtable_dump, "") \
21084 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21085 _(feature_enable_disable, "arc_name <arc_name> " \
21086 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21087 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21088 "[enable | disable] ") \
21089 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21091 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21092 "mac <mac-address> [del]") \
21093 _(l2_xconnect_dump, "") \
21094 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21095 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21096 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21097 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21098 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21099 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21100 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21101 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21102 _(sock_init_shm, "size <nnn>") \
21103 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21104 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21105 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21106 _(session_rules_dump, "") \
21107 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21108 _(output_acl_set_interface, \
21109 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21110 " [l2-table <nn>] [del]") \
21111 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21113 /* List of command functions, CLI names map directly to functions */
21114 #define foreach_cli_function \
21115 _(comment, "usage: comment <ignore-rest-of-line>") \
21116 _(dump_interface_table, "usage: dump_interface_table") \
21117 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21118 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21119 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21120 _(dump_macro_table, "usage: dump_macro_table ") \
21121 _(dump_node_table, "usage: dump_node_table") \
21122 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21123 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21124 _(elog_disable, "usage: elog_disable") \
21125 _(elog_enable, "usage: elog_enable") \
21126 _(elog_save, "usage: elog_save <filename>") \
21127 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21128 _(echo, "usage: echo <message>") \
21129 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21130 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21131 _(help, "usage: help") \
21132 _(q, "usage: quit") \
21133 _(quit, "usage: quit") \
21134 _(search_node_table, "usage: search_node_table <name>...") \
21135 _(set, "usage: set <variable-name> <value>") \
21136 _(script, "usage: script <file-name>") \
21137 _(statseg, "usage: statseg") \
21138 _(unset, "usage: unset <variable-name>")
21141 static void vl_api_##n##_t_handler_uni \
21142 (vl_api_##n##_t * mp) \
21144 vat_main_t * vam = &vat_main; \
21145 if (vam->json_output) { \
21146 vl_api_##n##_t_handler_json(mp); \
21148 vl_api_##n##_t_handler(mp); \
21151 foreach_vpe_api_reply_msg;
21152 #if VPP_API_TEST_BUILTIN == 0
21153 foreach_standalone_reply_msg;
21158 vat_api_hookup (vat_main_t * vam)
21161 vl_msg_api_set_handlers(VL_API_##N, #n, \
21162 vl_api_##n##_t_handler_uni, \
21164 vl_api_##n##_t_endian, \
21165 vl_api_##n##_t_print, \
21166 sizeof(vl_api_##n##_t), 1);
21167 foreach_vpe_api_reply_msg;
21168 #if VPP_API_TEST_BUILTIN == 0
21169 foreach_standalone_reply_msg;
21173 #if (VPP_API_TEST_BUILTIN==0)
21174 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21176 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21178 vam->function_by_name = hash_create_string (0, sizeof (uword));
21180 vam->help_by_name = hash_create_string (0, sizeof (uword));
21183 /* API messages we can send */
21184 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21185 foreach_vpe_api_msg;
21189 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21190 foreach_vpe_api_msg;
21193 /* CLI functions */
21194 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21195 foreach_cli_function;
21199 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21200 foreach_cli_function;
21204 #if VPP_API_TEST_BUILTIN
21205 static clib_error_t *
21206 vat_api_hookup_shim (vlib_main_t * vm)
21208 vat_api_hookup (&vat_main);
21212 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21216 * fd.io coding-style-patch-verification: ON
21219 * eval: (c-set-style "gnu")