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 IP46 address. */
269 unformat_ip46_address (unformat_input_t * input, va_list * args)
271 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
272 ip46_type_t type = va_arg (*args, ip46_type_t);
273 if ((type != IP46_TYPE_IP6) &&
274 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
276 ip46_address_mask_ip4 (ip46);
279 else if ((type != IP46_TYPE_IP4) &&
280 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
287 /* Parse an IP6 address. */
289 unformat_ip6_address (unformat_input_t * input, va_list * args)
291 ip6_address_t *result = va_arg (*args, ip6_address_t *);
293 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
294 uword c, n_colon, double_colon_index;
296 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
297 double_colon_index = ARRAY_LEN (hex_quads);
298 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
301 if (c >= '0' && c <= '9')
303 else if (c >= 'a' && c <= 'f')
304 hex_digit = c + 10 - 'a';
305 else if (c >= 'A' && c <= 'F')
306 hex_digit = c + 10 - 'A';
307 else if (c == ':' && n_colon < 2)
311 unformat_put_input (input);
315 /* Too many hex quads. */
316 if (n_hex_quads >= ARRAY_LEN (hex_quads))
321 hex_quad = (hex_quad << 4) | hex_digit;
323 /* Hex quad must fit in 16 bits. */
324 if (n_hex_digits >= 4)
331 /* Save position of :: */
334 /* More than one :: ? */
335 if (double_colon_index < ARRAY_LEN (hex_quads))
337 double_colon_index = n_hex_quads;
340 if (n_colon > 0 && n_hex_digits > 0)
342 hex_quads[n_hex_quads++] = hex_quad;
348 if (n_hex_digits > 0)
349 hex_quads[n_hex_quads++] = hex_quad;
354 /* Expand :: to appropriate number of zero hex quads. */
355 if (double_colon_index < ARRAY_LEN (hex_quads))
357 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
359 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
360 hex_quads[n_zero + i] = hex_quads[i];
362 for (i = 0; i < n_zero; i++)
363 hex_quads[double_colon_index + i] = 0;
365 n_hex_quads = ARRAY_LEN (hex_quads);
368 /* Too few hex quads given. */
369 if (n_hex_quads < ARRAY_LEN (hex_quads))
372 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
373 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
380 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
382 u32 *r = va_arg (*args, u32 *);
385 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
386 foreach_ipsec_policy_action
394 format_ipsec_crypto_alg (u8 * s, va_list * args)
396 u32 i = va_arg (*args, u32);
401 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
402 foreach_ipsec_crypto_alg
405 return format (s, "unknown");
407 return format (s, "%s", t);
411 format_ipsec_integ_alg (u8 * s, va_list * args)
413 u32 i = va_arg (*args, u32);
418 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
419 foreach_ipsec_integ_alg
422 return format (s, "unknown");
424 return format (s, "%s", t);
427 #else /* VPP_API_TEST_BUILTIN == 1 */
429 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
431 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
432 vnet_main_t *vnm = vnet_get_main ();
433 u32 *result = va_arg (*args, u32 *);
435 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
439 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
441 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
442 vnet_main_t *vnm = vnet_get_main ();
443 u32 *result = va_arg (*args, u32 *);
445 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
448 #endif /* VPP_API_TEST_BUILTIN */
451 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
453 u32 *r = va_arg (*args, u32 *);
456 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
457 foreach_ipsec_crypto_alg
465 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
467 u32 *r = va_arg (*args, u32 *);
470 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
471 foreach_ipsec_integ_alg
479 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
481 u8 *r = va_arg (*args, u8 *);
483 if (unformat (input, "kbps"))
484 *r = SSE2_QOS_RATE_KBPS;
485 else if (unformat (input, "pps"))
486 *r = SSE2_QOS_RATE_PPS;
493 unformat_policer_round_type (unformat_input_t * input, va_list * args)
495 u8 *r = va_arg (*args, u8 *);
497 if (unformat (input, "closest"))
498 *r = SSE2_QOS_ROUND_TO_CLOSEST;
499 else if (unformat (input, "up"))
500 *r = SSE2_QOS_ROUND_TO_UP;
501 else if (unformat (input, "down"))
502 *r = SSE2_QOS_ROUND_TO_DOWN;
509 unformat_policer_type (unformat_input_t * input, va_list * args)
511 u8 *r = va_arg (*args, u8 *);
513 if (unformat (input, "1r2c"))
514 *r = SSE2_QOS_POLICER_TYPE_1R2C;
515 else if (unformat (input, "1r3c"))
516 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
517 else if (unformat (input, "2r3c-2698"))
518 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
519 else if (unformat (input, "2r3c-4115"))
520 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
521 else if (unformat (input, "2r3c-mef5cf1"))
522 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
529 unformat_dscp (unformat_input_t * input, va_list * va)
531 u8 *r = va_arg (*va, u8 *);
534 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
543 unformat_policer_action_type (unformat_input_t * input, va_list * va)
545 sse2_qos_pol_action_params_st *a
546 = va_arg (*va, sse2_qos_pol_action_params_st *);
548 if (unformat (input, "drop"))
549 a->action_type = SSE2_QOS_ACTION_DROP;
550 else if (unformat (input, "transmit"))
551 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
552 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
553 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
560 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
562 u32 *r = va_arg (*va, u32 *);
565 if (unformat (input, "ip4"))
566 tid = POLICER_CLASSIFY_TABLE_IP4;
567 else if (unformat (input, "ip6"))
568 tid = POLICER_CLASSIFY_TABLE_IP6;
569 else if (unformat (input, "l2"))
570 tid = POLICER_CLASSIFY_TABLE_L2;
579 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
581 u32 *r = va_arg (*va, u32 *);
584 if (unformat (input, "ip4"))
585 tid = FLOW_CLASSIFY_TABLE_IP4;
586 else if (unformat (input, "ip6"))
587 tid = FLOW_CLASSIFY_TABLE_IP6;
595 #if (VPP_API_TEST_BUILTIN==0)
597 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
598 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
599 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
600 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
603 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
605 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
606 mfib_itf_attribute_t attr;
609 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
611 if (unformat (input, mfib_itf_flag_long_names[attr]))
612 *iflags |= (1 << attr);
614 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
616 if (unformat (input, mfib_itf_flag_names[attr]))
617 *iflags |= (1 << attr);
620 return (old == *iflags ? 0 : 1);
624 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
626 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
627 mfib_entry_attribute_t attr;
630 FOR_EACH_MFIB_ATTRIBUTE (attr)
632 if (unformat (input, mfib_flag_long_names[attr]))
633 *eflags |= (1 << attr);
635 FOR_EACH_MFIB_ATTRIBUTE (attr)
637 if (unformat (input, mfib_flag_names[attr]))
638 *eflags |= (1 << attr);
641 return (old == *eflags ? 0 : 1);
645 format_ip4_address (u8 * s, va_list * args)
647 u8 *a = va_arg (*args, u8 *);
648 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
652 format_ip6_address (u8 * s, va_list * args)
654 ip6_address_t *a = va_arg (*args, ip6_address_t *);
655 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
657 i_max_n_zero = ARRAY_LEN (a->as_u16);
659 i_first_zero = i_max_n_zero;
661 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
663 u32 is_zero = a->as_u16[i] == 0;
664 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
670 if ((!is_zero && n_zeros > max_n_zeros)
671 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
673 i_max_n_zero = i_first_zero;
674 max_n_zeros = n_zeros;
675 i_first_zero = ARRAY_LEN (a->as_u16);
680 last_double_colon = 0;
681 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
683 if (i == i_max_n_zero && max_n_zeros > 1)
685 s = format (s, "::");
686 i += max_n_zeros - 1;
687 last_double_colon = 1;
691 s = format (s, "%s%x",
692 (last_double_colon || i == 0) ? "" : ":",
693 clib_net_to_host_u16 (a->as_u16[i]));
694 last_double_colon = 0;
701 /* Format an IP46 address. */
703 format_ip46_address (u8 * s, va_list * args)
705 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
706 ip46_type_t type = va_arg (*args, ip46_type_t);
712 is_ip4 = ip46_address_is_ip4 (ip46);
723 format (s, "%U", format_ip4_address, &ip46->ip4) :
724 format (s, "%U", format_ip6_address, &ip46->ip6);
728 format_ethernet_address (u8 * s, va_list * args)
730 u8 *a = va_arg (*args, u8 *);
732 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
733 a[0], a[1], a[2], a[3], a[4], a[5]);
738 increment_v4_address (vl_api_ip4_address_t * i)
740 ip4_address_t *a = (ip4_address_t *) i;
743 v = ntohl (a->as_u32) + 1;
744 a->as_u32 = ntohl (v);
748 increment_v6_address (vl_api_ip6_address_t * i)
750 ip6_address_t *a = (ip6_address_t *) i;
753 v0 = clib_net_to_host_u64 (a->as_u64[0]);
754 v1 = clib_net_to_host_u64 (a->as_u64[1]);
759 a->as_u64[0] = clib_net_to_host_u64 (v0);
760 a->as_u64[1] = clib_net_to_host_u64 (v1);
764 increment_address (vl_api_address_t * a)
766 if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
767 increment_v4_address (&a->un.ip4);
768 else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
769 increment_v6_address (&a->un.ip6);
773 set_ip4_address (vl_api_address_t * a, u32 v)
775 if (a->af == ADDRESS_IP4)
777 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
783 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
786 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
788 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
789 sizeof (ip6_address_t));
793 increment_mac_address (u8 * mac)
795 u64 tmp = *((u64 *) mac);
796 tmp = clib_net_to_host_u64 (tmp);
797 tmp += 1 << 16; /* skip unused (least significant) octets */
798 tmp = clib_host_to_net_u64 (tmp);
800 clib_memcpy (mac, &tmp, 6);
804 vat_json_object_add_address (vat_json_node_t * node,
805 const char *str, const vl_api_address_t * addr)
807 if (ADDRESS_IP6 == addr->af)
811 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
812 vat_json_object_add_ip6 (node, str, ip6);
818 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
819 vat_json_object_add_ip4 (node, str, ip4);
824 vat_json_object_add_prefix (vat_json_node_t * node,
825 const vl_api_prefix_t * prefix)
827 vat_json_object_add_uint (node, "len", prefix->len);
828 vat_json_object_add_address (node, "address", &prefix->address);
831 static void vl_api_create_loopback_reply_t_handler
832 (vl_api_create_loopback_reply_t * mp)
834 vat_main_t *vam = &vat_main;
835 i32 retval = ntohl (mp->retval);
837 vam->retval = retval;
838 vam->regenerate_interface_table = 1;
839 vam->sw_if_index = ntohl (mp->sw_if_index);
840 vam->result_ready = 1;
843 static void vl_api_create_loopback_reply_t_handler_json
844 (vl_api_create_loopback_reply_t * mp)
846 vat_main_t *vam = &vat_main;
847 vat_json_node_t node;
849 vat_json_init_object (&node);
850 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
851 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
853 vat_json_print (vam->ofp, &node);
854 vat_json_free (&node);
855 vam->retval = ntohl (mp->retval);
856 vam->result_ready = 1;
859 static void vl_api_create_loopback_instance_reply_t_handler
860 (vl_api_create_loopback_instance_reply_t * mp)
862 vat_main_t *vam = &vat_main;
863 i32 retval = ntohl (mp->retval);
865 vam->retval = retval;
866 vam->regenerate_interface_table = 1;
867 vam->sw_if_index = ntohl (mp->sw_if_index);
868 vam->result_ready = 1;
871 static void vl_api_create_loopback_instance_reply_t_handler_json
872 (vl_api_create_loopback_instance_reply_t * mp)
874 vat_main_t *vam = &vat_main;
875 vat_json_node_t node;
877 vat_json_init_object (&node);
878 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
879 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
881 vat_json_print (vam->ofp, &node);
882 vat_json_free (&node);
883 vam->retval = ntohl (mp->retval);
884 vam->result_ready = 1;
887 static void vl_api_af_packet_create_reply_t_handler
888 (vl_api_af_packet_create_reply_t * mp)
890 vat_main_t *vam = &vat_main;
891 i32 retval = ntohl (mp->retval);
893 vam->retval = retval;
894 vam->regenerate_interface_table = 1;
895 vam->sw_if_index = ntohl (mp->sw_if_index);
896 vam->result_ready = 1;
899 static void vl_api_af_packet_create_reply_t_handler_json
900 (vl_api_af_packet_create_reply_t * mp)
902 vat_main_t *vam = &vat_main;
903 vat_json_node_t node;
905 vat_json_init_object (&node);
906 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
907 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
909 vat_json_print (vam->ofp, &node);
910 vat_json_free (&node);
912 vam->retval = ntohl (mp->retval);
913 vam->result_ready = 1;
916 static void vl_api_create_vlan_subif_reply_t_handler
917 (vl_api_create_vlan_subif_reply_t * mp)
919 vat_main_t *vam = &vat_main;
920 i32 retval = ntohl (mp->retval);
922 vam->retval = retval;
923 vam->regenerate_interface_table = 1;
924 vam->sw_if_index = ntohl (mp->sw_if_index);
925 vam->result_ready = 1;
928 static void vl_api_create_vlan_subif_reply_t_handler_json
929 (vl_api_create_vlan_subif_reply_t * mp)
931 vat_main_t *vam = &vat_main;
932 vat_json_node_t node;
934 vat_json_init_object (&node);
935 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
936 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
938 vat_json_print (vam->ofp, &node);
939 vat_json_free (&node);
941 vam->retval = ntohl (mp->retval);
942 vam->result_ready = 1;
945 static void vl_api_create_subif_reply_t_handler
946 (vl_api_create_subif_reply_t * mp)
948 vat_main_t *vam = &vat_main;
949 i32 retval = ntohl (mp->retval);
951 vam->retval = retval;
952 vam->regenerate_interface_table = 1;
953 vam->sw_if_index = ntohl (mp->sw_if_index);
954 vam->result_ready = 1;
957 static void vl_api_create_subif_reply_t_handler_json
958 (vl_api_create_subif_reply_t * mp)
960 vat_main_t *vam = &vat_main;
961 vat_json_node_t node;
963 vat_json_init_object (&node);
964 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
965 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
967 vat_json_print (vam->ofp, &node);
968 vat_json_free (&node);
970 vam->retval = ntohl (mp->retval);
971 vam->result_ready = 1;
974 static void vl_api_interface_name_renumber_reply_t_handler
975 (vl_api_interface_name_renumber_reply_t * mp)
977 vat_main_t *vam = &vat_main;
978 i32 retval = ntohl (mp->retval);
980 vam->retval = retval;
981 vam->regenerate_interface_table = 1;
982 vam->result_ready = 1;
985 static void vl_api_interface_name_renumber_reply_t_handler_json
986 (vl_api_interface_name_renumber_reply_t * mp)
988 vat_main_t *vam = &vat_main;
989 vat_json_node_t node;
991 vat_json_init_object (&node);
992 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
994 vat_json_print (vam->ofp, &node);
995 vat_json_free (&node);
997 vam->retval = ntohl (mp->retval);
998 vam->result_ready = 1;
1002 * Special-case: build the interface table, maintain
1003 * the next loopback sw_if_index vbl.
1005 static void vl_api_sw_interface_details_t_handler
1006 (vl_api_sw_interface_details_t * mp)
1008 vat_main_t *vam = &vat_main;
1009 u8 *s = format (0, "%s%c", mp->interface_name, 0);
1011 hash_set_mem (vam->sw_if_index_by_interface_name, s,
1012 ntohl (mp->sw_if_index));
1014 /* In sub interface case, fill the sub interface table entry */
1015 if (mp->sw_if_index != mp->sup_sw_if_index)
1017 sw_interface_subif_t *sub = NULL;
1019 vec_add2 (vam->sw_if_subif_table, sub, 1);
1021 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
1022 strncpy ((char *) sub->interface_name, (char *) s,
1023 vec_len (sub->interface_name));
1024 sub->sw_if_index = ntohl (mp->sw_if_index);
1025 sub->sub_id = ntohl (mp->sub_id);
1027 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
1029 sub->sub_number_of_tags = mp->sub_number_of_tags;
1030 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1031 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1033 /* vlan tag rewrite */
1034 sub->vtr_op = ntohl (mp->vtr_op);
1035 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1036 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1037 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1041 static void vl_api_sw_interface_details_t_handler_json
1042 (vl_api_sw_interface_details_t * mp)
1044 vat_main_t *vam = &vat_main;
1045 vat_json_node_t *node = NULL;
1047 if (VAT_JSON_ARRAY != vam->json_tree.type)
1049 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1050 vat_json_init_array (&vam->json_tree);
1052 node = vat_json_array_add (&vam->json_tree);
1054 vat_json_init_object (node);
1055 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1056 vat_json_object_add_uint (node, "sup_sw_if_index",
1057 ntohl (mp->sup_sw_if_index));
1058 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1059 sizeof (mp->l2_address));
1060 vat_json_object_add_string_copy (node, "interface_name",
1061 mp->interface_name);
1062 vat_json_object_add_string_copy (node, "interface_dev_type",
1063 mp->interface_dev_type);
1064 vat_json_object_add_uint (node, "flags", mp->flags);
1065 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1066 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1067 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1068 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1069 vat_json_object_add_uint (node, "sub_number_of_tags",
1070 mp->sub_number_of_tags);
1071 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1072 ntohs (mp->sub_outer_vlan_id));
1073 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1074 ntohs (mp->sub_inner_vlan_id));
1075 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1076 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1077 vat_json_object_add_uint (node, "vtr_push_dot1q",
1078 ntohl (mp->vtr_push_dot1q));
1079 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1080 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1081 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1083 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1085 format_ethernet_address,
1087 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1089 format_ethernet_address,
1091 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1092 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1096 #if VPP_API_TEST_BUILTIN == 0
1097 static void vl_api_sw_interface_event_t_handler
1098 (vl_api_sw_interface_event_t * mp)
1100 vat_main_t *vam = &vat_main;
1101 if (vam->interface_event_display)
1102 errmsg ("interface flags: sw_if_index %d %s %s",
1103 ntohl (mp->sw_if_index),
1104 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1105 "admin-up" : "admin-down",
1106 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1107 "link-up" : "link-down");
1111 __clib_unused static void
1112 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1114 /* JSON output not supported */
1118 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1120 vat_main_t *vam = &vat_main;
1121 i32 retval = ntohl (mp->retval);
1123 vam->retval = retval;
1124 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1125 vam->result_ready = 1;
1129 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1131 vat_main_t *vam = &vat_main;
1132 vat_json_node_t node;
1136 vat_json_init_object (&node);
1137 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1138 vat_json_object_add_uint (&node, "reply_in_shmem",
1139 ntohl (mp->reply_in_shmem));
1140 /* Toss the shared-memory original... */
1141 oldheap = vl_msg_push_heap ();
1143 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1146 vl_msg_pop_heap (oldheap);
1148 vat_json_print (vam->ofp, &node);
1149 vat_json_free (&node);
1151 vam->retval = ntohl (mp->retval);
1152 vam->result_ready = 1;
1156 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1158 vat_main_t *vam = &vat_main;
1159 i32 retval = ntohl (mp->retval);
1161 vec_reset_length (vam->cmd_reply);
1163 vam->retval = retval;
1165 vam->cmd_reply = vl_api_from_api_to_new_vec (&mp->reply);
1166 vam->result_ready = 1;
1170 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1172 vat_main_t *vam = &vat_main;
1173 vat_json_node_t node;
1174 u8 *reply = 0; /* reply vector */
1176 reply = vl_api_from_api_to_new_vec (&mp->reply);
1177 vec_reset_length (vam->cmd_reply);
1179 vat_json_init_object (&node);
1180 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1181 vat_json_object_add_string_copy (&node, "reply", reply);
1183 vat_json_print (vam->ofp, &node);
1184 vat_json_free (&node);
1187 vam->retval = ntohl (mp->retval);
1188 vam->result_ready = 1;
1191 static void vl_api_classify_add_del_table_reply_t_handler
1192 (vl_api_classify_add_del_table_reply_t * mp)
1194 vat_main_t *vam = &vat_main;
1195 i32 retval = ntohl (mp->retval);
1196 if (vam->async_mode)
1198 vam->async_errors += (retval < 0);
1202 vam->retval = retval;
1204 ((mp->new_table_index != 0xFFFFFFFF) ||
1205 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1206 (mp->match_n_vectors != 0xFFFFFFFF)))
1208 * Note: this is just barely thread-safe, depends on
1209 * the main thread spinning waiting for an answer...
1211 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1212 ntohl (mp->new_table_index),
1213 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1214 vam->result_ready = 1;
1218 static void vl_api_classify_add_del_table_reply_t_handler_json
1219 (vl_api_classify_add_del_table_reply_t * mp)
1221 vat_main_t *vam = &vat_main;
1222 vat_json_node_t node;
1224 vat_json_init_object (&node);
1225 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1226 vat_json_object_add_uint (&node, "new_table_index",
1227 ntohl (mp->new_table_index));
1228 vat_json_object_add_uint (&node, "skip_n_vectors",
1229 ntohl (mp->skip_n_vectors));
1230 vat_json_object_add_uint (&node, "match_n_vectors",
1231 ntohl (mp->match_n_vectors));
1233 vat_json_print (vam->ofp, &node);
1234 vat_json_free (&node);
1236 vam->retval = ntohl (mp->retval);
1237 vam->result_ready = 1;
1240 static void vl_api_get_node_index_reply_t_handler
1241 (vl_api_get_node_index_reply_t * mp)
1243 vat_main_t *vam = &vat_main;
1244 i32 retval = ntohl (mp->retval);
1245 if (vam->async_mode)
1247 vam->async_errors += (retval < 0);
1251 vam->retval = retval;
1253 errmsg ("node index %d", ntohl (mp->node_index));
1254 vam->result_ready = 1;
1258 static void vl_api_get_node_index_reply_t_handler_json
1259 (vl_api_get_node_index_reply_t * mp)
1261 vat_main_t *vam = &vat_main;
1262 vat_json_node_t node;
1264 vat_json_init_object (&node);
1265 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1266 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1268 vat_json_print (vam->ofp, &node);
1269 vat_json_free (&node);
1271 vam->retval = ntohl (mp->retval);
1272 vam->result_ready = 1;
1275 static void vl_api_get_next_index_reply_t_handler
1276 (vl_api_get_next_index_reply_t * mp)
1278 vat_main_t *vam = &vat_main;
1279 i32 retval = ntohl (mp->retval);
1280 if (vam->async_mode)
1282 vam->async_errors += (retval < 0);
1286 vam->retval = retval;
1288 errmsg ("next node index %d", ntohl (mp->next_index));
1289 vam->result_ready = 1;
1293 static void vl_api_get_next_index_reply_t_handler_json
1294 (vl_api_get_next_index_reply_t * mp)
1296 vat_main_t *vam = &vat_main;
1297 vat_json_node_t node;
1299 vat_json_init_object (&node);
1300 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1301 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1303 vat_json_print (vam->ofp, &node);
1304 vat_json_free (&node);
1306 vam->retval = ntohl (mp->retval);
1307 vam->result_ready = 1;
1310 static void vl_api_add_node_next_reply_t_handler
1311 (vl_api_add_node_next_reply_t * mp)
1313 vat_main_t *vam = &vat_main;
1314 i32 retval = ntohl (mp->retval);
1315 if (vam->async_mode)
1317 vam->async_errors += (retval < 0);
1321 vam->retval = retval;
1323 errmsg ("next index %d", ntohl (mp->next_index));
1324 vam->result_ready = 1;
1328 static void vl_api_add_node_next_reply_t_handler_json
1329 (vl_api_add_node_next_reply_t * mp)
1331 vat_main_t *vam = &vat_main;
1332 vat_json_node_t node;
1334 vat_json_init_object (&node);
1335 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1336 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1338 vat_json_print (vam->ofp, &node);
1339 vat_json_free (&node);
1341 vam->retval = ntohl (mp->retval);
1342 vam->result_ready = 1;
1345 static void vl_api_show_version_reply_t_handler
1346 (vl_api_show_version_reply_t * mp)
1348 vat_main_t *vam = &vat_main;
1349 i32 retval = ntohl (mp->retval);
1353 errmsg (" program: %s", mp->program);
1354 errmsg (" version: %s", mp->version);
1355 errmsg (" build date: %s", mp->build_date);
1356 errmsg ("build directory: %s", mp->build_directory);
1358 vam->retval = retval;
1359 vam->result_ready = 1;
1362 static void vl_api_show_version_reply_t_handler_json
1363 (vl_api_show_version_reply_t * mp)
1365 vat_main_t *vam = &vat_main;
1366 vat_json_node_t node;
1368 vat_json_init_object (&node);
1369 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1370 vat_json_object_add_string_copy (&node, "program", mp->program);
1371 vat_json_object_add_string_copy (&node, "version", mp->version);
1372 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1373 vat_json_object_add_string_copy (&node, "build_directory",
1374 mp->build_directory);
1376 vat_json_print (vam->ofp, &node);
1377 vat_json_free (&node);
1379 vam->retval = ntohl (mp->retval);
1380 vam->result_ready = 1;
1383 static void vl_api_show_threads_reply_t_handler
1384 (vl_api_show_threads_reply_t * mp)
1386 vat_main_t *vam = &vat_main;
1387 i32 retval = ntohl (mp->retval);
1391 count = ntohl (mp->count);
1393 for (i = 0; i < count; i++)
1395 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1396 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1397 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1398 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1399 ntohl (mp->thread_data[i].cpu_socket));
1401 vam->retval = retval;
1402 vam->result_ready = 1;
1405 static void vl_api_show_threads_reply_t_handler_json
1406 (vl_api_show_threads_reply_t * mp)
1408 vat_main_t *vam = &vat_main;
1409 vat_json_node_t node;
1410 vl_api_thread_data_t *td;
1411 i32 retval = ntohl (mp->retval);
1415 count = ntohl (mp->count);
1417 vat_json_init_object (&node);
1418 vat_json_object_add_int (&node, "retval", retval);
1419 vat_json_object_add_uint (&node, "count", count);
1421 for (i = 0; i < count; i++)
1423 td = &mp->thread_data[i];
1424 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1425 vat_json_object_add_string_copy (&node, "name", td->name);
1426 vat_json_object_add_string_copy (&node, "type", td->type);
1427 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1428 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1429 vat_json_object_add_int (&node, "core", ntohl (td->id));
1430 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1433 vat_json_print (vam->ofp, &node);
1434 vat_json_free (&node);
1436 vam->retval = retval;
1437 vam->result_ready = 1;
1441 api_show_threads (vat_main_t * vam)
1443 vl_api_show_threads_t *mp;
1447 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1448 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1450 M (SHOW_THREADS, mp);
1458 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1460 u32 n_macs = ntohl (mp->n_macs);
1461 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1462 ntohl (mp->pid), mp->client_index, n_macs);
1464 for (i = 0; i < n_macs; i++)
1466 vl_api_mac_entry_t *mac = &mp->mac[i];
1467 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1468 i + 1, ntohl (mac->sw_if_index),
1469 format_ethernet_address, mac->mac_addr, mac->action);
1476 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1478 /* JSON output not supported */
1481 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1482 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1485 * Special-case: build the bridge domain table, maintain
1486 * the next bd id vbl.
1488 static void vl_api_bridge_domain_details_t_handler
1489 (vl_api_bridge_domain_details_t * mp)
1491 vat_main_t *vam = &vat_main;
1492 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1495 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1496 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1498 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1499 ntohl (mp->bd_id), mp->learn, mp->forward,
1500 mp->flood, ntohl (mp->bvi_sw_if_index),
1501 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1505 vl_api_bridge_domain_sw_if_t *sw_ifs;
1506 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1509 sw_ifs = mp->sw_if_details;
1510 for (i = 0; i < n_sw_ifs; i++)
1516 sw_if_index = ntohl (sw_ifs->sw_if_index);
1519 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1521 if ((u32) p->value[0] == sw_if_index)
1523 sw_if_name = (u8 *)(p->key);
1528 print (vam->ofp, "%7d %3d %s", sw_if_index,
1529 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1530 "sw_if_index not found!");
1537 static void vl_api_bridge_domain_details_t_handler_json
1538 (vl_api_bridge_domain_details_t * mp)
1540 vat_main_t *vam = &vat_main;
1541 vat_json_node_t *node, *array = NULL;
1542 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1544 if (VAT_JSON_ARRAY != vam->json_tree.type)
1546 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1547 vat_json_init_array (&vam->json_tree);
1549 node = vat_json_array_add (&vam->json_tree);
1551 vat_json_init_object (node);
1552 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1553 vat_json_object_add_uint (node, "flood", mp->flood);
1554 vat_json_object_add_uint (node, "forward", mp->forward);
1555 vat_json_object_add_uint (node, "learn", mp->learn);
1556 vat_json_object_add_uint (node, "bvi_sw_if_index",
1557 ntohl (mp->bvi_sw_if_index));
1558 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1559 array = vat_json_object_add (node, "sw_if");
1560 vat_json_init_array (array);
1566 vl_api_bridge_domain_sw_if_t *sw_ifs;
1569 sw_ifs = mp->sw_if_details;
1570 for (i = 0; i < n_sw_ifs; i++)
1572 node = vat_json_array_add (array);
1573 vat_json_init_object (node);
1574 vat_json_object_add_uint (node, "sw_if_index",
1575 ntohl (sw_ifs->sw_if_index));
1576 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1582 static void vl_api_control_ping_reply_t_handler
1583 (vl_api_control_ping_reply_t * mp)
1585 vat_main_t *vam = &vat_main;
1586 i32 retval = ntohl (mp->retval);
1587 if (vam->async_mode)
1589 vam->async_errors += (retval < 0);
1593 vam->retval = retval;
1594 vam->result_ready = 1;
1596 if (vam->socket_client_main)
1597 vam->socket_client_main->control_pings_outstanding--;
1600 static void vl_api_control_ping_reply_t_handler_json
1601 (vl_api_control_ping_reply_t * mp)
1603 vat_main_t *vam = &vat_main;
1604 i32 retval = ntohl (mp->retval);
1606 if (VAT_JSON_NONE != vam->json_tree.type)
1608 vat_json_print (vam->ofp, &vam->json_tree);
1609 vat_json_free (&vam->json_tree);
1610 vam->json_tree.type = VAT_JSON_NONE;
1615 vat_json_init_array (&vam->json_tree);
1616 vat_json_print (vam->ofp, &vam->json_tree);
1617 vam->json_tree.type = VAT_JSON_NONE;
1620 vam->retval = retval;
1621 vam->result_ready = 1;
1625 vl_api_bridge_domain_set_mac_age_reply_t_handler
1626 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1628 vat_main_t *vam = &vat_main;
1629 i32 retval = ntohl (mp->retval);
1630 if (vam->async_mode)
1632 vam->async_errors += (retval < 0);
1636 vam->retval = retval;
1637 vam->result_ready = 1;
1641 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1642 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1644 vat_main_t *vam = &vat_main;
1645 vat_json_node_t node;
1647 vat_json_init_object (&node);
1648 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1650 vat_json_print (vam->ofp, &node);
1651 vat_json_free (&node);
1653 vam->retval = ntohl (mp->retval);
1654 vam->result_ready = 1;
1658 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1660 vat_main_t *vam = &vat_main;
1661 i32 retval = ntohl (mp->retval);
1662 if (vam->async_mode)
1664 vam->async_errors += (retval < 0);
1668 vam->retval = retval;
1669 vam->result_ready = 1;
1673 static void vl_api_l2_flags_reply_t_handler_json
1674 (vl_api_l2_flags_reply_t * mp)
1676 vat_main_t *vam = &vat_main;
1677 vat_json_node_t node;
1679 vat_json_init_object (&node);
1680 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1681 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1682 ntohl (mp->resulting_feature_bitmap));
1684 vat_json_print (vam->ofp, &node);
1685 vat_json_free (&node);
1687 vam->retval = ntohl (mp->retval);
1688 vam->result_ready = 1;
1691 static void vl_api_bridge_flags_reply_t_handler
1692 (vl_api_bridge_flags_reply_t * mp)
1694 vat_main_t *vam = &vat_main;
1695 i32 retval = ntohl (mp->retval);
1696 if (vam->async_mode)
1698 vam->async_errors += (retval < 0);
1702 vam->retval = retval;
1703 vam->result_ready = 1;
1707 static void vl_api_bridge_flags_reply_t_handler_json
1708 (vl_api_bridge_flags_reply_t * mp)
1710 vat_main_t *vam = &vat_main;
1711 vat_json_node_t node;
1713 vat_json_init_object (&node);
1714 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1715 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1716 ntohl (mp->resulting_feature_bitmap));
1718 vat_json_print (vam->ofp, &node);
1719 vat_json_free (&node);
1721 vam->retval = ntohl (mp->retval);
1722 vam->result_ready = 1;
1726 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1728 vat_main_t *vam = &vat_main;
1729 i32 retval = ntohl (mp->retval);
1730 if (vam->async_mode)
1732 vam->async_errors += (retval < 0);
1736 vam->retval = retval;
1737 vam->sw_if_index = ntohl (mp->sw_if_index);
1738 vam->result_ready = 1;
1743 static void vl_api_tap_create_v2_reply_t_handler_json
1744 (vl_api_tap_create_v2_reply_t * mp)
1746 vat_main_t *vam = &vat_main;
1747 vat_json_node_t node;
1749 vat_json_init_object (&node);
1750 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1751 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1753 vat_json_print (vam->ofp, &node);
1754 vat_json_free (&node);
1756 vam->retval = ntohl (mp->retval);
1757 vam->result_ready = 1;
1762 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1764 vat_main_t *vam = &vat_main;
1765 i32 retval = ntohl (mp->retval);
1766 if (vam->async_mode)
1768 vam->async_errors += (retval < 0);
1772 vam->retval = retval;
1773 vam->result_ready = 1;
1777 static void vl_api_tap_delete_v2_reply_t_handler_json
1778 (vl_api_tap_delete_v2_reply_t * mp)
1780 vat_main_t *vam = &vat_main;
1781 vat_json_node_t node;
1783 vat_json_init_object (&node);
1784 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1786 vat_json_print (vam->ofp, &node);
1787 vat_json_free (&node);
1789 vam->retval = ntohl (mp->retval);
1790 vam->result_ready = 1;
1794 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1797 vat_main_t *vam = &vat_main;
1798 i32 retval = ntohl (mp->retval);
1799 if (vam->async_mode)
1801 vam->async_errors += (retval < 0);
1805 vam->retval = retval;
1806 vam->sw_if_index = ntohl (mp->sw_if_index);
1807 vam->result_ready = 1;
1811 static void vl_api_virtio_pci_create_reply_t_handler_json
1812 (vl_api_virtio_pci_create_reply_t * mp)
1814 vat_main_t *vam = &vat_main;
1815 vat_json_node_t node;
1817 vat_json_init_object (&node);
1818 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1819 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1821 vat_json_print (vam->ofp, &node);
1822 vat_json_free (&node);
1824 vam->retval = ntohl (mp->retval);
1825 vam->result_ready = 1;
1830 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1833 vat_main_t *vam = &vat_main;
1834 i32 retval = ntohl (mp->retval);
1835 if (vam->async_mode)
1837 vam->async_errors += (retval < 0);
1841 vam->retval = retval;
1842 vam->result_ready = 1;
1846 static void vl_api_virtio_pci_delete_reply_t_handler_json
1847 (vl_api_virtio_pci_delete_reply_t * mp)
1849 vat_main_t *vam = &vat_main;
1850 vat_json_node_t node;
1852 vat_json_init_object (&node);
1853 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1855 vat_json_print (vam->ofp, &node);
1856 vat_json_free (&node);
1858 vam->retval = ntohl (mp->retval);
1859 vam->result_ready = 1;
1863 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1865 vat_main_t *vam = &vat_main;
1866 i32 retval = ntohl (mp->retval);
1868 if (vam->async_mode)
1870 vam->async_errors += (retval < 0);
1874 vam->retval = retval;
1875 vam->sw_if_index = ntohl (mp->sw_if_index);
1876 vam->result_ready = 1;
1880 static void vl_api_bond_create_reply_t_handler_json
1881 (vl_api_bond_create_reply_t * mp)
1883 vat_main_t *vam = &vat_main;
1884 vat_json_node_t node;
1886 vat_json_init_object (&node);
1887 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1888 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1890 vat_json_print (vam->ofp, &node);
1891 vat_json_free (&node);
1893 vam->retval = ntohl (mp->retval);
1894 vam->result_ready = 1;
1898 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1900 vat_main_t *vam = &vat_main;
1901 i32 retval = ntohl (mp->retval);
1903 if (vam->async_mode)
1905 vam->async_errors += (retval < 0);
1909 vam->retval = retval;
1910 vam->result_ready = 1;
1914 static void vl_api_bond_delete_reply_t_handler_json
1915 (vl_api_bond_delete_reply_t * mp)
1917 vat_main_t *vam = &vat_main;
1918 vat_json_node_t node;
1920 vat_json_init_object (&node);
1921 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1923 vat_json_print (vam->ofp, &node);
1924 vat_json_free (&node);
1926 vam->retval = ntohl (mp->retval);
1927 vam->result_ready = 1;
1931 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1933 vat_main_t *vam = &vat_main;
1934 i32 retval = ntohl (mp->retval);
1936 if (vam->async_mode)
1938 vam->async_errors += (retval < 0);
1942 vam->retval = retval;
1943 vam->result_ready = 1;
1947 static void vl_api_bond_enslave_reply_t_handler_json
1948 (vl_api_bond_enslave_reply_t * mp)
1950 vat_main_t *vam = &vat_main;
1951 vat_json_node_t node;
1953 vat_json_init_object (&node);
1954 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1956 vat_json_print (vam->ofp, &node);
1957 vat_json_free (&node);
1959 vam->retval = ntohl (mp->retval);
1960 vam->result_ready = 1;
1964 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1967 vat_main_t *vam = &vat_main;
1968 i32 retval = ntohl (mp->retval);
1970 if (vam->async_mode)
1972 vam->async_errors += (retval < 0);
1976 vam->retval = retval;
1977 vam->result_ready = 1;
1981 static void vl_api_bond_detach_slave_reply_t_handler_json
1982 (vl_api_bond_detach_slave_reply_t * mp)
1984 vat_main_t *vam = &vat_main;
1985 vat_json_node_t node;
1987 vat_json_init_object (&node);
1988 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1990 vat_json_print (vam->ofp, &node);
1991 vat_json_free (&node);
1993 vam->retval = ntohl (mp->retval);
1994 vam->result_ready = 1;
1998 api_sw_interface_set_bond_weight (vat_main_t * vam)
2000 unformat_input_t *i = vam->input;
2001 vl_api_sw_interface_set_bond_weight_t *mp;
2002 u32 sw_if_index = ~0;
2004 u8 weight_enter = 0;
2007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2009 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2011 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2013 else if (unformat (i, "weight %u", &weight))
2019 if (sw_if_index == ~0)
2021 errmsg ("missing interface name or sw_if_index");
2024 if (weight_enter == 0)
2026 errmsg ("missing valid weight");
2030 /* Construct the API message */
2031 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2032 mp->sw_if_index = ntohl (sw_if_index);
2033 mp->weight = ntohl (weight);
2040 static void vl_api_sw_interface_bond_details_t_handler
2041 (vl_api_sw_interface_bond_details_t * mp)
2043 vat_main_t *vam = &vat_main;
2046 "%-16s %-12d %-12U %-13U %-14u %-14u",
2047 mp->interface_name, ntohl (mp->sw_if_index),
2048 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2049 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2052 static void vl_api_sw_interface_bond_details_t_handler_json
2053 (vl_api_sw_interface_bond_details_t * mp)
2055 vat_main_t *vam = &vat_main;
2056 vat_json_node_t *node = NULL;
2058 if (VAT_JSON_ARRAY != vam->json_tree.type)
2060 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2061 vat_json_init_array (&vam->json_tree);
2063 node = vat_json_array_add (&vam->json_tree);
2065 vat_json_init_object (node);
2066 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2067 vat_json_object_add_string_copy (node, "interface_name",
2068 mp->interface_name);
2069 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2070 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2071 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2072 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2076 api_sw_interface_bond_dump (vat_main_t * vam)
2078 vl_api_sw_interface_bond_dump_t *mp;
2079 vl_api_control_ping_t *mp_ping;
2083 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2084 "interface name", "sw_if_index", "mode", "load balance",
2085 "active slaves", "slaves");
2087 /* Get list of bond interfaces */
2088 M (SW_INTERFACE_BOND_DUMP, mp);
2091 /* Use a control ping for synchronization */
2092 MPING (CONTROL_PING, mp_ping);
2099 static void vl_api_sw_interface_slave_details_t_handler
2100 (vl_api_sw_interface_slave_details_t * mp)
2102 vat_main_t *vam = &vat_main;
2105 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2106 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2107 ntohl (mp->weight), mp->is_local_numa);
2110 static void vl_api_sw_interface_slave_details_t_handler_json
2111 (vl_api_sw_interface_slave_details_t * mp)
2113 vat_main_t *vam = &vat_main;
2114 vat_json_node_t *node = NULL;
2116 if (VAT_JSON_ARRAY != vam->json_tree.type)
2118 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2119 vat_json_init_array (&vam->json_tree);
2121 node = vat_json_array_add (&vam->json_tree);
2123 vat_json_init_object (node);
2124 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2125 vat_json_object_add_string_copy (node, "interface_name",
2126 mp->interface_name);
2127 vat_json_object_add_uint (node, "passive", mp->is_passive);
2128 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2129 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2130 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2134 api_sw_interface_slave_dump (vat_main_t * vam)
2136 unformat_input_t *i = vam->input;
2137 vl_api_sw_interface_slave_dump_t *mp;
2138 vl_api_control_ping_t *mp_ping;
2139 u32 sw_if_index = ~0;
2140 u8 sw_if_index_set = 0;
2143 /* Parse args required to build the message */
2144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2147 sw_if_index_set = 1;
2148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2149 sw_if_index_set = 1;
2154 if (sw_if_index_set == 0)
2156 errmsg ("missing vpp interface name. ");
2161 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2162 "slave interface name", "sw_if_index", "passive", "long_timeout",
2163 "weight", "local numa");
2165 /* Get list of bond interfaces */
2166 M (SW_INTERFACE_SLAVE_DUMP, mp);
2167 mp->sw_if_index = ntohl (sw_if_index);
2170 /* Use a control ping for synchronization */
2171 MPING (CONTROL_PING, mp_ping);
2178 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2179 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2181 vat_main_t *vam = &vat_main;
2182 i32 retval = ntohl (mp->retval);
2183 if (vam->async_mode)
2185 vam->async_errors += (retval < 0);
2189 vam->retval = retval;
2190 vam->sw_if_index = ntohl (mp->sw_if_index);
2191 vam->result_ready = 1;
2193 vam->regenerate_interface_table = 1;
2196 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2197 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2199 vat_main_t *vam = &vat_main;
2200 vat_json_node_t node;
2202 vat_json_init_object (&node);
2203 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2204 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2205 ntohl (mp->sw_if_index));
2207 vat_json_print (vam->ofp, &node);
2208 vat_json_free (&node);
2210 vam->retval = ntohl (mp->retval);
2211 vam->result_ready = 1;
2214 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2215 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2217 vat_main_t *vam = &vat_main;
2218 i32 retval = ntohl (mp->retval);
2219 if (vam->async_mode)
2221 vam->async_errors += (retval < 0);
2225 vam->retval = retval;
2226 vam->sw_if_index = ntohl (mp->sw_if_index);
2227 vam->result_ready = 1;
2231 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2232 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2234 vat_main_t *vam = &vat_main;
2235 vat_json_node_t node;
2237 vat_json_init_object (&node);
2238 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2239 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2241 vat_json_print (vam->ofp, &node);
2242 vat_json_free (&node);
2244 vam->retval = ntohl (mp->retval);
2245 vam->result_ready = 1;
2248 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2249 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2251 vat_main_t *vam = &vat_main;
2252 i32 retval = ntohl (mp->retval);
2253 if (vam->async_mode)
2255 vam->async_errors += (retval < 0);
2259 vam->retval = retval;
2260 vam->result_ready = 1;
2264 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2265 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2267 vat_main_t *vam = &vat_main;
2268 vat_json_node_t node;
2270 vat_json_init_object (&node);
2271 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2272 vat_json_object_add_uint (&node, "fwd_entry_index",
2273 clib_net_to_host_u32 (mp->fwd_entry_index));
2275 vat_json_print (vam->ofp, &node);
2276 vat_json_free (&node);
2278 vam->retval = ntohl (mp->retval);
2279 vam->result_ready = 1;
2283 format_lisp_transport_protocol (u8 * s, va_list * args)
2285 u32 proto = va_arg (*args, u32);
2290 return format (s, "udp");
2292 return format (s, "api");
2299 static void vl_api_one_get_transport_protocol_reply_t_handler
2300 (vl_api_one_get_transport_protocol_reply_t * mp)
2302 vat_main_t *vam = &vat_main;
2303 i32 retval = ntohl (mp->retval);
2304 if (vam->async_mode)
2306 vam->async_errors += (retval < 0);
2310 u32 proto = mp->protocol;
2311 print (vam->ofp, "Transport protocol: %U",
2312 format_lisp_transport_protocol, proto);
2313 vam->retval = retval;
2314 vam->result_ready = 1;
2318 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2319 (vl_api_one_get_transport_protocol_reply_t * mp)
2321 vat_main_t *vam = &vat_main;
2322 vat_json_node_t node;
2325 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2328 vat_json_init_object (&node);
2329 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2330 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2333 vat_json_print (vam->ofp, &node);
2334 vat_json_free (&node);
2336 vam->retval = ntohl (mp->retval);
2337 vam->result_ready = 1;
2340 static void vl_api_one_add_del_locator_set_reply_t_handler
2341 (vl_api_one_add_del_locator_set_reply_t * mp)
2343 vat_main_t *vam = &vat_main;
2344 i32 retval = ntohl (mp->retval);
2345 if (vam->async_mode)
2347 vam->async_errors += (retval < 0);
2351 vam->retval = retval;
2352 vam->result_ready = 1;
2356 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2357 (vl_api_one_add_del_locator_set_reply_t * mp)
2359 vat_main_t *vam = &vat_main;
2360 vat_json_node_t node;
2362 vat_json_init_object (&node);
2363 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2364 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2366 vat_json_print (vam->ofp, &node);
2367 vat_json_free (&node);
2369 vam->retval = ntohl (mp->retval);
2370 vam->result_ready = 1;
2373 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2374 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2376 vat_main_t *vam = &vat_main;
2377 i32 retval = ntohl (mp->retval);
2378 if (vam->async_mode)
2380 vam->async_errors += (retval < 0);
2384 vam->retval = retval;
2385 vam->sw_if_index = ntohl (mp->sw_if_index);
2386 vam->result_ready = 1;
2388 vam->regenerate_interface_table = 1;
2391 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2392 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2394 vat_main_t *vam = &vat_main;
2395 vat_json_node_t node;
2397 vat_json_init_object (&node);
2398 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2399 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2401 vat_json_print (vam->ofp, &node);
2402 vat_json_free (&node);
2404 vam->retval = ntohl (mp->retval);
2405 vam->result_ready = 1;
2408 static void vl_api_vxlan_offload_rx_reply_t_handler
2409 (vl_api_vxlan_offload_rx_reply_t * mp)
2411 vat_main_t *vam = &vat_main;
2412 i32 retval = ntohl (mp->retval);
2413 if (vam->async_mode)
2415 vam->async_errors += (retval < 0);
2419 vam->retval = retval;
2420 vam->result_ready = 1;
2424 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2425 (vl_api_vxlan_offload_rx_reply_t * mp)
2427 vat_main_t *vam = &vat_main;
2428 vat_json_node_t node;
2430 vat_json_init_object (&node);
2431 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2433 vat_json_print (vam->ofp, &node);
2434 vat_json_free (&node);
2436 vam->retval = ntohl (mp->retval);
2437 vam->result_ready = 1;
2440 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2441 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2443 vat_main_t *vam = &vat_main;
2444 i32 retval = ntohl (mp->retval);
2445 if (vam->async_mode)
2447 vam->async_errors += (retval < 0);
2451 vam->retval = retval;
2452 vam->sw_if_index = ntohl (mp->sw_if_index);
2453 vam->result_ready = 1;
2457 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2458 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2460 vat_main_t *vam = &vat_main;
2461 vat_json_node_t node;
2463 vat_json_init_object (&node);
2464 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2465 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2467 vat_json_print (vam->ofp, &node);
2468 vat_json_free (&node);
2470 vam->retval = ntohl (mp->retval);
2471 vam->result_ready = 1;
2474 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2475 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2477 vat_main_t *vam = &vat_main;
2478 i32 retval = ntohl (mp->retval);
2479 if (vam->async_mode)
2481 vam->async_errors += (retval < 0);
2485 vam->retval = retval;
2486 vam->sw_if_index = ntohl (mp->sw_if_index);
2487 vam->result_ready = 1;
2489 vam->regenerate_interface_table = 1;
2492 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2493 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2495 vat_main_t *vam = &vat_main;
2496 vat_json_node_t node;
2498 vat_json_init_object (&node);
2499 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2500 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2502 vat_json_print (vam->ofp, &node);
2503 vat_json_free (&node);
2505 vam->retval = ntohl (mp->retval);
2506 vam->result_ready = 1;
2509 static void vl_api_gre_tunnel_add_del_reply_t_handler
2510 (vl_api_gre_tunnel_add_del_reply_t * mp)
2512 vat_main_t *vam = &vat_main;
2513 i32 retval = ntohl (mp->retval);
2514 if (vam->async_mode)
2516 vam->async_errors += (retval < 0);
2520 vam->retval = retval;
2521 vam->sw_if_index = ntohl (mp->sw_if_index);
2522 vam->result_ready = 1;
2526 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2527 (vl_api_gre_tunnel_add_del_reply_t * mp)
2529 vat_main_t *vam = &vat_main;
2530 vat_json_node_t node;
2532 vat_json_init_object (&node);
2533 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2534 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2536 vat_json_print (vam->ofp, &node);
2537 vat_json_free (&node);
2539 vam->retval = ntohl (mp->retval);
2540 vam->result_ready = 1;
2543 static void vl_api_create_vhost_user_if_reply_t_handler
2544 (vl_api_create_vhost_user_if_reply_t * mp)
2546 vat_main_t *vam = &vat_main;
2547 i32 retval = ntohl (mp->retval);
2548 if (vam->async_mode)
2550 vam->async_errors += (retval < 0);
2554 vam->retval = retval;
2555 vam->sw_if_index = ntohl (mp->sw_if_index);
2556 vam->result_ready = 1;
2558 vam->regenerate_interface_table = 1;
2561 static void vl_api_create_vhost_user_if_reply_t_handler_json
2562 (vl_api_create_vhost_user_if_reply_t * mp)
2564 vat_main_t *vam = &vat_main;
2565 vat_json_node_t node;
2567 vat_json_init_object (&node);
2568 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2569 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2571 vat_json_print (vam->ofp, &node);
2572 vat_json_free (&node);
2574 vam->retval = ntohl (mp->retval);
2575 vam->result_ready = 1;
2578 static void vl_api_ip_address_details_t_handler
2579 (vl_api_ip_address_details_t * mp)
2581 vat_main_t *vam = &vat_main;
2582 static ip_address_details_t empty_ip_address_details = { {0} };
2583 ip_address_details_t *address = NULL;
2584 ip_details_t *current_ip_details = NULL;
2585 ip_details_t *details = NULL;
2587 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2589 if (!details || vam->current_sw_if_index >= vec_len (details)
2590 || !details[vam->current_sw_if_index].present)
2592 errmsg ("ip address details arrived but not stored");
2593 errmsg ("ip_dump should be called first");
2597 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2599 #define addresses (current_ip_details->addr)
2601 vec_validate_init_empty (addresses, vec_len (addresses),
2602 empty_ip_address_details);
2604 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2606 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2607 address->prefix_length = mp->prefix.len;
2611 static void vl_api_ip_address_details_t_handler_json
2612 (vl_api_ip_address_details_t * mp)
2614 vat_main_t *vam = &vat_main;
2615 vat_json_node_t *node = NULL;
2617 if (VAT_JSON_ARRAY != vam->json_tree.type)
2619 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2620 vat_json_init_array (&vam->json_tree);
2622 node = vat_json_array_add (&vam->json_tree);
2624 vat_json_init_object (node);
2625 vat_json_object_add_prefix (node, &mp->prefix);
2629 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2631 vat_main_t *vam = &vat_main;
2632 static ip_details_t empty_ip_details = { 0 };
2633 ip_details_t *ip = NULL;
2634 u32 sw_if_index = ~0;
2636 sw_if_index = ntohl (mp->sw_if_index);
2638 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2639 sw_if_index, empty_ip_details);
2641 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2648 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2650 vat_main_t *vam = &vat_main;
2652 if (VAT_JSON_ARRAY != vam->json_tree.type)
2654 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2655 vat_json_init_array (&vam->json_tree);
2657 vat_json_array_add_uint (&vam->json_tree,
2658 clib_net_to_host_u32 (mp->sw_if_index));
2661 static void vl_api_get_first_msg_id_reply_t_handler
2662 (vl_api_get_first_msg_id_reply_t * mp)
2664 vat_main_t *vam = &vat_main;
2665 i32 retval = ntohl (mp->retval);
2667 if (vam->async_mode)
2669 vam->async_errors += (retval < 0);
2673 vam->retval = retval;
2674 vam->result_ready = 1;
2678 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2682 static void vl_api_get_first_msg_id_reply_t_handler_json
2683 (vl_api_get_first_msg_id_reply_t * mp)
2685 vat_main_t *vam = &vat_main;
2686 vat_json_node_t node;
2688 vat_json_init_object (&node);
2689 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2690 vat_json_object_add_uint (&node, "first_msg_id",
2691 (uint) ntohs (mp->first_msg_id));
2693 vat_json_print (vam->ofp, &node);
2694 vat_json_free (&node);
2696 vam->retval = ntohl (mp->retval);
2697 vam->result_ready = 1;
2700 static void vl_api_get_node_graph_reply_t_handler
2701 (vl_api_get_node_graph_reply_t * mp)
2703 vat_main_t *vam = &vat_main;
2704 i32 retval = ntohl (mp->retval);
2705 u8 *pvt_copy, *reply;
2710 if (vam->async_mode)
2712 vam->async_errors += (retval < 0);
2716 vam->retval = retval;
2717 vam->result_ready = 1;
2720 /* "Should never happen..." */
2724 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2725 pvt_copy = vec_dup (reply);
2727 /* Toss the shared-memory original... */
2728 oldheap = vl_msg_push_heap ();
2732 vl_msg_pop_heap (oldheap);
2734 if (vam->graph_nodes)
2736 hash_free (vam->graph_node_index_by_name);
2738 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2740 node = vam->graph_nodes[0][i];
2741 vec_free (node->name);
2742 vec_free (node->next_nodes);
2745 vec_free (vam->graph_nodes[0]);
2746 vec_free (vam->graph_nodes);
2749 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2750 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2751 vec_free (pvt_copy);
2753 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2755 node = vam->graph_nodes[0][i];
2756 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2760 static void vl_api_get_node_graph_reply_t_handler_json
2761 (vl_api_get_node_graph_reply_t * mp)
2763 vat_main_t *vam = &vat_main;
2765 vat_json_node_t node;
2768 /* $$$$ make this real? */
2769 vat_json_init_object (&node);
2770 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2771 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2773 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2775 /* Toss the shared-memory original... */
2776 oldheap = vl_msg_push_heap ();
2780 vl_msg_pop_heap (oldheap);
2782 vat_json_print (vam->ofp, &node);
2783 vat_json_free (&node);
2785 vam->retval = ntohl (mp->retval);
2786 vam->result_ready = 1;
2790 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2792 vat_main_t *vam = &vat_main;
2797 s = format (s, "%=16d%=16d%=16d",
2798 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2802 s = format (s, "%=16U%=16d%=16d",
2803 mp->is_ipv6 ? format_ip6_address :
2805 mp->ip_address, mp->priority, mp->weight);
2808 print (vam->ofp, "%v", s);
2813 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2815 vat_main_t *vam = &vat_main;
2816 vat_json_node_t *node = NULL;
2817 struct in6_addr ip6;
2820 if (VAT_JSON_ARRAY != vam->json_tree.type)
2822 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2823 vat_json_init_array (&vam->json_tree);
2825 node = vat_json_array_add (&vam->json_tree);
2826 vat_json_init_object (node);
2828 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2829 vat_json_object_add_uint (node, "priority", mp->priority);
2830 vat_json_object_add_uint (node, "weight", mp->weight);
2833 vat_json_object_add_uint (node, "sw_if_index",
2834 clib_net_to_host_u32 (mp->sw_if_index));
2839 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2840 vat_json_object_add_ip6 (node, "address", ip6);
2844 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2845 vat_json_object_add_ip4 (node, "address", ip4);
2851 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2854 vat_main_t *vam = &vat_main;
2857 ls_name = format (0, "%s", mp->ls_name);
2859 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2865 vl_api_one_locator_set_details_t_handler_json
2866 (vl_api_one_locator_set_details_t * mp)
2868 vat_main_t *vam = &vat_main;
2869 vat_json_node_t *node = 0;
2872 ls_name = format (0, "%s", mp->ls_name);
2873 vec_add1 (ls_name, 0);
2875 if (VAT_JSON_ARRAY != vam->json_tree.type)
2877 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2878 vat_json_init_array (&vam->json_tree);
2880 node = vat_json_array_add (&vam->json_tree);
2882 vat_json_init_object (node);
2883 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2884 vat_json_object_add_uint (node, "ls_index",
2885 clib_net_to_host_u32 (mp->ls_index));
2893 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2896 unformat_nsh_address (unformat_input_t * input, va_list * args)
2898 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2899 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2903 format_nsh_address_vat (u8 * s, va_list * args)
2905 nsh_t *a = va_arg (*args, nsh_t *);
2906 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2910 format_lisp_flat_eid (u8 * s, va_list * args)
2912 u32 type = va_arg (*args, u32);
2913 u8 *eid = va_arg (*args, u8 *);
2914 u32 eid_len = va_arg (*args, u32);
2919 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2921 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2923 return format (s, "%U", format_ethernet_address, eid);
2925 return format (s, "%U", format_nsh_address_vat, eid);
2931 format_lisp_eid_vat (u8 * s, va_list * args)
2933 u32 type = va_arg (*args, u32);
2934 u8 *eid = va_arg (*args, u8 *);
2935 u32 eid_len = va_arg (*args, u32);
2936 u8 *seid = va_arg (*args, u8 *);
2937 u32 seid_len = va_arg (*args, u32);
2938 u32 is_src_dst = va_arg (*args, u32);
2941 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2943 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2949 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2951 vat_main_t *vam = &vat_main;
2952 u8 *s = 0, *eid = 0;
2954 if (~0 == mp->locator_set_index)
2955 s = format (0, "action: %d", mp->action);
2957 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2959 eid = format (0, "%U", format_lisp_eid_vat,
2963 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2966 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2967 clib_net_to_host_u32 (mp->vni),
2969 mp->is_local ? "local" : "remote",
2970 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2971 clib_net_to_host_u16 (mp->key_id), mp->key);
2978 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2981 vat_main_t *vam = &vat_main;
2982 vat_json_node_t *node = 0;
2985 if (VAT_JSON_ARRAY != vam->json_tree.type)
2987 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2988 vat_json_init_array (&vam->json_tree);
2990 node = vat_json_array_add (&vam->json_tree);
2992 vat_json_init_object (node);
2993 if (~0 == mp->locator_set_index)
2994 vat_json_object_add_uint (node, "action", mp->action);
2996 vat_json_object_add_uint (node, "locator_set_index",
2997 clib_net_to_host_u32 (mp->locator_set_index));
2999 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3000 if (mp->eid_type == 3)
3002 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3003 vat_json_init_object (nsh_json);
3004 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3005 vat_json_object_add_uint (nsh_json, "spi",
3006 clib_net_to_host_u32 (nsh->spi));
3007 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3011 eid = format (0, "%U", format_lisp_eid_vat,
3015 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3017 vat_json_object_add_string_copy (node, "eid", eid);
3020 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3021 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3022 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3026 vat_json_object_add_uint (node, "key_id",
3027 clib_net_to_host_u16 (mp->key_id));
3028 vat_json_object_add_string_copy (node, "key", mp->key);
3033 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3035 vat_main_t *vam = &vat_main;
3036 u8 *seid = 0, *deid = 0;
3037 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3039 deid = format (0, "%U", format_lisp_eid_vat,
3040 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3042 seid = format (0, "%U", format_lisp_eid_vat,
3043 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3049 format_ip_address_fcn = format_ip4_address;
3051 format_ip_address_fcn = format_ip6_address;
3054 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3055 clib_net_to_host_u32 (mp->vni),
3057 format_ip_address_fcn, mp->lloc,
3058 format_ip_address_fcn, mp->rloc,
3059 clib_net_to_host_u32 (mp->pkt_count),
3060 clib_net_to_host_u32 (mp->bytes));
3067 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3069 struct in6_addr ip6;
3071 vat_main_t *vam = &vat_main;
3072 vat_json_node_t *node = 0;
3073 u8 *deid = 0, *seid = 0;
3075 if (VAT_JSON_ARRAY != vam->json_tree.type)
3077 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3078 vat_json_init_array (&vam->json_tree);
3080 node = vat_json_array_add (&vam->json_tree);
3082 vat_json_init_object (node);
3083 deid = format (0, "%U", format_lisp_eid_vat,
3084 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3086 seid = format (0, "%U", format_lisp_eid_vat,
3087 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3092 vat_json_object_add_string_copy (node, "seid", seid);
3093 vat_json_object_add_string_copy (node, "deid", deid);
3094 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3098 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3099 vat_json_object_add_ip4 (node, "lloc", ip4);
3100 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3101 vat_json_object_add_ip4 (node, "rloc", ip4);
3105 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3106 vat_json_object_add_ip6 (node, "lloc", ip6);
3107 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3108 vat_json_object_add_ip6 (node, "rloc", ip6);
3110 vat_json_object_add_uint (node, "pkt_count",
3111 clib_net_to_host_u32 (mp->pkt_count));
3112 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3119 vl_api_one_eid_table_map_details_t_handler
3120 (vl_api_one_eid_table_map_details_t * mp)
3122 vat_main_t *vam = &vat_main;
3124 u8 *line = format (0, "%=10d%=10d",
3125 clib_net_to_host_u32 (mp->vni),
3126 clib_net_to_host_u32 (mp->dp_table));
3127 print (vam->ofp, "%v", line);
3132 vl_api_one_eid_table_map_details_t_handler_json
3133 (vl_api_one_eid_table_map_details_t * mp)
3135 vat_main_t *vam = &vat_main;
3136 vat_json_node_t *node = NULL;
3138 if (VAT_JSON_ARRAY != vam->json_tree.type)
3140 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3141 vat_json_init_array (&vam->json_tree);
3143 node = vat_json_array_add (&vam->json_tree);
3144 vat_json_init_object (node);
3145 vat_json_object_add_uint (node, "dp_table",
3146 clib_net_to_host_u32 (mp->dp_table));
3147 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3151 vl_api_one_eid_table_vni_details_t_handler
3152 (vl_api_one_eid_table_vni_details_t * mp)
3154 vat_main_t *vam = &vat_main;
3156 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3157 print (vam->ofp, "%v", line);
3162 vl_api_one_eid_table_vni_details_t_handler_json
3163 (vl_api_one_eid_table_vni_details_t * mp)
3165 vat_main_t *vam = &vat_main;
3166 vat_json_node_t *node = NULL;
3168 if (VAT_JSON_ARRAY != vam->json_tree.type)
3170 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3171 vat_json_init_array (&vam->json_tree);
3173 node = vat_json_array_add (&vam->json_tree);
3174 vat_json_init_object (node);
3175 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3179 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3180 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3182 vat_main_t *vam = &vat_main;
3183 int retval = clib_net_to_host_u32 (mp->retval);
3185 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3186 print (vam->ofp, "fallback threshold value: %d", mp->value);
3188 vam->retval = retval;
3189 vam->result_ready = 1;
3193 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3194 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3196 vat_main_t *vam = &vat_main;
3197 vat_json_node_t _node, *node = &_node;
3198 int retval = clib_net_to_host_u32 (mp->retval);
3200 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3201 vat_json_init_object (node);
3202 vat_json_object_add_uint (node, "value", mp->value);
3204 vat_json_print (vam->ofp, node);
3205 vat_json_free (node);
3207 vam->retval = retval;
3208 vam->result_ready = 1;
3212 vl_api_show_one_map_register_state_reply_t_handler
3213 (vl_api_show_one_map_register_state_reply_t * mp)
3215 vat_main_t *vam = &vat_main;
3216 int retval = clib_net_to_host_u32 (mp->retval);
3218 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3220 vam->retval = retval;
3221 vam->result_ready = 1;
3225 vl_api_show_one_map_register_state_reply_t_handler_json
3226 (vl_api_show_one_map_register_state_reply_t * mp)
3228 vat_main_t *vam = &vat_main;
3229 vat_json_node_t _node, *node = &_node;
3230 int retval = clib_net_to_host_u32 (mp->retval);
3232 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3234 vat_json_init_object (node);
3235 vat_json_object_add_string_copy (node, "state", s);
3237 vat_json_print (vam->ofp, node);
3238 vat_json_free (node);
3240 vam->retval = retval;
3241 vam->result_ready = 1;
3246 vl_api_show_one_rloc_probe_state_reply_t_handler
3247 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3249 vat_main_t *vam = &vat_main;
3250 int retval = clib_net_to_host_u32 (mp->retval);
3255 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3257 vam->retval = retval;
3258 vam->result_ready = 1;
3262 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3263 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3265 vat_main_t *vam = &vat_main;
3266 vat_json_node_t _node, *node = &_node;
3267 int retval = clib_net_to_host_u32 (mp->retval);
3269 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3270 vat_json_init_object (node);
3271 vat_json_object_add_string_copy (node, "state", s);
3273 vat_json_print (vam->ofp, node);
3274 vat_json_free (node);
3276 vam->retval = retval;
3277 vam->result_ready = 1;
3282 vl_api_show_one_stats_enable_disable_reply_t_handler
3283 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3285 vat_main_t *vam = &vat_main;
3286 int retval = clib_net_to_host_u32 (mp->retval);
3291 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3293 vam->retval = retval;
3294 vam->result_ready = 1;
3298 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3299 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3301 vat_main_t *vam = &vat_main;
3302 vat_json_node_t _node, *node = &_node;
3303 int retval = clib_net_to_host_u32 (mp->retval);
3305 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3306 vat_json_init_object (node);
3307 vat_json_object_add_string_copy (node, "state", s);
3309 vat_json_print (vam->ofp, node);
3310 vat_json_free (node);
3312 vam->retval = retval;
3313 vam->result_ready = 1;
3318 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3320 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3321 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3322 e->vni = clib_net_to_host_u32 (e->vni);
3326 gpe_fwd_entries_get_reply_t_net_to_host
3327 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3331 mp->count = clib_net_to_host_u32 (mp->count);
3332 for (i = 0; i < mp->count; i++)
3334 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3339 format_gpe_encap_mode (u8 * s, va_list * args)
3341 u32 mode = va_arg (*args, u32);
3346 return format (s, "lisp");
3348 return format (s, "vxlan");
3354 vl_api_gpe_get_encap_mode_reply_t_handler
3355 (vl_api_gpe_get_encap_mode_reply_t * mp)
3357 vat_main_t *vam = &vat_main;
3359 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3360 vam->retval = ntohl (mp->retval);
3361 vam->result_ready = 1;
3365 vl_api_gpe_get_encap_mode_reply_t_handler_json
3366 (vl_api_gpe_get_encap_mode_reply_t * mp)
3368 vat_main_t *vam = &vat_main;
3369 vat_json_node_t node;
3371 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3372 vec_add1 (encap_mode, 0);
3374 vat_json_init_object (&node);
3375 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3377 vec_free (encap_mode);
3378 vat_json_print (vam->ofp, &node);
3379 vat_json_free (&node);
3381 vam->retval = ntohl (mp->retval);
3382 vam->result_ready = 1;
3386 vl_api_gpe_fwd_entry_path_details_t_handler
3387 (vl_api_gpe_fwd_entry_path_details_t * mp)
3389 vat_main_t *vam = &vat_main;
3390 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3392 if (mp->lcl_loc.is_ip4)
3393 format_ip_address_fcn = format_ip4_address;
3395 format_ip_address_fcn = format_ip6_address;
3397 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3398 format_ip_address_fcn, &mp->lcl_loc,
3399 format_ip_address_fcn, &mp->rmt_loc);
3403 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3405 struct in6_addr ip6;
3410 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3411 vat_json_object_add_ip4 (n, "address", ip4);
3415 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3416 vat_json_object_add_ip6 (n, "address", ip6);
3418 vat_json_object_add_uint (n, "weight", loc->weight);
3422 vl_api_gpe_fwd_entry_path_details_t_handler_json
3423 (vl_api_gpe_fwd_entry_path_details_t * mp)
3425 vat_main_t *vam = &vat_main;
3426 vat_json_node_t *node = NULL;
3427 vat_json_node_t *loc_node;
3429 if (VAT_JSON_ARRAY != vam->json_tree.type)
3431 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3432 vat_json_init_array (&vam->json_tree);
3434 node = vat_json_array_add (&vam->json_tree);
3435 vat_json_init_object (node);
3437 loc_node = vat_json_object_add (node, "local_locator");
3438 vat_json_init_object (loc_node);
3439 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3441 loc_node = vat_json_object_add (node, "remote_locator");
3442 vat_json_init_object (loc_node);
3443 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3447 vl_api_gpe_fwd_entries_get_reply_t_handler
3448 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3450 vat_main_t *vam = &vat_main;
3452 int retval = clib_net_to_host_u32 (mp->retval);
3453 vl_api_gpe_fwd_entry_t *e;
3458 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3460 for (i = 0; i < mp->count; i++)
3462 e = &mp->entries[i];
3463 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3464 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3465 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3469 vam->retval = retval;
3470 vam->result_ready = 1;
3474 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3475 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3478 vat_main_t *vam = &vat_main;
3479 vat_json_node_t *e = 0, root;
3481 int retval = clib_net_to_host_u32 (mp->retval);
3482 vl_api_gpe_fwd_entry_t *fwd;
3487 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3488 vat_json_init_array (&root);
3490 for (i = 0; i < mp->count; i++)
3492 e = vat_json_array_add (&root);
3493 fwd = &mp->entries[i];
3495 vat_json_init_object (e);
3496 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3497 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3498 vat_json_object_add_int (e, "vni", fwd->vni);
3499 vat_json_object_add_int (e, "action", fwd->action);
3501 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3502 fwd->leid_prefix_len);
3504 vat_json_object_add_string_copy (e, "leid", s);
3507 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3508 fwd->reid_prefix_len);
3510 vat_json_object_add_string_copy (e, "reid", s);
3514 vat_json_print (vam->ofp, &root);
3515 vat_json_free (&root);
3518 vam->retval = retval;
3519 vam->result_ready = 1;
3523 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3524 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3526 vat_main_t *vam = &vat_main;
3528 int retval = clib_net_to_host_u32 (mp->retval);
3529 vl_api_gpe_native_fwd_rpath_t *r;
3534 n = clib_net_to_host_u32 (mp->count);
3536 for (i = 0; i < n; i++)
3538 r = &mp->entries[i];
3539 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3540 clib_net_to_host_u32 (r->fib_index),
3541 clib_net_to_host_u32 (r->nh_sw_if_index),
3542 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3546 vam->retval = retval;
3547 vam->result_ready = 1;
3551 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3552 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3554 vat_main_t *vam = &vat_main;
3555 vat_json_node_t root, *e;
3557 int retval = clib_net_to_host_u32 (mp->retval);
3558 vl_api_gpe_native_fwd_rpath_t *r;
3564 n = clib_net_to_host_u32 (mp->count);
3565 vat_json_init_array (&root);
3567 for (i = 0; i < n; i++)
3569 e = vat_json_array_add (&root);
3570 vat_json_init_object (e);
3571 r = &mp->entries[i];
3573 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3576 vat_json_object_add_string_copy (e, "ip4", s);
3579 vat_json_object_add_uint (e, "fib_index",
3580 clib_net_to_host_u32 (r->fib_index));
3581 vat_json_object_add_uint (e, "nh_sw_if_index",
3582 clib_net_to_host_u32 (r->nh_sw_if_index));
3585 vat_json_print (vam->ofp, &root);
3586 vat_json_free (&root);
3589 vam->retval = retval;
3590 vam->result_ready = 1;
3594 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3595 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3597 vat_main_t *vam = &vat_main;
3599 int retval = clib_net_to_host_u32 (mp->retval);
3604 n = clib_net_to_host_u32 (mp->count);
3606 for (i = 0; i < n; i++)
3607 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3610 vam->retval = retval;
3611 vam->result_ready = 1;
3615 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3616 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3618 vat_main_t *vam = &vat_main;
3619 vat_json_node_t root;
3621 int retval = clib_net_to_host_u32 (mp->retval);
3626 n = clib_net_to_host_u32 (mp->count);
3627 vat_json_init_array (&root);
3629 for (i = 0; i < n; i++)
3630 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3632 vat_json_print (vam->ofp, &root);
3633 vat_json_free (&root);
3636 vam->retval = retval;
3637 vam->result_ready = 1;
3641 vl_api_one_ndp_entries_get_reply_t_handler
3642 (vl_api_one_ndp_entries_get_reply_t * mp)
3644 vat_main_t *vam = &vat_main;
3646 int retval = clib_net_to_host_u32 (mp->retval);
3651 n = clib_net_to_host_u32 (mp->count);
3653 for (i = 0; i < n; i++)
3654 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3655 format_ethernet_address, mp->entries[i].mac);
3658 vam->retval = retval;
3659 vam->result_ready = 1;
3663 vl_api_one_ndp_entries_get_reply_t_handler_json
3664 (vl_api_one_ndp_entries_get_reply_t * mp)
3667 vat_main_t *vam = &vat_main;
3668 vat_json_node_t *e = 0, root;
3670 int retval = clib_net_to_host_u32 (mp->retval);
3671 vl_api_one_ndp_entry_t *arp_entry;
3676 n = clib_net_to_host_u32 (mp->count);
3677 vat_json_init_array (&root);
3679 for (i = 0; i < n; i++)
3681 e = vat_json_array_add (&root);
3682 arp_entry = &mp->entries[i];
3684 vat_json_init_object (e);
3685 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3688 vat_json_object_add_string_copy (e, "mac", s);
3691 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3693 vat_json_object_add_string_copy (e, "ip6", s);
3697 vat_json_print (vam->ofp, &root);
3698 vat_json_free (&root);
3701 vam->retval = retval;
3702 vam->result_ready = 1;
3706 vl_api_one_l2_arp_entries_get_reply_t_handler
3707 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3709 vat_main_t *vam = &vat_main;
3711 int retval = clib_net_to_host_u32 (mp->retval);
3716 n = clib_net_to_host_u32 (mp->count);
3718 for (i = 0; i < n; i++)
3719 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3720 format_ethernet_address, mp->entries[i].mac);
3723 vam->retval = retval;
3724 vam->result_ready = 1;
3728 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3729 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3732 vat_main_t *vam = &vat_main;
3733 vat_json_node_t *e = 0, root;
3735 int retval = clib_net_to_host_u32 (mp->retval);
3736 vl_api_one_l2_arp_entry_t *arp_entry;
3741 n = clib_net_to_host_u32 (mp->count);
3742 vat_json_init_array (&root);
3744 for (i = 0; i < n; i++)
3746 e = vat_json_array_add (&root);
3747 arp_entry = &mp->entries[i];
3749 vat_json_init_object (e);
3750 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3753 vat_json_object_add_string_copy (e, "mac", s);
3756 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3758 vat_json_object_add_string_copy (e, "ip4", s);
3762 vat_json_print (vam->ofp, &root);
3763 vat_json_free (&root);
3766 vam->retval = retval;
3767 vam->result_ready = 1;
3771 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3773 vat_main_t *vam = &vat_main;
3775 int retval = clib_net_to_host_u32 (mp->retval);
3780 n = clib_net_to_host_u32 (mp->count);
3782 for (i = 0; i < n; i++)
3784 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3788 vam->retval = retval;
3789 vam->result_ready = 1;
3793 vl_api_one_ndp_bd_get_reply_t_handler_json
3794 (vl_api_one_ndp_bd_get_reply_t * mp)
3796 vat_main_t *vam = &vat_main;
3797 vat_json_node_t root;
3799 int retval = clib_net_to_host_u32 (mp->retval);
3804 n = clib_net_to_host_u32 (mp->count);
3805 vat_json_init_array (&root);
3807 for (i = 0; i < n; i++)
3809 vat_json_array_add_uint (&root,
3810 clib_net_to_host_u32 (mp->bridge_domains[i]));
3813 vat_json_print (vam->ofp, &root);
3814 vat_json_free (&root);
3817 vam->retval = retval;
3818 vam->result_ready = 1;
3822 vl_api_one_l2_arp_bd_get_reply_t_handler
3823 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3825 vat_main_t *vam = &vat_main;
3827 int retval = clib_net_to_host_u32 (mp->retval);
3832 n = clib_net_to_host_u32 (mp->count);
3834 for (i = 0; i < n; i++)
3836 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3840 vam->retval = retval;
3841 vam->result_ready = 1;
3845 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3846 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3848 vat_main_t *vam = &vat_main;
3849 vat_json_node_t root;
3851 int retval = clib_net_to_host_u32 (mp->retval);
3856 n = clib_net_to_host_u32 (mp->count);
3857 vat_json_init_array (&root);
3859 for (i = 0; i < n; i++)
3861 vat_json_array_add_uint (&root,
3862 clib_net_to_host_u32 (mp->bridge_domains[i]));
3865 vat_json_print (vam->ofp, &root);
3866 vat_json_free (&root);
3869 vam->retval = retval;
3870 vam->result_ready = 1;
3874 vl_api_one_adjacencies_get_reply_t_handler
3875 (vl_api_one_adjacencies_get_reply_t * mp)
3877 vat_main_t *vam = &vat_main;
3879 int retval = clib_net_to_host_u32 (mp->retval);
3880 vl_api_one_adjacency_t *a;
3885 n = clib_net_to_host_u32 (mp->count);
3887 for (i = 0; i < n; i++)
3889 a = &mp->adjacencies[i];
3890 print (vam->ofp, "%U %40U",
3891 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3892 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3896 vam->retval = retval;
3897 vam->result_ready = 1;
3901 vl_api_one_adjacencies_get_reply_t_handler_json
3902 (vl_api_one_adjacencies_get_reply_t * mp)
3905 vat_main_t *vam = &vat_main;
3906 vat_json_node_t *e = 0, root;
3908 int retval = clib_net_to_host_u32 (mp->retval);
3909 vl_api_one_adjacency_t *a;
3914 n = clib_net_to_host_u32 (mp->count);
3915 vat_json_init_array (&root);
3917 for (i = 0; i < n; i++)
3919 e = vat_json_array_add (&root);
3920 a = &mp->adjacencies[i];
3922 vat_json_init_object (e);
3923 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3924 a->leid_prefix_len);
3926 vat_json_object_add_string_copy (e, "leid", s);
3929 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3930 a->reid_prefix_len);
3932 vat_json_object_add_string_copy (e, "reid", s);
3936 vat_json_print (vam->ofp, &root);
3937 vat_json_free (&root);
3940 vam->retval = retval;
3941 vam->result_ready = 1;
3945 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3947 vat_main_t *vam = &vat_main;
3949 print (vam->ofp, "%=20U",
3950 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3955 vl_api_one_map_server_details_t_handler_json
3956 (vl_api_one_map_server_details_t * mp)
3958 vat_main_t *vam = &vat_main;
3959 vat_json_node_t *node = NULL;
3960 struct in6_addr ip6;
3963 if (VAT_JSON_ARRAY != vam->json_tree.type)
3965 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3966 vat_json_init_array (&vam->json_tree);
3968 node = vat_json_array_add (&vam->json_tree);
3970 vat_json_init_object (node);
3973 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3974 vat_json_object_add_ip6 (node, "map-server", ip6);
3978 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3979 vat_json_object_add_ip4 (node, "map-server", ip4);
3984 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3987 vat_main_t *vam = &vat_main;
3989 print (vam->ofp, "%=20U",
3990 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3995 vl_api_one_map_resolver_details_t_handler_json
3996 (vl_api_one_map_resolver_details_t * mp)
3998 vat_main_t *vam = &vat_main;
3999 vat_json_node_t *node = NULL;
4000 struct in6_addr ip6;
4003 if (VAT_JSON_ARRAY != vam->json_tree.type)
4005 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4006 vat_json_init_array (&vam->json_tree);
4008 node = vat_json_array_add (&vam->json_tree);
4010 vat_json_init_object (node);
4013 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4014 vat_json_object_add_ip6 (node, "map resolver", ip6);
4018 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4019 vat_json_object_add_ip4 (node, "map resolver", ip4);
4024 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4026 vat_main_t *vam = &vat_main;
4027 i32 retval = ntohl (mp->retval);
4031 print (vam->ofp, "feature: %s\ngpe: %s",
4032 mp->feature_status ? "enabled" : "disabled",
4033 mp->gpe_status ? "enabled" : "disabled");
4036 vam->retval = retval;
4037 vam->result_ready = 1;
4041 vl_api_show_one_status_reply_t_handler_json
4042 (vl_api_show_one_status_reply_t * mp)
4044 vat_main_t *vam = &vat_main;
4045 vat_json_node_t node;
4046 u8 *gpe_status = NULL;
4047 u8 *feature_status = NULL;
4049 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4050 feature_status = format (0, "%s",
4051 mp->feature_status ? "enabled" : "disabled");
4052 vec_add1 (gpe_status, 0);
4053 vec_add1 (feature_status, 0);
4055 vat_json_init_object (&node);
4056 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4057 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4059 vec_free (gpe_status);
4060 vec_free (feature_status);
4062 vat_json_print (vam->ofp, &node);
4063 vat_json_free (&node);
4065 vam->retval = ntohl (mp->retval);
4066 vam->result_ready = 1;
4070 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4071 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4073 vat_main_t *vam = &vat_main;
4074 i32 retval = ntohl (mp->retval);
4078 print (vam->ofp, "%=20s", mp->locator_set_name);
4081 vam->retval = retval;
4082 vam->result_ready = 1;
4086 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4087 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4089 vat_main_t *vam = &vat_main;
4090 vat_json_node_t *node = NULL;
4092 if (VAT_JSON_ARRAY != vam->json_tree.type)
4094 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4095 vat_json_init_array (&vam->json_tree);
4097 node = vat_json_array_add (&vam->json_tree);
4099 vat_json_init_object (node);
4100 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4102 vat_json_print (vam->ofp, node);
4103 vat_json_free (node);
4105 vam->retval = ntohl (mp->retval);
4106 vam->result_ready = 1;
4110 format_lisp_map_request_mode (u8 * s, va_list * args)
4112 u32 mode = va_arg (*args, u32);
4117 return format (0, "dst-only");
4119 return format (0, "src-dst");
4125 vl_api_show_one_map_request_mode_reply_t_handler
4126 (vl_api_show_one_map_request_mode_reply_t * mp)
4128 vat_main_t *vam = &vat_main;
4129 i32 retval = ntohl (mp->retval);
4133 u32 mode = mp->mode;
4134 print (vam->ofp, "map_request_mode: %U",
4135 format_lisp_map_request_mode, mode);
4138 vam->retval = retval;
4139 vam->result_ready = 1;
4143 vl_api_show_one_map_request_mode_reply_t_handler_json
4144 (vl_api_show_one_map_request_mode_reply_t * mp)
4146 vat_main_t *vam = &vat_main;
4147 vat_json_node_t node;
4152 s = format (0, "%U", format_lisp_map_request_mode, mode);
4155 vat_json_init_object (&node);
4156 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4157 vat_json_print (vam->ofp, &node);
4158 vat_json_free (&node);
4161 vam->retval = ntohl (mp->retval);
4162 vam->result_ready = 1;
4166 vl_api_one_show_xtr_mode_reply_t_handler
4167 (vl_api_one_show_xtr_mode_reply_t * mp)
4169 vat_main_t *vam = &vat_main;
4170 i32 retval = ntohl (mp->retval);
4174 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4177 vam->retval = retval;
4178 vam->result_ready = 1;
4182 vl_api_one_show_xtr_mode_reply_t_handler_json
4183 (vl_api_one_show_xtr_mode_reply_t * mp)
4185 vat_main_t *vam = &vat_main;
4186 vat_json_node_t node;
4189 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4190 vec_add1 (status, 0);
4192 vat_json_init_object (&node);
4193 vat_json_object_add_string_copy (&node, "status", status);
4197 vat_json_print (vam->ofp, &node);
4198 vat_json_free (&node);
4200 vam->retval = ntohl (mp->retval);
4201 vam->result_ready = 1;
4205 vl_api_one_show_pitr_mode_reply_t_handler
4206 (vl_api_one_show_pitr_mode_reply_t * mp)
4208 vat_main_t *vam = &vat_main;
4209 i32 retval = ntohl (mp->retval);
4213 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4216 vam->retval = retval;
4217 vam->result_ready = 1;
4221 vl_api_one_show_pitr_mode_reply_t_handler_json
4222 (vl_api_one_show_pitr_mode_reply_t * mp)
4224 vat_main_t *vam = &vat_main;
4225 vat_json_node_t node;
4228 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4229 vec_add1 (status, 0);
4231 vat_json_init_object (&node);
4232 vat_json_object_add_string_copy (&node, "status", status);
4236 vat_json_print (vam->ofp, &node);
4237 vat_json_free (&node);
4239 vam->retval = ntohl (mp->retval);
4240 vam->result_ready = 1;
4244 vl_api_one_show_petr_mode_reply_t_handler
4245 (vl_api_one_show_petr_mode_reply_t * mp)
4247 vat_main_t *vam = &vat_main;
4248 i32 retval = ntohl (mp->retval);
4252 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4255 vam->retval = retval;
4256 vam->result_ready = 1;
4260 vl_api_one_show_petr_mode_reply_t_handler_json
4261 (vl_api_one_show_petr_mode_reply_t * mp)
4263 vat_main_t *vam = &vat_main;
4264 vat_json_node_t node;
4267 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4268 vec_add1 (status, 0);
4270 vat_json_init_object (&node);
4271 vat_json_object_add_string_copy (&node, "status", status);
4275 vat_json_print (vam->ofp, &node);
4276 vat_json_free (&node);
4278 vam->retval = ntohl (mp->retval);
4279 vam->result_ready = 1;
4283 vl_api_show_one_use_petr_reply_t_handler
4284 (vl_api_show_one_use_petr_reply_t * mp)
4286 vat_main_t *vam = &vat_main;
4287 i32 retval = ntohl (mp->retval);
4291 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4294 print (vam->ofp, "Proxy-ETR address; %U",
4295 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4300 vam->retval = retval;
4301 vam->result_ready = 1;
4305 vl_api_show_one_use_petr_reply_t_handler_json
4306 (vl_api_show_one_use_petr_reply_t * mp)
4308 vat_main_t *vam = &vat_main;
4309 vat_json_node_t node;
4312 struct in6_addr ip6;
4314 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4315 vec_add1 (status, 0);
4317 vat_json_init_object (&node);
4318 vat_json_object_add_string_copy (&node, "status", status);
4323 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4324 vat_json_object_add_ip6 (&node, "address", ip6);
4328 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4329 vat_json_object_add_ip4 (&node, "address", ip4);
4335 vat_json_print (vam->ofp, &node);
4336 vat_json_free (&node);
4338 vam->retval = ntohl (mp->retval);
4339 vam->result_ready = 1;
4343 vl_api_show_one_nsh_mapping_reply_t_handler
4344 (vl_api_show_one_nsh_mapping_reply_t * mp)
4346 vat_main_t *vam = &vat_main;
4347 i32 retval = ntohl (mp->retval);
4351 print (vam->ofp, "%-20s%-16s",
4352 mp->is_set ? "set" : "not-set",
4353 mp->is_set ? (char *) mp->locator_set_name : "");
4356 vam->retval = retval;
4357 vam->result_ready = 1;
4361 vl_api_show_one_nsh_mapping_reply_t_handler_json
4362 (vl_api_show_one_nsh_mapping_reply_t * mp)
4364 vat_main_t *vam = &vat_main;
4365 vat_json_node_t node;
4368 status = format (0, "%s", mp->is_set ? "yes" : "no");
4369 vec_add1 (status, 0);
4371 vat_json_init_object (&node);
4372 vat_json_object_add_string_copy (&node, "is_set", status);
4375 vat_json_object_add_string_copy (&node, "locator_set",
4376 mp->locator_set_name);
4381 vat_json_print (vam->ofp, &node);
4382 vat_json_free (&node);
4384 vam->retval = ntohl (mp->retval);
4385 vam->result_ready = 1;
4389 vl_api_show_one_map_register_ttl_reply_t_handler
4390 (vl_api_show_one_map_register_ttl_reply_t * mp)
4392 vat_main_t *vam = &vat_main;
4393 i32 retval = ntohl (mp->retval);
4395 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4399 print (vam->ofp, "ttl: %u", mp->ttl);
4402 vam->retval = retval;
4403 vam->result_ready = 1;
4407 vl_api_show_one_map_register_ttl_reply_t_handler_json
4408 (vl_api_show_one_map_register_ttl_reply_t * mp)
4410 vat_main_t *vam = &vat_main;
4411 vat_json_node_t node;
4413 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4414 vat_json_init_object (&node);
4415 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4417 vat_json_print (vam->ofp, &node);
4418 vat_json_free (&node);
4420 vam->retval = ntohl (mp->retval);
4421 vam->result_ready = 1;
4425 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4427 vat_main_t *vam = &vat_main;
4428 i32 retval = ntohl (mp->retval);
4432 print (vam->ofp, "%-20s%-16s",
4433 mp->status ? "enabled" : "disabled",
4434 mp->status ? (char *) mp->locator_set_name : "");
4437 vam->retval = retval;
4438 vam->result_ready = 1;
4442 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4444 vat_main_t *vam = &vat_main;
4445 vat_json_node_t node;
4448 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4449 vec_add1 (status, 0);
4451 vat_json_init_object (&node);
4452 vat_json_object_add_string_copy (&node, "status", status);
4455 vat_json_object_add_string_copy (&node, "locator_set",
4456 mp->locator_set_name);
4461 vat_json_print (vam->ofp, &node);
4462 vat_json_free (&node);
4464 vam->retval = ntohl (mp->retval);
4465 vam->result_ready = 1;
4469 format_policer_type (u8 * s, va_list * va)
4471 u32 i = va_arg (*va, u32);
4473 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4474 s = format (s, "1r2c");
4475 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4476 s = format (s, "1r3c");
4477 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4478 s = format (s, "2r3c-2698");
4479 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4480 s = format (s, "2r3c-4115");
4481 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4482 s = format (s, "2r3c-mef5cf1");
4484 s = format (s, "ILLEGAL");
4489 format_policer_rate_type (u8 * s, va_list * va)
4491 u32 i = va_arg (*va, u32);
4493 if (i == SSE2_QOS_RATE_KBPS)
4494 s = format (s, "kbps");
4495 else if (i == SSE2_QOS_RATE_PPS)
4496 s = format (s, "pps");
4498 s = format (s, "ILLEGAL");
4503 format_policer_round_type (u8 * s, va_list * va)
4505 u32 i = va_arg (*va, u32);
4507 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4508 s = format (s, "closest");
4509 else if (i == SSE2_QOS_ROUND_TO_UP)
4510 s = format (s, "up");
4511 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4512 s = format (s, "down");
4514 s = format (s, "ILLEGAL");
4519 format_policer_action_type (u8 * s, va_list * va)
4521 u32 i = va_arg (*va, u32);
4523 if (i == SSE2_QOS_ACTION_DROP)
4524 s = format (s, "drop");
4525 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4526 s = format (s, "transmit");
4527 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4528 s = format (s, "mark-and-transmit");
4530 s = format (s, "ILLEGAL");
4535 format_dscp (u8 * s, va_list * va)
4537 u32 i = va_arg (*va, u32);
4542 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4546 return format (s, "ILLEGAL");
4548 s = format (s, "%s", t);
4553 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4555 vat_main_t *vam = &vat_main;
4556 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4558 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4559 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4561 conform_dscp_str = format (0, "");
4563 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4564 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4566 exceed_dscp_str = format (0, "");
4568 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4569 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4571 violate_dscp_str = format (0, "");
4573 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4574 "rate type %U, round type %U, %s rate, %s color-aware, "
4575 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4576 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4577 "conform action %U%s, exceed action %U%s, violate action %U%s",
4579 format_policer_type, mp->type,
4582 clib_net_to_host_u64 (mp->cb),
4583 clib_net_to_host_u64 (mp->eb),
4584 format_policer_rate_type, mp->rate_type,
4585 format_policer_round_type, mp->round_type,
4586 mp->single_rate ? "single" : "dual",
4587 mp->color_aware ? "is" : "not",
4588 ntohl (mp->cir_tokens_per_period),
4589 ntohl (mp->pir_tokens_per_period),
4591 ntohl (mp->current_limit),
4592 ntohl (mp->current_bucket),
4593 ntohl (mp->extended_limit),
4594 ntohl (mp->extended_bucket),
4595 clib_net_to_host_u64 (mp->last_update_time),
4596 format_policer_action_type, mp->conform_action_type,
4598 format_policer_action_type, mp->exceed_action_type,
4600 format_policer_action_type, mp->violate_action_type,
4603 vec_free (conform_dscp_str);
4604 vec_free (exceed_dscp_str);
4605 vec_free (violate_dscp_str);
4608 static void vl_api_policer_details_t_handler_json
4609 (vl_api_policer_details_t * mp)
4611 vat_main_t *vam = &vat_main;
4612 vat_json_node_t *node;
4613 u8 *rate_type_str, *round_type_str, *type_str;
4614 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4616 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4618 format (0, "%U", format_policer_round_type, mp->round_type);
4619 type_str = format (0, "%U", format_policer_type, mp->type);
4620 conform_action_str = format (0, "%U", format_policer_action_type,
4621 mp->conform_action_type);
4622 exceed_action_str = format (0, "%U", format_policer_action_type,
4623 mp->exceed_action_type);
4624 violate_action_str = format (0, "%U", format_policer_action_type,
4625 mp->violate_action_type);
4627 if (VAT_JSON_ARRAY != vam->json_tree.type)
4629 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4630 vat_json_init_array (&vam->json_tree);
4632 node = vat_json_array_add (&vam->json_tree);
4634 vat_json_init_object (node);
4635 vat_json_object_add_string_copy (node, "name", mp->name);
4636 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4637 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4638 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4639 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4640 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4641 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4642 vat_json_object_add_string_copy (node, "type", type_str);
4643 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4644 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4645 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4646 vat_json_object_add_uint (node, "cir_tokens_per_period",
4647 ntohl (mp->cir_tokens_per_period));
4648 vat_json_object_add_uint (node, "eir_tokens_per_period",
4649 ntohl (mp->pir_tokens_per_period));
4650 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4651 vat_json_object_add_uint (node, "current_bucket",
4652 ntohl (mp->current_bucket));
4653 vat_json_object_add_uint (node, "extended_limit",
4654 ntohl (mp->extended_limit));
4655 vat_json_object_add_uint (node, "extended_bucket",
4656 ntohl (mp->extended_bucket));
4657 vat_json_object_add_uint (node, "last_update_time",
4658 ntohl (mp->last_update_time));
4659 vat_json_object_add_string_copy (node, "conform_action",
4660 conform_action_str);
4661 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4663 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4664 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4665 vec_free (dscp_str);
4667 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4668 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4670 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4671 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4672 vec_free (dscp_str);
4674 vat_json_object_add_string_copy (node, "violate_action",
4675 violate_action_str);
4676 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4678 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4679 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4680 vec_free (dscp_str);
4683 vec_free (rate_type_str);
4684 vec_free (round_type_str);
4685 vec_free (type_str);
4686 vec_free (conform_action_str);
4687 vec_free (exceed_action_str);
4688 vec_free (violate_action_str);
4692 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4695 vat_main_t *vam = &vat_main;
4696 int i, count = ntohl (mp->count);
4699 print (vam->ofp, "classify table ids (%d) : ", count);
4700 for (i = 0; i < count; i++)
4702 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4703 print (vam->ofp, (i < count - 1) ? "," : "");
4705 vam->retval = ntohl (mp->retval);
4706 vam->result_ready = 1;
4710 vl_api_classify_table_ids_reply_t_handler_json
4711 (vl_api_classify_table_ids_reply_t * mp)
4713 vat_main_t *vam = &vat_main;
4714 int i, count = ntohl (mp->count);
4718 vat_json_node_t node;
4720 vat_json_init_object (&node);
4721 for (i = 0; i < count; i++)
4723 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4725 vat_json_print (vam->ofp, &node);
4726 vat_json_free (&node);
4728 vam->retval = ntohl (mp->retval);
4729 vam->result_ready = 1;
4733 vl_api_classify_table_by_interface_reply_t_handler
4734 (vl_api_classify_table_by_interface_reply_t * mp)
4736 vat_main_t *vam = &vat_main;
4739 table_id = ntohl (mp->l2_table_id);
4741 print (vam->ofp, "l2 table id : %d", table_id);
4743 print (vam->ofp, "l2 table id : No input ACL tables configured");
4744 table_id = ntohl (mp->ip4_table_id);
4746 print (vam->ofp, "ip4 table id : %d", table_id);
4748 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4749 table_id = ntohl (mp->ip6_table_id);
4751 print (vam->ofp, "ip6 table id : %d", table_id);
4753 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4754 vam->retval = ntohl (mp->retval);
4755 vam->result_ready = 1;
4759 vl_api_classify_table_by_interface_reply_t_handler_json
4760 (vl_api_classify_table_by_interface_reply_t * mp)
4762 vat_main_t *vam = &vat_main;
4763 vat_json_node_t node;
4765 vat_json_init_object (&node);
4767 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4768 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4769 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4771 vat_json_print (vam->ofp, &node);
4772 vat_json_free (&node);
4774 vam->retval = ntohl (mp->retval);
4775 vam->result_ready = 1;
4778 static void vl_api_policer_add_del_reply_t_handler
4779 (vl_api_policer_add_del_reply_t * mp)
4781 vat_main_t *vam = &vat_main;
4782 i32 retval = ntohl (mp->retval);
4783 if (vam->async_mode)
4785 vam->async_errors += (retval < 0);
4789 vam->retval = retval;
4790 vam->result_ready = 1;
4791 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4793 * Note: this is just barely thread-safe, depends on
4794 * the main thread spinning waiting for an answer...
4796 errmsg ("policer index %d", ntohl (mp->policer_index));
4800 static void vl_api_policer_add_del_reply_t_handler_json
4801 (vl_api_policer_add_del_reply_t * mp)
4803 vat_main_t *vam = &vat_main;
4804 vat_json_node_t node;
4806 vat_json_init_object (&node);
4807 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4808 vat_json_object_add_uint (&node, "policer_index",
4809 ntohl (mp->policer_index));
4811 vat_json_print (vam->ofp, &node);
4812 vat_json_free (&node);
4814 vam->retval = ntohl (mp->retval);
4815 vam->result_ready = 1;
4818 /* Format hex dump. */
4820 format_hex_bytes (u8 * s, va_list * va)
4822 u8 *bytes = va_arg (*va, u8 *);
4823 int n_bytes = va_arg (*va, int);
4826 /* Print short or long form depending on byte count. */
4827 uword short_form = n_bytes <= 32;
4828 u32 indent = format_get_indent (s);
4833 for (i = 0; i < n_bytes; i++)
4835 if (!short_form && (i % 32) == 0)
4836 s = format (s, "%08x: ", i);
4837 s = format (s, "%02x", bytes[i]);
4838 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4839 s = format (s, "\n%U", format_white_space, indent);
4846 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4849 vat_main_t *vam = &vat_main;
4850 i32 retval = ntohl (mp->retval);
4853 print (vam->ofp, "classify table info :");
4854 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4855 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4856 ntohl (mp->miss_next_index));
4857 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4858 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4859 ntohl (mp->match_n_vectors));
4860 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4861 ntohl (mp->mask_length));
4863 vam->retval = retval;
4864 vam->result_ready = 1;
4868 vl_api_classify_table_info_reply_t_handler_json
4869 (vl_api_classify_table_info_reply_t * mp)
4871 vat_main_t *vam = &vat_main;
4872 vat_json_node_t node;
4874 i32 retval = ntohl (mp->retval);
4877 vat_json_init_object (&node);
4879 vat_json_object_add_int (&node, "sessions",
4880 ntohl (mp->active_sessions));
4881 vat_json_object_add_int (&node, "nexttbl",
4882 ntohl (mp->next_table_index));
4883 vat_json_object_add_int (&node, "nextnode",
4884 ntohl (mp->miss_next_index));
4885 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4886 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4887 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4888 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4889 ntohl (mp->mask_length), 0);
4890 vat_json_object_add_string_copy (&node, "mask", s);
4892 vat_json_print (vam->ofp, &node);
4893 vat_json_free (&node);
4895 vam->retval = ntohl (mp->retval);
4896 vam->result_ready = 1;
4900 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4903 vat_main_t *vam = &vat_main;
4905 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4906 ntohl (mp->hit_next_index), ntohl (mp->advance),
4907 ntohl (mp->opaque_index));
4908 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4909 ntohl (mp->match_length));
4913 vl_api_classify_session_details_t_handler_json
4914 (vl_api_classify_session_details_t * mp)
4916 vat_main_t *vam = &vat_main;
4917 vat_json_node_t *node = NULL;
4919 if (VAT_JSON_ARRAY != vam->json_tree.type)
4921 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4922 vat_json_init_array (&vam->json_tree);
4924 node = vat_json_array_add (&vam->json_tree);
4926 vat_json_init_object (node);
4927 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4928 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4929 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4931 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4933 vat_json_object_add_string_copy (node, "match", s);
4936 static void vl_api_pg_create_interface_reply_t_handler
4937 (vl_api_pg_create_interface_reply_t * mp)
4939 vat_main_t *vam = &vat_main;
4941 vam->retval = ntohl (mp->retval);
4942 vam->result_ready = 1;
4945 static void vl_api_pg_create_interface_reply_t_handler_json
4946 (vl_api_pg_create_interface_reply_t * mp)
4948 vat_main_t *vam = &vat_main;
4949 vat_json_node_t node;
4951 i32 retval = ntohl (mp->retval);
4954 vat_json_init_object (&node);
4956 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4958 vat_json_print (vam->ofp, &node);
4959 vat_json_free (&node);
4961 vam->retval = ntohl (mp->retval);
4962 vam->result_ready = 1;
4965 static void vl_api_policer_classify_details_t_handler
4966 (vl_api_policer_classify_details_t * mp)
4968 vat_main_t *vam = &vat_main;
4970 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4971 ntohl (mp->table_index));
4974 static void vl_api_policer_classify_details_t_handler_json
4975 (vl_api_policer_classify_details_t * mp)
4977 vat_main_t *vam = &vat_main;
4978 vat_json_node_t *node;
4980 if (VAT_JSON_ARRAY != vam->json_tree.type)
4982 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4983 vat_json_init_array (&vam->json_tree);
4985 node = vat_json_array_add (&vam->json_tree);
4987 vat_json_init_object (node);
4988 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4989 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4992 static void vl_api_flow_classify_details_t_handler
4993 (vl_api_flow_classify_details_t * mp)
4995 vat_main_t *vam = &vat_main;
4997 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4998 ntohl (mp->table_index));
5001 static void vl_api_flow_classify_details_t_handler_json
5002 (vl_api_flow_classify_details_t * mp)
5004 vat_main_t *vam = &vat_main;
5005 vat_json_node_t *node;
5007 if (VAT_JSON_ARRAY != vam->json_tree.type)
5009 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5010 vat_json_init_array (&vam->json_tree);
5012 node = vat_json_array_add (&vam->json_tree);
5014 vat_json_init_object (node);
5015 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5016 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5019 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5020 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5021 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5022 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5023 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5024 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5025 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5026 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5027 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5028 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5031 * Generate boilerplate reply handlers, which
5032 * dig the return value out of the xxx_reply_t API message,
5033 * stick it into vam->retval, and set vam->result_ready
5035 * Could also do this by pointing N message decode slots at
5036 * a single function, but that could break in subtle ways.
5039 #define foreach_standard_reply_retval_handler \
5040 _(sw_interface_set_flags_reply) \
5041 _(sw_interface_add_del_address_reply) \
5042 _(sw_interface_set_rx_mode_reply) \
5043 _(sw_interface_set_rx_placement_reply) \
5044 _(sw_interface_set_table_reply) \
5045 _(sw_interface_set_mpls_enable_reply) \
5046 _(sw_interface_set_vpath_reply) \
5047 _(sw_interface_set_vxlan_bypass_reply) \
5048 _(sw_interface_set_geneve_bypass_reply) \
5049 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5050 _(sw_interface_set_l2_bridge_reply) \
5051 _(sw_interface_set_bond_weight_reply) \
5052 _(bridge_domain_add_del_reply) \
5053 _(sw_interface_set_l2_xconnect_reply) \
5054 _(l2fib_add_del_reply) \
5055 _(l2fib_flush_int_reply) \
5056 _(l2fib_flush_bd_reply) \
5057 _(ip_route_add_del_reply) \
5058 _(ip_table_add_del_reply) \
5059 _(ip_table_replace_begin_reply) \
5060 _(ip_table_flush_reply) \
5061 _(ip_table_replace_end_reply) \
5062 _(ip_mroute_add_del_reply) \
5063 _(mpls_route_add_del_reply) \
5064 _(mpls_table_add_del_reply) \
5065 _(mpls_ip_bind_unbind_reply) \
5066 _(bier_route_add_del_reply) \
5067 _(bier_table_add_del_reply) \
5068 _(sw_interface_set_unnumbered_reply) \
5069 _(set_ip_flow_hash_reply) \
5070 _(sw_interface_ip6_enable_disable_reply) \
5071 _(l2_patch_add_del_reply) \
5072 _(sr_mpls_policy_add_reply) \
5073 _(sr_mpls_policy_mod_reply) \
5074 _(sr_mpls_policy_del_reply) \
5075 _(sr_policy_add_reply) \
5076 _(sr_policy_mod_reply) \
5077 _(sr_policy_del_reply) \
5078 _(sr_localsid_add_del_reply) \
5079 _(sr_steering_add_del_reply) \
5080 _(classify_add_del_session_reply) \
5081 _(classify_set_interface_ip_table_reply) \
5082 _(classify_set_interface_l2_tables_reply) \
5083 _(l2tpv3_set_tunnel_cookies_reply) \
5084 _(l2tpv3_interface_enable_disable_reply) \
5085 _(l2tpv3_set_lookup_key_reply) \
5086 _(l2_fib_clear_table_reply) \
5087 _(l2_interface_efp_filter_reply) \
5088 _(l2_interface_vlan_tag_rewrite_reply) \
5089 _(modify_vhost_user_if_reply) \
5090 _(delete_vhost_user_if_reply) \
5091 _(want_l2_macs_events_reply) \
5092 _(input_acl_set_interface_reply) \
5093 _(ipsec_spd_add_del_reply) \
5094 _(ipsec_interface_add_del_spd_reply) \
5095 _(ipsec_spd_entry_add_del_reply) \
5096 _(ipsec_sad_entry_add_del_reply) \
5097 _(ipsec_tunnel_if_add_del_reply) \
5098 _(ipsec_tunnel_if_set_sa_reply) \
5099 _(delete_loopback_reply) \
5100 _(bd_ip_mac_add_del_reply) \
5101 _(bd_ip_mac_flush_reply) \
5102 _(want_interface_events_reply) \
5103 _(cop_interface_enable_disable_reply) \
5104 _(cop_whitelist_enable_disable_reply) \
5105 _(sw_interface_clear_stats_reply) \
5106 _(ioam_enable_reply) \
5107 _(ioam_disable_reply) \
5108 _(one_add_del_locator_reply) \
5109 _(one_add_del_local_eid_reply) \
5110 _(one_add_del_remote_mapping_reply) \
5111 _(one_add_del_adjacency_reply) \
5112 _(one_add_del_map_resolver_reply) \
5113 _(one_add_del_map_server_reply) \
5114 _(one_enable_disable_reply) \
5115 _(one_rloc_probe_enable_disable_reply) \
5116 _(one_map_register_enable_disable_reply) \
5117 _(one_map_register_set_ttl_reply) \
5118 _(one_set_transport_protocol_reply) \
5119 _(one_map_register_fallback_threshold_reply) \
5120 _(one_pitr_set_locator_set_reply) \
5121 _(one_map_request_mode_reply) \
5122 _(one_add_del_map_request_itr_rlocs_reply) \
5123 _(one_eid_table_add_del_map_reply) \
5124 _(one_use_petr_reply) \
5125 _(one_stats_enable_disable_reply) \
5126 _(one_add_del_l2_arp_entry_reply) \
5127 _(one_add_del_ndp_entry_reply) \
5128 _(one_stats_flush_reply) \
5129 _(one_enable_disable_xtr_mode_reply) \
5130 _(one_enable_disable_pitr_mode_reply) \
5131 _(one_enable_disable_petr_mode_reply) \
5132 _(gpe_enable_disable_reply) \
5133 _(gpe_set_encap_mode_reply) \
5134 _(gpe_add_del_iface_reply) \
5135 _(gpe_add_del_native_fwd_rpath_reply) \
5136 _(af_packet_delete_reply) \
5137 _(policer_classify_set_interface_reply) \
5138 _(set_ipfix_exporter_reply) \
5139 _(set_ipfix_classify_stream_reply) \
5140 _(ipfix_classify_table_add_del_reply) \
5141 _(flow_classify_set_interface_reply) \
5142 _(sw_interface_span_enable_disable_reply) \
5143 _(pg_capture_reply) \
5144 _(pg_enable_disable_reply) \
5145 _(ip_source_and_port_range_check_add_del_reply) \
5146 _(ip_source_and_port_range_check_interface_add_del_reply)\
5147 _(delete_subif_reply) \
5148 _(l2_interface_pbb_tag_rewrite_reply) \
5150 _(feature_enable_disable_reply) \
5151 _(feature_gso_enable_disable_reply) \
5152 _(sw_interface_tag_add_del_reply) \
5153 _(sw_interface_add_del_mac_address_reply) \
5154 _(hw_interface_set_mtu_reply) \
5155 _(p2p_ethernet_add_reply) \
5156 _(p2p_ethernet_del_reply) \
5157 _(lldp_config_reply) \
5158 _(sw_interface_set_lldp_reply) \
5159 _(tcp_configure_src_addresses_reply) \
5160 _(session_rule_add_del_reply) \
5161 _(ip_container_proxy_add_del_reply) \
5162 _(output_acl_set_interface_reply) \
5163 _(qos_record_enable_disable_reply)
5166 static void vl_api_##n##_t_handler \
5167 (vl_api_##n##_t * mp) \
5169 vat_main_t * vam = &vat_main; \
5170 i32 retval = ntohl(mp->retval); \
5171 if (vam->async_mode) { \
5172 vam->async_errors += (retval < 0); \
5174 vam->retval = retval; \
5175 vam->result_ready = 1; \
5178 foreach_standard_reply_retval_handler;
5182 static void vl_api_##n##_t_handler_json \
5183 (vl_api_##n##_t * mp) \
5185 vat_main_t * vam = &vat_main; \
5186 vat_json_node_t node; \
5187 vat_json_init_object(&node); \
5188 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5189 vat_json_print(vam->ofp, &node); \
5190 vam->retval = ntohl(mp->retval); \
5191 vam->result_ready = 1; \
5193 foreach_standard_reply_retval_handler;
5197 * Table of message reply handlers, must include boilerplate handlers
5201 #define foreach_vpe_api_reply_msg \
5202 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5203 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5204 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5205 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5206 _(CONTROL_PING_REPLY, control_ping_reply) \
5207 _(CLI_REPLY, cli_reply) \
5208 _(CLI_INBAND_REPLY, cli_inband_reply) \
5209 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5210 sw_interface_add_del_address_reply) \
5211 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5212 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5213 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5214 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5215 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5216 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5217 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5218 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5219 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5220 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5221 sw_interface_set_l2_xconnect_reply) \
5222 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5223 sw_interface_set_l2_bridge_reply) \
5224 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5225 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5226 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5227 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5228 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5229 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5230 _(L2_FLAGS_REPLY, l2_flags_reply) \
5231 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5232 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5233 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5234 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5235 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5236 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5237 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5238 _(BOND_CREATE_REPLY, bond_create_reply) \
5239 _(BOND_DELETE_REPLY, bond_delete_reply) \
5240 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5241 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5242 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5243 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5244 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5245 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5246 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5247 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5248 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5249 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5250 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5251 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5252 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5253 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5254 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5255 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5256 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5257 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5258 sw_interface_set_unnumbered_reply) \
5259 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5260 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5261 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5262 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5263 sw_interface_ip6_enable_disable_reply) \
5264 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5265 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5266 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5267 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5268 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5269 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5270 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5271 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5272 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5273 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5274 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5275 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5276 classify_set_interface_ip_table_reply) \
5277 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5278 classify_set_interface_l2_tables_reply) \
5279 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5280 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5281 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5282 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5283 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5284 l2tpv3_interface_enable_disable_reply) \
5285 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5286 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5287 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5288 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5289 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5290 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5291 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5292 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5293 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5294 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5295 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5296 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5297 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5298 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5299 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5300 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5301 _(SHOW_VERSION_REPLY, show_version_reply) \
5302 _(SHOW_THREADS_REPLY, show_threads_reply) \
5303 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5304 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5305 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5306 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5307 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5308 _(L2_MACS_EVENT, l2_macs_event) \
5309 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5310 _(IP_ADDRESS_DETAILS, ip_address_details) \
5311 _(IP_DETAILS, ip_details) \
5312 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5313 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5314 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5315 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5316 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5317 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5318 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5319 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5320 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5321 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5322 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5323 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5324 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5325 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5326 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5327 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5328 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5329 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5330 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5331 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5332 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5333 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5334 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5335 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5336 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5337 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5338 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5339 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5340 one_map_register_enable_disable_reply) \
5341 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5342 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5343 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5344 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5345 one_map_register_fallback_threshold_reply) \
5346 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5347 one_rloc_probe_enable_disable_reply) \
5348 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5349 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5350 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5351 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5352 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5353 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5354 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5355 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5356 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5357 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5358 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5359 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5360 _(ONE_STATS_DETAILS, one_stats_details) \
5361 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5362 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5363 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5364 show_one_stats_enable_disable_reply) \
5365 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5366 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5367 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5368 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5369 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5370 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5371 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5372 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5373 one_enable_disable_pitr_mode_reply) \
5374 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5375 one_enable_disable_petr_mode_reply) \
5376 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5377 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5378 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5379 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5380 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5381 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5382 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5383 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5384 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5385 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5386 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5387 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5388 gpe_add_del_native_fwd_rpath_reply) \
5389 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5390 gpe_fwd_entry_path_details) \
5391 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5392 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5393 one_add_del_map_request_itr_rlocs_reply) \
5394 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5395 one_get_map_request_itr_rlocs_reply) \
5396 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5397 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5398 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5399 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5400 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5401 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5402 show_one_map_register_state_reply) \
5403 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5404 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5405 show_one_map_register_fallback_threshold_reply) \
5406 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5407 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5408 _(AF_PACKET_DETAILS, af_packet_details) \
5409 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5410 _(POLICER_DETAILS, policer_details) \
5411 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5412 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5413 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5414 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5415 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5416 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5417 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5418 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5419 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5420 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5421 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5422 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5423 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5424 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5425 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5426 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5427 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5428 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5429 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5430 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5431 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5432 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5433 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5434 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5435 ip_source_and_port_range_check_add_del_reply) \
5436 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5437 ip_source_and_port_range_check_interface_add_del_reply) \
5438 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5439 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5440 _(SET_PUNT_REPLY, set_punt_reply) \
5441 _(IP_TABLE_DETAILS, ip_table_details) \
5442 _(IP_ROUTE_DETAILS, ip_route_details) \
5443 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5444 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5445 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5446 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5447 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5448 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5449 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5450 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5451 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5452 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5453 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5454 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5455 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5456 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5457 _(SESSION_RULES_DETAILS, session_rules_details) \
5458 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5459 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5460 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5462 #define foreach_standalone_reply_msg \
5463 _(SW_INTERFACE_EVENT, sw_interface_event)
5471 #define STR_VTR_OP_CASE(op) \
5472 case L2_VTR_ ## op: \
5476 str_vtr_op (u32 vtr_op)
5480 STR_VTR_OP_CASE (DISABLED);
5481 STR_VTR_OP_CASE (PUSH_1);
5482 STR_VTR_OP_CASE (PUSH_2);
5483 STR_VTR_OP_CASE (POP_1);
5484 STR_VTR_OP_CASE (POP_2);
5485 STR_VTR_OP_CASE (TRANSLATE_1_1);
5486 STR_VTR_OP_CASE (TRANSLATE_1_2);
5487 STR_VTR_OP_CASE (TRANSLATE_2_1);
5488 STR_VTR_OP_CASE (TRANSLATE_2_2);
5495 dump_sub_interface_table (vat_main_t * vam)
5497 const sw_interface_subif_t *sub = NULL;
5499 if (vam->json_output)
5502 ("JSON output supported only for VPE API calls and dump_stats_table");
5507 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5508 "Interface", "sw_if_index",
5509 "sub id", "dot1ad", "tags", "outer id",
5510 "inner id", "exact", "default", "outer any", "inner any");
5512 vec_foreach (sub, vam->sw_if_subif_table)
5515 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5516 sub->interface_name,
5518 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5519 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5520 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5521 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5522 if (sub->vtr_op != L2_VTR_DISABLED)
5525 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5526 "tag1: %d tag2: %d ]",
5527 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5528 sub->vtr_tag1, sub->vtr_tag2);
5536 name_sort_cmp (void *a1, void *a2)
5538 name_sort_t *n1 = a1;
5539 name_sort_t *n2 = a2;
5541 return strcmp ((char *) n1->name, (char *) n2->name);
5545 dump_interface_table (vat_main_t * vam)
5548 name_sort_t *nses = 0, *ns;
5550 if (vam->json_output)
5553 ("JSON output supported only for VPE API calls and dump_stats_table");
5558 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5560 vec_add2 (nses, ns, 1);
5561 ns->name = (u8 *)(p->key);
5562 ns->value = (u32) p->value[0];
5566 vec_sort_with_function (nses, name_sort_cmp);
5568 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5569 vec_foreach (ns, nses)
5571 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5578 dump_ip_table (vat_main_t * vam, int is_ipv6)
5580 const ip_details_t *det = NULL;
5581 const ip_address_details_t *address = NULL;
5584 print (vam->ofp, "%-12s", "sw_if_index");
5586 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5593 print (vam->ofp, "%-12d", i);
5594 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5599 vec_foreach (address, det->addr)
5603 is_ipv6 ? format_ip6_address : format_ip4_address,
5604 address->ip, address->prefix_length);
5612 dump_ipv4_table (vat_main_t * vam)
5614 if (vam->json_output)
5617 ("JSON output supported only for VPE API calls and dump_stats_table");
5621 return dump_ip_table (vam, 0);
5625 dump_ipv6_table (vat_main_t * vam)
5627 if (vam->json_output)
5630 ("JSON output supported only for VPE API calls and dump_stats_table");
5634 return dump_ip_table (vam, 1);
5638 * Pass CLI buffers directly in the CLI_INBAND API message,
5639 * instead of an additional shared memory area.
5642 exec_inband (vat_main_t * vam)
5644 vl_api_cli_inband_t *mp;
5645 unformat_input_t *i = vam->input;
5648 if (vec_len (i->buffer) == 0)
5651 if (vam->exec_mode == 0 && unformat (i, "mode"))
5656 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5663 * In order for the CLI command to work, it
5664 * must be a vector ending in \n, not a C-string ending
5667 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
5668 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
5672 /* json responses may or may not include a useful reply... */
5673 if (vec_len (vam->cmd_reply))
5674 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5679 exec (vat_main_t * vam)
5681 return exec_inband (vam);
5685 api_create_loopback (vat_main_t * vam)
5687 unformat_input_t *i = vam->input;
5688 vl_api_create_loopback_t *mp;
5689 vl_api_create_loopback_instance_t *mp_lbi;
5692 u8 is_specified = 0;
5693 u32 user_instance = 0;
5696 clib_memset (mac_address, 0, sizeof (mac_address));
5698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5700 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5702 if (unformat (i, "instance %d", &user_instance))
5710 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5711 mp_lbi->is_specified = is_specified;
5713 mp_lbi->user_instance = htonl (user_instance);
5715 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5720 /* Construct the API message */
5721 M (CREATE_LOOPBACK, mp);
5723 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5732 api_delete_loopback (vat_main_t * vam)
5734 unformat_input_t *i = vam->input;
5735 vl_api_delete_loopback_t *mp;
5736 u32 sw_if_index = ~0;
5739 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5741 if (unformat (i, "sw_if_index %d", &sw_if_index))
5747 if (sw_if_index == ~0)
5749 errmsg ("missing sw_if_index");
5753 /* Construct the API message */
5754 M (DELETE_LOOPBACK, mp);
5755 mp->sw_if_index = ntohl (sw_if_index);
5763 api_want_interface_events (vat_main_t * vam)
5765 unformat_input_t *i = vam->input;
5766 vl_api_want_interface_events_t *mp;
5770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5772 if (unformat (i, "enable"))
5774 else if (unformat (i, "disable"))
5782 errmsg ("missing enable|disable");
5786 M (WANT_INTERFACE_EVENTS, mp);
5787 mp->enable_disable = enable;
5789 vam->interface_event_display = enable;
5797 /* Note: non-static, called once to set up the initial intfc table */
5799 api_sw_interface_dump (vat_main_t * vam)
5801 vl_api_sw_interface_dump_t *mp;
5802 vl_api_control_ping_t *mp_ping;
5804 name_sort_t *nses = 0, *ns;
5805 sw_interface_subif_t *sub = NULL;
5808 /* Toss the old name table */
5810 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5812 vec_add2 (nses, ns, 1);
5813 ns->name = (u8 *)(p->key);
5814 ns->value = (u32) p->value[0];
5818 hash_free (vam->sw_if_index_by_interface_name);
5820 vec_foreach (ns, nses) vec_free (ns->name);
5824 vec_foreach (sub, vam->sw_if_subif_table)
5826 vec_free (sub->interface_name);
5828 vec_free (vam->sw_if_subif_table);
5830 /* recreate the interface name hash table */
5831 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5834 * Ask for all interface names. Otherwise, the epic catalog of
5835 * name filters becomes ridiculously long, and vat ends up needing
5836 * to be taught about new interface types.
5838 M (SW_INTERFACE_DUMP, mp);
5841 /* Use a control ping for synchronization */
5842 MPING (CONTROL_PING, mp_ping);
5850 api_sw_interface_set_flags (vat_main_t * vam)
5852 unformat_input_t *i = vam->input;
5853 vl_api_sw_interface_set_flags_t *mp;
5855 u8 sw_if_index_set = 0;
5859 /* Parse args required to build the message */
5860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5862 if (unformat (i, "admin-up"))
5864 else if (unformat (i, "admin-down"))
5867 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5868 sw_if_index_set = 1;
5869 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5870 sw_if_index_set = 1;
5875 if (sw_if_index_set == 0)
5877 errmsg ("missing interface name or sw_if_index");
5881 /* Construct the API message */
5882 M (SW_INTERFACE_SET_FLAGS, mp);
5883 mp->sw_if_index = ntohl (sw_if_index);
5884 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5889 /* Wait for a reply, return the good/bad news... */
5895 api_sw_interface_set_rx_mode (vat_main_t * vam)
5897 unformat_input_t *i = vam->input;
5898 vl_api_sw_interface_set_rx_mode_t *mp;
5900 u8 sw_if_index_set = 0;
5902 u8 queue_id_valid = 0;
5904 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5906 /* Parse args required to build the message */
5907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5909 if (unformat (i, "queue %d", &queue_id))
5911 else if (unformat (i, "polling"))
5912 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5913 else if (unformat (i, "interrupt"))
5914 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5915 else if (unformat (i, "adaptive"))
5916 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5918 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5919 sw_if_index_set = 1;
5920 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5921 sw_if_index_set = 1;
5926 if (sw_if_index_set == 0)
5928 errmsg ("missing interface name or sw_if_index");
5931 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5933 errmsg ("missing rx-mode");
5937 /* Construct the API message */
5938 M (SW_INTERFACE_SET_RX_MODE, mp);
5939 mp->sw_if_index = ntohl (sw_if_index);
5940 mp->mode = (vl_api_rx_mode_t) mode;
5941 mp->queue_id_valid = queue_id_valid;
5942 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5947 /* Wait for a reply, return the good/bad news... */
5953 api_sw_interface_set_rx_placement (vat_main_t * vam)
5955 unformat_input_t *i = vam->input;
5956 vl_api_sw_interface_set_rx_placement_t *mp;
5958 u8 sw_if_index_set = 0;
5961 u32 queue_id, thread_index;
5963 /* Parse args required to build the message */
5964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5966 if (unformat (i, "queue %d", &queue_id))
5968 else if (unformat (i, "main"))
5970 else if (unformat (i, "worker %d", &thread_index))
5973 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5974 sw_if_index_set = 1;
5975 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5976 sw_if_index_set = 1;
5981 if (sw_if_index_set == 0)
5983 errmsg ("missing interface name or sw_if_index");
5989 /* Construct the API message */
5990 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5991 mp->sw_if_index = ntohl (sw_if_index);
5992 mp->worker_id = ntohl (thread_index);
5993 mp->queue_id = ntohl (queue_id);
5994 mp->is_main = is_main;
5998 /* Wait for a reply, return the good/bad news... */
6003 static void vl_api_sw_interface_rx_placement_details_t_handler
6004 (vl_api_sw_interface_rx_placement_details_t * mp)
6006 vat_main_t *vam = &vat_main;
6007 u32 worker_id = ntohl (mp->worker_id);
6010 "\n%-11d %-11s %-6d %-5d %-9s",
6011 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6012 worker_id, ntohl (mp->queue_id),
6014 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6017 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6018 (vl_api_sw_interface_rx_placement_details_t * mp)
6020 vat_main_t *vam = &vat_main;
6021 vat_json_node_t *node = NULL;
6023 if (VAT_JSON_ARRAY != vam->json_tree.type)
6025 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6026 vat_json_init_array (&vam->json_tree);
6028 node = vat_json_array_add (&vam->json_tree);
6030 vat_json_init_object (node);
6031 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6032 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6033 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6034 vat_json_object_add_uint (node, "mode", mp->mode);
6038 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6040 unformat_input_t *i = vam->input;
6041 vl_api_sw_interface_rx_placement_dump_t *mp;
6042 vl_api_control_ping_t *mp_ping;
6045 u8 sw_if_index_set = 0;
6047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6049 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6051 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6058 "\n%-11s %-11s %-6s %-5s %-4s",
6059 "sw_if_index", "main/worker", "thread", "queue", "mode");
6061 /* Dump Interface rx placement */
6062 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6064 if (sw_if_index_set)
6065 mp->sw_if_index = htonl (sw_if_index);
6067 mp->sw_if_index = ~0;
6071 /* Use a control ping for synchronization */
6072 MPING (CONTROL_PING, mp_ping);
6080 api_sw_interface_clear_stats (vat_main_t * vam)
6082 unformat_input_t *i = vam->input;
6083 vl_api_sw_interface_clear_stats_t *mp;
6085 u8 sw_if_index_set = 0;
6088 /* Parse args required to build the message */
6089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6091 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6092 sw_if_index_set = 1;
6093 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6094 sw_if_index_set = 1;
6099 /* Construct the API message */
6100 M (SW_INTERFACE_CLEAR_STATS, mp);
6102 if (sw_if_index_set == 1)
6103 mp->sw_if_index = ntohl (sw_if_index);
6105 mp->sw_if_index = ~0;
6110 /* Wait for a reply, return the good/bad news... */
6116 api_sw_interface_add_del_address (vat_main_t * vam)
6118 unformat_input_t *i = vam->input;
6119 vl_api_sw_interface_add_del_address_t *mp;
6121 u8 sw_if_index_set = 0;
6122 u8 is_add = 1, del_all = 0;
6123 u32 address_length = 0;
6124 u8 v4_address_set = 0;
6125 u8 v6_address_set = 0;
6126 ip4_address_t v4address;
6127 ip6_address_t v6address;
6130 /* Parse args required to build the message */
6131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6133 if (unformat (i, "del-all"))
6135 else if (unformat (i, "del"))
6138 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6139 sw_if_index_set = 1;
6140 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6141 sw_if_index_set = 1;
6142 else if (unformat (i, "%U/%d",
6143 unformat_ip4_address, &v4address, &address_length))
6145 else if (unformat (i, "%U/%d",
6146 unformat_ip6_address, &v6address, &address_length))
6152 if (sw_if_index_set == 0)
6154 errmsg ("missing interface name or sw_if_index");
6157 if (v4_address_set && v6_address_set)
6159 errmsg ("both v4 and v6 addresses set");
6162 if (!v4_address_set && !v6_address_set && !del_all)
6164 errmsg ("no addresses set");
6168 /* Construct the API message */
6169 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6171 mp->sw_if_index = ntohl (sw_if_index);
6172 mp->is_add = is_add;
6173 mp->del_all = del_all;
6176 mp->prefix.address.af = ADDRESS_IP6;
6177 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6181 mp->prefix.address.af = ADDRESS_IP4;
6182 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6184 mp->prefix.len = address_length;
6189 /* Wait for a reply, return good/bad news */
6195 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6197 unformat_input_t *i = vam->input;
6198 vl_api_sw_interface_set_mpls_enable_t *mp;
6200 u8 sw_if_index_set = 0;
6204 /* Parse args required to build the message */
6205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6207 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6208 sw_if_index_set = 1;
6209 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6210 sw_if_index_set = 1;
6211 else if (unformat (i, "disable"))
6213 else if (unformat (i, "dis"))
6219 if (sw_if_index_set == 0)
6221 errmsg ("missing interface name or sw_if_index");
6225 /* Construct the API message */
6226 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6228 mp->sw_if_index = ntohl (sw_if_index);
6229 mp->enable = enable;
6234 /* Wait for a reply... */
6240 api_sw_interface_set_table (vat_main_t * vam)
6242 unformat_input_t *i = vam->input;
6243 vl_api_sw_interface_set_table_t *mp;
6244 u32 sw_if_index, vrf_id = 0;
6245 u8 sw_if_index_set = 0;
6249 /* Parse args required to build the message */
6250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6252 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6253 sw_if_index_set = 1;
6254 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6255 sw_if_index_set = 1;
6256 else if (unformat (i, "vrf %d", &vrf_id))
6258 else if (unformat (i, "ipv6"))
6264 if (sw_if_index_set == 0)
6266 errmsg ("missing interface name or sw_if_index");
6270 /* Construct the API message */
6271 M (SW_INTERFACE_SET_TABLE, mp);
6273 mp->sw_if_index = ntohl (sw_if_index);
6274 mp->is_ipv6 = is_ipv6;
6275 mp->vrf_id = ntohl (vrf_id);
6280 /* Wait for a reply... */
6285 static void vl_api_sw_interface_get_table_reply_t_handler
6286 (vl_api_sw_interface_get_table_reply_t * mp)
6288 vat_main_t *vam = &vat_main;
6290 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6292 vam->retval = ntohl (mp->retval);
6293 vam->result_ready = 1;
6297 static void vl_api_sw_interface_get_table_reply_t_handler_json
6298 (vl_api_sw_interface_get_table_reply_t * mp)
6300 vat_main_t *vam = &vat_main;
6301 vat_json_node_t node;
6303 vat_json_init_object (&node);
6304 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6305 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6307 vat_json_print (vam->ofp, &node);
6308 vat_json_free (&node);
6310 vam->retval = ntohl (mp->retval);
6311 vam->result_ready = 1;
6315 api_sw_interface_get_table (vat_main_t * vam)
6317 unformat_input_t *i = vam->input;
6318 vl_api_sw_interface_get_table_t *mp;
6320 u8 sw_if_index_set = 0;
6324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6326 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6327 sw_if_index_set = 1;
6328 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6329 sw_if_index_set = 1;
6330 else if (unformat (i, "ipv6"))
6336 if (sw_if_index_set == 0)
6338 errmsg ("missing interface name or sw_if_index");
6342 M (SW_INTERFACE_GET_TABLE, mp);
6343 mp->sw_if_index = htonl (sw_if_index);
6344 mp->is_ipv6 = is_ipv6;
6352 api_sw_interface_set_vpath (vat_main_t * vam)
6354 unformat_input_t *i = vam->input;
6355 vl_api_sw_interface_set_vpath_t *mp;
6356 u32 sw_if_index = 0;
6357 u8 sw_if_index_set = 0;
6361 /* Parse args required to build the message */
6362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6364 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6365 sw_if_index_set = 1;
6366 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6367 sw_if_index_set = 1;
6368 else if (unformat (i, "enable"))
6370 else if (unformat (i, "disable"))
6376 if (sw_if_index_set == 0)
6378 errmsg ("missing interface name or sw_if_index");
6382 /* Construct the API message */
6383 M (SW_INTERFACE_SET_VPATH, mp);
6385 mp->sw_if_index = ntohl (sw_if_index);
6386 mp->enable = is_enable;
6391 /* Wait for a reply... */
6397 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6399 unformat_input_t *i = vam->input;
6400 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6401 u32 sw_if_index = 0;
6402 u8 sw_if_index_set = 0;
6407 /* Parse args required to build the message */
6408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6410 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6411 sw_if_index_set = 1;
6412 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6413 sw_if_index_set = 1;
6414 else if (unformat (i, "enable"))
6416 else if (unformat (i, "disable"))
6418 else if (unformat (i, "ip4"))
6420 else if (unformat (i, "ip6"))
6426 if (sw_if_index_set == 0)
6428 errmsg ("missing interface name or sw_if_index");
6432 /* Construct the API message */
6433 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6435 mp->sw_if_index = ntohl (sw_if_index);
6436 mp->enable = is_enable;
6437 mp->is_ipv6 = is_ipv6;
6442 /* Wait for a reply... */
6448 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6450 unformat_input_t *i = vam->input;
6451 vl_api_sw_interface_set_geneve_bypass_t *mp;
6452 u32 sw_if_index = 0;
6453 u8 sw_if_index_set = 0;
6458 /* Parse args required to build the message */
6459 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6461 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6462 sw_if_index_set = 1;
6463 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6464 sw_if_index_set = 1;
6465 else if (unformat (i, "enable"))
6467 else if (unformat (i, "disable"))
6469 else if (unformat (i, "ip4"))
6471 else if (unformat (i, "ip6"))
6477 if (sw_if_index_set == 0)
6479 errmsg ("missing interface name or sw_if_index");
6483 /* Construct the API message */
6484 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6486 mp->sw_if_index = ntohl (sw_if_index);
6487 mp->enable = is_enable;
6488 mp->is_ipv6 = is_ipv6;
6493 /* Wait for a reply... */
6499 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6501 unformat_input_t *i = vam->input;
6502 vl_api_sw_interface_set_l2_xconnect_t *mp;
6504 u8 rx_sw_if_index_set = 0;
6506 u8 tx_sw_if_index_set = 0;
6510 /* Parse args required to build the message */
6511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6513 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6514 rx_sw_if_index_set = 1;
6515 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6516 tx_sw_if_index_set = 1;
6517 else if (unformat (i, "rx"))
6519 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6521 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6523 rx_sw_if_index_set = 1;
6528 else if (unformat (i, "tx"))
6530 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6532 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6534 tx_sw_if_index_set = 1;
6539 else if (unformat (i, "enable"))
6541 else if (unformat (i, "disable"))
6547 if (rx_sw_if_index_set == 0)
6549 errmsg ("missing rx interface name or rx_sw_if_index");
6553 if (enable && (tx_sw_if_index_set == 0))
6555 errmsg ("missing tx interface name or tx_sw_if_index");
6559 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6561 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6562 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6563 mp->enable = enable;
6571 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6573 unformat_input_t *i = vam->input;
6574 vl_api_sw_interface_set_l2_bridge_t *mp;
6575 vl_api_l2_port_type_t port_type;
6577 u8 rx_sw_if_index_set = 0;
6584 port_type = L2_API_PORT_TYPE_NORMAL;
6586 /* Parse args required to build the message */
6587 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6589 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6590 rx_sw_if_index_set = 1;
6591 else if (unformat (i, "bd_id %d", &bd_id))
6595 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6596 rx_sw_if_index_set = 1;
6597 else if (unformat (i, "shg %d", &shg))
6599 else if (unformat (i, "bvi"))
6600 port_type = L2_API_PORT_TYPE_BVI;
6601 else if (unformat (i, "uu-fwd"))
6602 port_type = L2_API_PORT_TYPE_UU_FWD;
6603 else if (unformat (i, "enable"))
6605 else if (unformat (i, "disable"))
6611 if (rx_sw_if_index_set == 0)
6613 errmsg ("missing rx interface name or sw_if_index");
6617 if (enable && (bd_id_set == 0))
6619 errmsg ("missing bridge domain");
6623 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6625 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6626 mp->bd_id = ntohl (bd_id);
6628 mp->port_type = ntohl (port_type);
6629 mp->enable = enable;
6637 api_bridge_domain_dump (vat_main_t * vam)
6639 unformat_input_t *i = vam->input;
6640 vl_api_bridge_domain_dump_t *mp;
6641 vl_api_control_ping_t *mp_ping;
6645 /* Parse args required to build the message */
6646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6648 if (unformat (i, "bd_id %d", &bd_id))
6654 M (BRIDGE_DOMAIN_DUMP, mp);
6655 mp->bd_id = ntohl (bd_id);
6658 /* Use a control ping for synchronization */
6659 MPING (CONTROL_PING, mp_ping);
6667 api_bridge_domain_add_del (vat_main_t * vam)
6669 unformat_input_t *i = vam->input;
6670 vl_api_bridge_domain_add_del_t *mp;
6673 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6678 /* Parse args required to build the message */
6679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6681 if (unformat (i, "bd_id %d", &bd_id))
6683 else if (unformat (i, "flood %d", &flood))
6685 else if (unformat (i, "uu-flood %d", &uu_flood))
6687 else if (unformat (i, "forward %d", &forward))
6689 else if (unformat (i, "learn %d", &learn))
6691 else if (unformat (i, "arp-term %d", &arp_term))
6693 else if (unformat (i, "mac-age %d", &mac_age))
6695 else if (unformat (i, "bd-tag %s", &bd_tag))
6697 else if (unformat (i, "del"))
6700 flood = uu_flood = forward = learn = 0;
6708 errmsg ("missing bridge domain");
6715 errmsg ("mac age must be less than 256 ");
6720 if ((bd_tag) && (vec_len (bd_tag) > 63))
6722 errmsg ("bd-tag cannot be longer than 63");
6727 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6729 mp->bd_id = ntohl (bd_id);
6731 mp->uu_flood = uu_flood;
6732 mp->forward = forward;
6734 mp->arp_term = arp_term;
6735 mp->is_add = is_add;
6736 mp->mac_age = (u8) mac_age;
6739 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6740 mp->bd_tag[vec_len (bd_tag)] = 0;
6751 api_l2fib_flush_bd (vat_main_t * vam)
6753 unformat_input_t *i = vam->input;
6754 vl_api_l2fib_flush_bd_t *mp;
6758 /* Parse args required to build the message */
6759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6761 if (unformat (i, "bd_id %d", &bd_id));
6768 errmsg ("missing bridge domain");
6772 M (L2FIB_FLUSH_BD, mp);
6774 mp->bd_id = htonl (bd_id);
6782 api_l2fib_flush_int (vat_main_t * vam)
6784 unformat_input_t *i = vam->input;
6785 vl_api_l2fib_flush_int_t *mp;
6786 u32 sw_if_index = ~0;
6789 /* Parse args required to build the message */
6790 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6792 if (unformat (i, "sw_if_index %d", &sw_if_index));
6794 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6799 if (sw_if_index == ~0)
6801 errmsg ("missing interface name or sw_if_index");
6805 M (L2FIB_FLUSH_INT, mp);
6807 mp->sw_if_index = ntohl (sw_if_index);
6815 api_l2fib_add_del (vat_main_t * vam)
6817 unformat_input_t *i = vam->input;
6818 vl_api_l2fib_add_del_t *mp;
6824 u32 sw_if_index = 0;
6825 u8 sw_if_index_set = 0;
6834 /* Parse args required to build the message */
6835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6837 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6839 else if (unformat (i, "bd_id %d", &bd_id))
6841 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6842 sw_if_index_set = 1;
6843 else if (unformat (i, "sw_if"))
6845 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6848 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6849 sw_if_index_set = 1;
6854 else if (unformat (i, "static"))
6856 else if (unformat (i, "filter"))
6861 else if (unformat (i, "bvi"))
6866 else if (unformat (i, "del"))
6868 else if (unformat (i, "count %d", &count))
6876 errmsg ("missing mac address");
6882 errmsg ("missing bridge domain");
6886 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6888 errmsg ("missing interface name or sw_if_index");
6894 /* Turn on async mode */
6895 vam->async_mode = 1;
6896 vam->async_errors = 0;
6897 before = vat_time_now (vam);
6900 for (j = 0; j < count; j++)
6902 M (L2FIB_ADD_DEL, mp);
6904 clib_memcpy (mp->mac, mac, 6);
6905 mp->bd_id = ntohl (bd_id);
6906 mp->is_add = is_add;
6907 mp->sw_if_index = ntohl (sw_if_index);
6911 mp->static_mac = static_mac;
6912 mp->filter_mac = filter_mac;
6913 mp->bvi_mac = bvi_mac;
6915 increment_mac_address (mac);
6922 vl_api_control_ping_t *mp_ping;
6925 /* Shut off async mode */
6926 vam->async_mode = 0;
6928 MPING (CONTROL_PING, mp_ping);
6931 timeout = vat_time_now (vam) + 1.0;
6932 while (vat_time_now (vam) < timeout)
6933 if (vam->result_ready == 1)
6938 if (vam->retval == -99)
6941 if (vam->async_errors > 0)
6943 errmsg ("%d asynchronous errors", vam->async_errors);
6946 vam->async_errors = 0;
6947 after = vat_time_now (vam);
6949 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6950 count, after - before, count / (after - before));
6956 /* Wait for a reply... */
6960 /* Return the good/bad news */
6961 return (vam->retval);
6965 api_bridge_domain_set_mac_age (vat_main_t * vam)
6967 unformat_input_t *i = vam->input;
6968 vl_api_bridge_domain_set_mac_age_t *mp;
6973 /* Parse args required to build the message */
6974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6976 if (unformat (i, "bd_id %d", &bd_id));
6977 else if (unformat (i, "mac-age %d", &mac_age));
6984 errmsg ("missing bridge domain");
6990 errmsg ("mac age must be less than 256 ");
6994 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6996 mp->bd_id = htonl (bd_id);
6997 mp->mac_age = (u8) mac_age;
7005 api_l2_flags (vat_main_t * vam)
7007 unformat_input_t *i = vam->input;
7008 vl_api_l2_flags_t *mp;
7011 u8 sw_if_index_set = 0;
7015 /* Parse args required to build the message */
7016 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7018 if (unformat (i, "sw_if_index %d", &sw_if_index))
7019 sw_if_index_set = 1;
7020 else if (unformat (i, "sw_if"))
7022 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7025 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7026 sw_if_index_set = 1;
7031 else if (unformat (i, "learn"))
7033 else if (unformat (i, "forward"))
7035 else if (unformat (i, "flood"))
7037 else if (unformat (i, "uu-flood"))
7038 flags |= L2_UU_FLOOD;
7039 else if (unformat (i, "arp-term"))
7040 flags |= L2_ARP_TERM;
7041 else if (unformat (i, "off"))
7043 else if (unformat (i, "disable"))
7049 if (sw_if_index_set == 0)
7051 errmsg ("missing interface name or sw_if_index");
7057 mp->sw_if_index = ntohl (sw_if_index);
7058 mp->feature_bitmap = ntohl (flags);
7059 mp->is_set = is_set;
7067 api_bridge_flags (vat_main_t * vam)
7069 unformat_input_t *i = vam->input;
7070 vl_api_bridge_flags_t *mp;
7074 bd_flags_t flags = 0;
7077 /* Parse args required to build the message */
7078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7080 if (unformat (i, "bd_id %d", &bd_id))
7082 else if (unformat (i, "learn"))
7083 flags |= BRIDGE_API_FLAG_LEARN;
7084 else if (unformat (i, "forward"))
7085 flags |= BRIDGE_API_FLAG_FWD;
7086 else if (unformat (i, "flood"))
7087 flags |= BRIDGE_API_FLAG_FLOOD;
7088 else if (unformat (i, "uu-flood"))
7089 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7090 else if (unformat (i, "arp-term"))
7091 flags |= BRIDGE_API_FLAG_ARP_TERM;
7092 else if (unformat (i, "off"))
7094 else if (unformat (i, "disable"))
7102 errmsg ("missing bridge domain");
7106 M (BRIDGE_FLAGS, mp);
7108 mp->bd_id = ntohl (bd_id);
7109 mp->flags = ntohl (flags);
7110 mp->is_set = is_set;
7118 api_bd_ip_mac_add_del (vat_main_t * vam)
7120 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7121 vl_api_mac_address_t mac = { 0 };
7122 unformat_input_t *i = vam->input;
7123 vl_api_bd_ip_mac_add_del_t *mp;
7132 /* Parse args required to build the message */
7133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7135 if (unformat (i, "bd_id %d", &bd_id))
7139 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7143 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7147 else if (unformat (i, "del"))
7155 errmsg ("missing bridge domain");
7158 else if (ip_set == 0)
7160 errmsg ("missing IP address");
7163 else if (mac_set == 0)
7165 errmsg ("missing MAC address");
7169 M (BD_IP_MAC_ADD_DEL, mp);
7171 mp->entry.bd_id = ntohl (bd_id);
7172 mp->is_add = is_add;
7174 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7175 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7183 api_bd_ip_mac_flush (vat_main_t * vam)
7185 unformat_input_t *i = vam->input;
7186 vl_api_bd_ip_mac_flush_t *mp;
7191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7193 if (unformat (i, "bd_id %d", &bd_id))
7203 errmsg ("missing bridge domain");
7207 M (BD_IP_MAC_FLUSH, mp);
7209 mp->bd_id = ntohl (bd_id);
7216 static void vl_api_bd_ip_mac_details_t_handler
7217 (vl_api_bd_ip_mac_details_t * mp)
7219 vat_main_t *vam = &vat_main;
7223 ntohl (mp->entry.bd_id),
7224 format_vl_api_mac_address, mp->entry.mac,
7225 format_vl_api_address, &mp->entry.ip);
7228 static void vl_api_bd_ip_mac_details_t_handler_json
7229 (vl_api_bd_ip_mac_details_t * mp)
7231 vat_main_t *vam = &vat_main;
7232 vat_json_node_t *node = NULL;
7234 if (VAT_JSON_ARRAY != vam->json_tree.type)
7236 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7237 vat_json_init_array (&vam->json_tree);
7239 node = vat_json_array_add (&vam->json_tree);
7241 vat_json_init_object (node);
7242 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7243 vat_json_object_add_string_copy (node, "mac_address",
7244 format (0, "%U", format_vl_api_mac_address,
7248 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7249 vat_json_object_add_string_copy (node, "ip_address", ip);
7254 api_bd_ip_mac_dump (vat_main_t * vam)
7256 unformat_input_t *i = vam->input;
7257 vl_api_bd_ip_mac_dump_t *mp;
7258 vl_api_control_ping_t *mp_ping;
7263 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7265 if (unformat (i, "bd_id %d", &bd_id))
7274 "\n%-5s %-7s %-20s %-30s",
7275 "bd_id", "is_ipv6", "mac_address", "ip_address");
7277 /* Dump Bridge Domain Ip to Mac entries */
7278 M (BD_IP_MAC_DUMP, mp);
7281 mp->bd_id = htonl (bd_id);
7287 /* Use a control ping for synchronization */
7288 MPING (CONTROL_PING, mp_ping);
7296 api_tap_create_v2 (vat_main_t * vam)
7298 unformat_input_t *i = vam->input;
7299 vl_api_tap_create_v2_t *mp;
7303 u32 num_rx_queues = 0;
7304 u8 *host_if_name = 0;
7305 u8 host_if_name_set = 0;
7308 u8 host_mac_addr[6];
7309 u8 host_mac_addr_set = 0;
7310 u8 *host_bridge = 0;
7311 u8 host_bridge_set = 0;
7312 u8 host_ip4_prefix_set = 0;
7313 u8 host_ip6_prefix_set = 0;
7314 ip4_address_t host_ip4_addr;
7315 ip4_address_t host_ip4_gw;
7316 u8 host_ip4_gw_set = 0;
7317 u32 host_ip4_prefix_len = 0;
7318 ip6_address_t host_ip6_addr;
7319 ip6_address_t host_ip6_gw;
7320 u8 host_ip6_gw_set = 0;
7321 u32 host_ip6_prefix_len = 0;
7322 u32 host_mtu_size = 0;
7323 u8 host_mtu_set = 0;
7326 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7328 clib_memset (mac_address, 0, sizeof (mac_address));
7330 /* Parse args required to build the message */
7331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7333 if (unformat (i, "id %u", &id))
7337 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7339 else if (unformat (i, "host-if-name %s", &host_if_name))
7340 host_if_name_set = 1;
7341 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
7343 else if (unformat (i, "host-ns %s", &host_ns))
7345 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7347 host_mac_addr_set = 1;
7348 else if (unformat (i, "host-bridge %s", &host_bridge))
7349 host_bridge_set = 1;
7350 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
7351 &host_ip4_addr, &host_ip4_prefix_len))
7352 host_ip4_prefix_set = 1;
7353 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
7354 &host_ip6_addr, &host_ip6_prefix_len))
7355 host_ip6_prefix_set = 1;
7356 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7358 host_ip4_gw_set = 1;
7359 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7361 host_ip6_gw_set = 1;
7362 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7364 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7366 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
7368 else if (unformat (i, "no-gso"))
7369 tap_flags &= ~TAP_FLAG_GSO;
7370 else if (unformat (i, "gso"))
7371 tap_flags |= TAP_FLAG_GSO;
7372 else if (unformat (i, "csum-offload"))
7373 tap_flags |= TAP_FLAG_CSUM_OFFLOAD;
7378 if (vec_len (host_if_name) > 63)
7380 errmsg ("tap name too long. ");
7383 if (vec_len (host_ns) > 63)
7385 errmsg ("host name space too long. ");
7388 if (vec_len (host_bridge) > 63)
7390 errmsg ("host bridge name too long. ");
7393 if (host_ip4_prefix_len > 32)
7395 errmsg ("host ip4 prefix length not valid. ");
7398 if (host_ip6_prefix_len > 128)
7400 errmsg ("host ip6 prefix length not valid. ");
7403 if (!is_pow2 (rx_ring_sz))
7405 errmsg ("rx ring size must be power of 2. ");
7408 if (rx_ring_sz > 32768)
7410 errmsg ("rx ring size must be 32768 or lower. ");
7413 if (!is_pow2 (tx_ring_sz))
7415 errmsg ("tx ring size must be power of 2. ");
7418 if (tx_ring_sz > 32768)
7420 errmsg ("tx ring size must be 32768 or lower. ");
7423 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7425 errmsg ("host MTU size must be in between 64 and 65355. ");
7429 /* Construct the API message */
7430 M (TAP_CREATE_V2, mp);
7432 mp->id = ntohl (id);
7433 mp->use_random_mac = random_mac;
7434 mp->num_rx_queues = (u8) num_rx_queues;
7435 mp->tx_ring_sz = ntohs (tx_ring_sz);
7436 mp->rx_ring_sz = ntohs (rx_ring_sz);
7437 mp->host_mtu_set = host_mtu_set;
7438 mp->host_mtu_size = ntohl (host_mtu_size);
7439 mp->host_mac_addr_set = host_mac_addr_set;
7440 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7441 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7442 mp->host_ip4_gw_set = host_ip4_gw_set;
7443 mp->host_ip6_gw_set = host_ip6_gw_set;
7444 mp->tap_flags = ntohl (tap_flags);
7445 mp->host_namespace_set = host_ns_set;
7446 mp->host_if_name_set = host_if_name_set;
7447 mp->host_bridge_set = host_bridge_set;
7449 if (random_mac == 0)
7450 clib_memcpy (mp->mac_address, mac_address, 6);
7451 if (host_mac_addr_set)
7452 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7453 if (host_if_name_set)
7454 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7456 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7457 if (host_bridge_set)
7458 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7459 if (host_ip4_prefix_set)
7461 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7462 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7464 if (host_ip6_prefix_set)
7466 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7467 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7469 if (host_ip4_gw_set)
7470 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7471 if (host_ip6_gw_set)
7472 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7475 vec_free (host_if_name);
7476 vec_free (host_bridge);
7481 /* Wait for a reply... */
7487 api_tap_delete_v2 (vat_main_t * vam)
7489 unformat_input_t *i = vam->input;
7490 vl_api_tap_delete_v2_t *mp;
7491 u32 sw_if_index = ~0;
7492 u8 sw_if_index_set = 0;
7495 /* Parse args required to build the message */
7496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7498 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7499 sw_if_index_set = 1;
7500 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7501 sw_if_index_set = 1;
7506 if (sw_if_index_set == 0)
7508 errmsg ("missing vpp interface name. ");
7512 /* Construct the API message */
7513 M (TAP_DELETE_V2, mp);
7515 mp->sw_if_index = ntohl (sw_if_index);
7520 /* Wait for a reply... */
7526 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7528 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7531 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7534 addr->domain = x[0];
7537 addr->function = x[3];
7543 api_virtio_pci_create (vat_main_t * vam)
7545 unformat_input_t *i = vam->input;
7546 vl_api_virtio_pci_create_t *mp;
7550 u8 checksum_offload_enabled = 0;
7552 u64 features = (u64) ~ (0ULL);
7555 clib_memset (mac_address, 0, sizeof (mac_address));
7557 /* Parse args required to build the message */
7558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7560 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7564 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7566 else if (unformat (i, "features 0x%llx", &features))
7568 else if (unformat (i, "gso-enabled"))
7570 else if (unformat (i, "csum-offload-enabled"))
7571 checksum_offload_enabled = 1;
7578 errmsg ("pci address must be non zero. ");
7582 /* Construct the API message */
7583 M (VIRTIO_PCI_CREATE, mp);
7585 mp->use_random_mac = random_mac;
7587 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7588 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7589 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7590 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7592 mp->features = clib_host_to_net_u64 (features);
7593 mp->gso_enabled = gso_enabled;
7594 mp->checksum_offload_enabled = checksum_offload_enabled;
7596 if (random_mac == 0)
7597 clib_memcpy (mp->mac_address, mac_address, 6);
7602 /* Wait for a reply... */
7608 api_virtio_pci_delete (vat_main_t * vam)
7610 unformat_input_t *i = vam->input;
7611 vl_api_virtio_pci_delete_t *mp;
7612 u32 sw_if_index = ~0;
7613 u8 sw_if_index_set = 0;
7616 /* Parse args required to build the message */
7617 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7619 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7620 sw_if_index_set = 1;
7621 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7622 sw_if_index_set = 1;
7627 if (sw_if_index_set == 0)
7629 errmsg ("missing vpp interface name. ");
7633 /* Construct the API message */
7634 M (VIRTIO_PCI_DELETE, mp);
7636 mp->sw_if_index = htonl (sw_if_index);
7641 /* Wait for a reply... */
7647 api_bond_create (vat_main_t * vam)
7649 unformat_input_t *i = vam->input;
7650 vl_api_bond_create_t *mp;
7660 clib_memset (mac_address, 0, sizeof (mac_address));
7663 /* Parse args required to build the message */
7664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7666 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7668 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7669 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7671 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7674 else if (unformat (i, "numa-only"))
7676 else if (unformat (i, "id %u", &id))
7682 if (mode_is_set == 0)
7684 errmsg ("Missing bond mode. ");
7688 /* Construct the API message */
7689 M (BOND_CREATE, mp);
7691 mp->use_custom_mac = custom_mac;
7693 mp->mode = htonl (mode);
7694 mp->lb = htonl (lb);
7695 mp->id = htonl (id);
7696 mp->numa_only = numa_only;
7699 clib_memcpy (mp->mac_address, mac_address, 6);
7704 /* Wait for a reply... */
7710 api_bond_delete (vat_main_t * vam)
7712 unformat_input_t *i = vam->input;
7713 vl_api_bond_delete_t *mp;
7714 u32 sw_if_index = ~0;
7715 u8 sw_if_index_set = 0;
7718 /* Parse args required to build the message */
7719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7721 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7722 sw_if_index_set = 1;
7723 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7724 sw_if_index_set = 1;
7729 if (sw_if_index_set == 0)
7731 errmsg ("missing vpp interface name. ");
7735 /* Construct the API message */
7736 M (BOND_DELETE, mp);
7738 mp->sw_if_index = ntohl (sw_if_index);
7743 /* Wait for a reply... */
7749 api_bond_enslave (vat_main_t * vam)
7751 unformat_input_t *i = vam->input;
7752 vl_api_bond_enslave_t *mp;
7753 u32 bond_sw_if_index;
7757 u32 bond_sw_if_index_is_set = 0;
7759 u8 sw_if_index_is_set = 0;
7761 /* Parse args required to build the message */
7762 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7764 if (unformat (i, "sw_if_index %d", &sw_if_index))
7765 sw_if_index_is_set = 1;
7766 else if (unformat (i, "bond %u", &bond_sw_if_index))
7767 bond_sw_if_index_is_set = 1;
7768 else if (unformat (i, "passive %d", &is_passive))
7770 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7776 if (bond_sw_if_index_is_set == 0)
7778 errmsg ("Missing bond sw_if_index. ");
7781 if (sw_if_index_is_set == 0)
7783 errmsg ("Missing slave sw_if_index. ");
7787 /* Construct the API message */
7788 M (BOND_ENSLAVE, mp);
7790 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7791 mp->sw_if_index = ntohl (sw_if_index);
7792 mp->is_long_timeout = is_long_timeout;
7793 mp->is_passive = is_passive;
7798 /* Wait for a reply... */
7804 api_bond_detach_slave (vat_main_t * vam)
7806 unformat_input_t *i = vam->input;
7807 vl_api_bond_detach_slave_t *mp;
7808 u32 sw_if_index = ~0;
7809 u8 sw_if_index_set = 0;
7812 /* Parse args required to build the message */
7813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7815 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7816 sw_if_index_set = 1;
7817 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7818 sw_if_index_set = 1;
7823 if (sw_if_index_set == 0)
7825 errmsg ("missing vpp interface name. ");
7829 /* Construct the API message */
7830 M (BOND_DETACH_SLAVE, mp);
7832 mp->sw_if_index = ntohl (sw_if_index);
7837 /* Wait for a reply... */
7843 api_ip_table_add_del (vat_main_t * vam)
7845 unformat_input_t *i = vam->input;
7846 vl_api_ip_table_add_del_t *mp;
7852 /* Parse args required to build the message */
7853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7855 if (unformat (i, "ipv6"))
7857 else if (unformat (i, "del"))
7859 else if (unformat (i, "add"))
7861 else if (unformat (i, "table %d", &table_id))
7865 clib_warning ("parse error '%U'", format_unformat_error, i);
7872 errmsg ("missing table-ID");
7876 /* Construct the API message */
7877 M (IP_TABLE_ADD_DEL, mp);
7879 mp->table.table_id = ntohl (table_id);
7880 mp->table.is_ip6 = is_ipv6;
7881 mp->is_add = is_add;
7886 /* Wait for a reply... */
7893 unformat_fib_path (unformat_input_t * input, va_list * args)
7895 vat_main_t *vam = va_arg (*args, vat_main_t *);
7896 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7897 u32 weight, preference;
7898 mpls_label_t out_label;
7900 clib_memset (path, 0, sizeof (*path));
7902 path->sw_if_index = ~0;
7906 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7908 if (unformat (input, "%U %U",
7909 unformat_vl_api_ip4_address,
7910 &path->nh.address.ip4,
7911 api_unformat_sw_if_index, vam, &path->sw_if_index))
7913 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7915 else if (unformat (input, "%U %U",
7916 unformat_vl_api_ip6_address,
7917 &path->nh.address.ip6,
7918 api_unformat_sw_if_index, vam, &path->sw_if_index))
7920 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7922 else if (unformat (input, "weight %u", &weight))
7924 path->weight = weight;
7926 else if (unformat (input, "preference %u", &preference))
7928 path->preference = preference;
7930 else if (unformat (input, "%U next-hop-table %d",
7931 unformat_vl_api_ip4_address,
7932 &path->nh.address.ip4, &path->table_id))
7934 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7936 else if (unformat (input, "%U next-hop-table %d",
7937 unformat_vl_api_ip6_address,
7938 &path->nh.address.ip6, &path->table_id))
7940 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7942 else if (unformat (input, "%U",
7943 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7946 * the recursive next-hops are by default in the default table
7949 path->sw_if_index = ~0;
7950 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7952 else if (unformat (input, "%U",
7953 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7956 * the recursive next-hops are by default in the default table
7959 path->sw_if_index = ~0;
7960 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7962 else if (unformat (input, "resolve-via-host"))
7964 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7966 else if (unformat (input, "resolve-via-attached"))
7968 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7970 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7972 path->type = FIB_API_PATH_TYPE_LOCAL;
7973 path->sw_if_index = ~0;
7974 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7976 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7978 path->type = FIB_API_PATH_TYPE_LOCAL;
7979 path->sw_if_index = ~0;
7980 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7982 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7984 else if (unformat (input, "via-label %d", &path->nh.via_label))
7986 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7987 path->sw_if_index = ~0;
7989 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7991 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7992 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7994 else if (unformat (input, "local"))
7996 path->type = FIB_API_PATH_TYPE_LOCAL;
7998 else if (unformat (input, "out-labels"))
8000 while (unformat (input, "%d", &out_label))
8002 path->label_stack[path->n_labels].label = out_label;
8003 path->label_stack[path->n_labels].is_uniform = 0;
8004 path->label_stack[path->n_labels].ttl = 64;
8008 else if (unformat (input, "via"))
8010 /* new path, back up and return */
8011 unformat_put_input (input);
8012 unformat_put_input (input);
8013 unformat_put_input (input);
8014 unformat_put_input (input);
8023 path->proto = ntohl (path->proto);
8024 path->type = ntohl (path->type);
8025 path->flags = ntohl (path->flags);
8026 path->table_id = ntohl (path->table_id);
8027 path->sw_if_index = ntohl (path->sw_if_index);
8033 api_ip_route_add_del (vat_main_t * vam)
8035 unformat_input_t *i = vam->input;
8036 vl_api_ip_route_add_del_t *mp;
8039 u8 is_multipath = 0;
8042 vl_api_prefix_t pfx = { };
8043 vl_api_fib_path_t paths[8];
8047 u32 random_add_del = 0;
8048 u32 *random_vector = 0;
8049 u32 random_seed = 0xdeaddabe;
8051 /* Parse args required to build the message */
8052 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8054 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8056 else if (unformat (i, "del"))
8058 else if (unformat (i, "add"))
8060 else if (unformat (i, "vrf %d", &vrf_id))
8062 else if (unformat (i, "count %d", &count))
8064 else if (unformat (i, "random"))
8066 else if (unformat (i, "multipath"))
8068 else if (unformat (i, "seed %d", &random_seed))
8072 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8075 if (8 == path_count)
8077 errmsg ("max 8 paths");
8083 clib_warning ("parse error '%U'", format_unformat_error, i);
8090 errmsg ("specify a path; via ...");
8093 if (prefix_set == 0)
8095 errmsg ("missing prefix");
8099 /* Generate a pile of unique, random routes */
8102 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8103 u32 this_random_address;
8106 random_hash = hash_create (count, sizeof (uword));
8108 hash_set (random_hash, i->as_u32, 1);
8109 for (j = 0; j <= count; j++)
8113 this_random_address = random_u32 (&random_seed);
8114 this_random_address =
8115 clib_host_to_net_u32 (this_random_address);
8117 while (hash_get (random_hash, this_random_address));
8118 vec_add1 (random_vector, this_random_address);
8119 hash_set (random_hash, this_random_address, 1);
8121 hash_free (random_hash);
8122 set_ip4_address (&pfx.address, random_vector[0]);
8127 /* Turn on async mode */
8128 vam->async_mode = 1;
8129 vam->async_errors = 0;
8130 before = vat_time_now (vam);
8133 for (j = 0; j < count; j++)
8135 /* Construct the API message */
8136 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8138 mp->is_add = is_add;
8139 mp->is_multipath = is_multipath;
8141 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8142 mp->route.table_id = ntohl (vrf_id);
8143 mp->route.n_paths = path_count;
8145 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8148 set_ip4_address (&pfx.address, random_vector[j + 1]);
8150 increment_address (&pfx.address);
8153 /* If we receive SIGTERM, stop now... */
8158 /* When testing multiple add/del ops, use a control-ping to sync */
8161 vl_api_control_ping_t *mp_ping;
8165 /* Shut off async mode */
8166 vam->async_mode = 0;
8168 MPING (CONTROL_PING, mp_ping);
8171 timeout = vat_time_now (vam) + 1.0;
8172 while (vat_time_now (vam) < timeout)
8173 if (vam->result_ready == 1)
8178 if (vam->retval == -99)
8181 if (vam->async_errors > 0)
8183 errmsg ("%d asynchronous errors", vam->async_errors);
8186 vam->async_errors = 0;
8187 after = vat_time_now (vam);
8189 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8193 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8194 count, after - before, count / (after - before));
8200 /* Wait for a reply... */
8205 /* Return the good/bad news */
8206 return (vam->retval);
8210 api_ip_mroute_add_del (vat_main_t * vam)
8212 unformat_input_t *i = vam->input;
8213 u8 path_set = 0, prefix_set = 0, is_add = 1;
8214 vl_api_ip_mroute_add_del_t *mp;
8215 mfib_entry_flags_t eflags = 0;
8216 vl_api_mfib_path_t path;
8217 vl_api_mprefix_t pfx = { };
8221 /* Parse args required to build the message */
8222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8224 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8227 pfx.grp_address_length = htons (pfx.grp_address_length);
8229 else if (unformat (i, "del"))
8231 else if (unformat (i, "add"))
8233 else if (unformat (i, "vrf %d", &vrf_id))
8235 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8236 path.itf_flags = htonl (path.itf_flags);
8237 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8239 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8243 clib_warning ("parse error '%U'", format_unformat_error, i);
8248 if (prefix_set == 0)
8250 errmsg ("missing addresses\n");
8255 errmsg ("missing path\n");
8259 /* Construct the API message */
8260 M (IP_MROUTE_ADD_DEL, mp);
8262 mp->is_add = is_add;
8263 mp->is_multipath = 1;
8265 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8266 mp->route.table_id = htonl (vrf_id);
8267 mp->route.n_paths = 1;
8268 mp->route.entry_flags = htonl (eflags);
8270 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8274 /* Wait for a reply... */
8280 api_mpls_table_add_del (vat_main_t * vam)
8282 unformat_input_t *i = vam->input;
8283 vl_api_mpls_table_add_del_t *mp;
8288 /* Parse args required to build the message */
8289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8291 if (unformat (i, "table %d", &table_id))
8293 else if (unformat (i, "del"))
8295 else if (unformat (i, "add"))
8299 clib_warning ("parse error '%U'", format_unformat_error, i);
8306 errmsg ("missing table-ID");
8310 /* Construct the API message */
8311 M (MPLS_TABLE_ADD_DEL, mp);
8313 mp->mt_table.mt_table_id = ntohl (table_id);
8314 mp->mt_is_add = is_add;
8319 /* Wait for a reply... */
8326 api_mpls_route_add_del (vat_main_t * vam)
8328 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8329 mpls_label_t local_label = MPLS_LABEL_INVALID;
8330 unformat_input_t *i = vam->input;
8331 vl_api_mpls_route_add_del_t *mp;
8332 vl_api_fib_path_t paths[8];
8336 /* Parse args required to build the message */
8337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8339 if (unformat (i, "%d", &local_label))
8341 else if (unformat (i, "eos"))
8343 else if (unformat (i, "non-eos"))
8345 else if (unformat (i, "del"))
8347 else if (unformat (i, "add"))
8349 else if (unformat (i, "multipath"))
8351 else if (unformat (i, "count %d", &count))
8355 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8358 if (8 == path_count)
8360 errmsg ("max 8 paths");
8366 clib_warning ("parse error '%U'", format_unformat_error, i);
8373 errmsg ("specify a path; via ...");
8377 if (MPLS_LABEL_INVALID == local_label)
8379 errmsg ("missing label");
8385 /* Turn on async mode */
8386 vam->async_mode = 1;
8387 vam->async_errors = 0;
8388 before = vat_time_now (vam);
8391 for (j = 0; j < count; j++)
8393 /* Construct the API message */
8394 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8396 mp->mr_is_add = is_add;
8397 mp->mr_is_multipath = is_multipath;
8399 mp->mr_route.mr_label = local_label;
8400 mp->mr_route.mr_eos = is_eos;
8401 mp->mr_route.mr_table_id = 0;
8402 mp->mr_route.mr_n_paths = path_count;
8404 clib_memcpy (&mp->mr_route.mr_paths, paths,
8405 sizeof (paths[0]) * path_count);
8411 /* If we receive SIGTERM, stop now... */
8416 /* When testing multiple add/del ops, use a control-ping to sync */
8419 vl_api_control_ping_t *mp_ping;
8423 /* Shut off async mode */
8424 vam->async_mode = 0;
8426 MPING (CONTROL_PING, mp_ping);
8429 timeout = vat_time_now (vam) + 1.0;
8430 while (vat_time_now (vam) < timeout)
8431 if (vam->result_ready == 1)
8436 if (vam->retval == -99)
8439 if (vam->async_errors > 0)
8441 errmsg ("%d asynchronous errors", vam->async_errors);
8444 vam->async_errors = 0;
8445 after = vat_time_now (vam);
8447 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8451 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8452 count, after - before, count / (after - before));
8458 /* Wait for a reply... */
8463 /* Return the good/bad news */
8464 return (vam->retval);
8469 api_mpls_ip_bind_unbind (vat_main_t * vam)
8471 unformat_input_t *i = vam->input;
8472 vl_api_mpls_ip_bind_unbind_t *mp;
8473 u32 ip_table_id = 0;
8475 vl_api_prefix_t pfx;
8477 mpls_label_t local_label = MPLS_LABEL_INVALID;
8480 /* Parse args required to build the message */
8481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8483 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8485 else if (unformat (i, "%d", &local_label))
8487 else if (unformat (i, "table-id %d", &ip_table_id))
8489 else if (unformat (i, "unbind"))
8491 else if (unformat (i, "bind"))
8495 clib_warning ("parse error '%U'", format_unformat_error, i);
8502 errmsg ("IP prefix not set");
8506 if (MPLS_LABEL_INVALID == local_label)
8508 errmsg ("missing label");
8512 /* Construct the API message */
8513 M (MPLS_IP_BIND_UNBIND, mp);
8515 mp->mb_is_bind = is_bind;
8516 mp->mb_ip_table_id = ntohl (ip_table_id);
8517 mp->mb_mpls_table_id = 0;
8518 mp->mb_label = ntohl (local_label);
8519 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8524 /* Wait for a reply... */
8531 api_sr_mpls_policy_add (vat_main_t * vam)
8533 unformat_input_t *i = vam->input;
8534 vl_api_sr_mpls_policy_add_t *mp;
8540 u32 *segments = NULL;
8543 /* Parse args required to build the message */
8544 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8546 if (unformat (i, "bsid %d", &bsid))
8548 else if (unformat (i, "weight %d", &weight))
8550 else if (unformat (i, "spray"))
8552 else if (unformat (i, "next %d", &sid))
8555 vec_add1 (segments, htonl (sid));
8559 clib_warning ("parse error '%U'", format_unformat_error, i);
8566 errmsg ("bsid not set");
8570 if (n_segments == 0)
8572 errmsg ("no sid in segment stack");
8576 /* Construct the API message */
8577 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8579 mp->bsid = htonl (bsid);
8580 mp->weight = htonl (weight);
8581 mp->is_spray = type;
8582 mp->n_segments = n_segments;
8583 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8584 vec_free (segments);
8589 /* Wait for a reply... */
8595 api_sr_mpls_policy_del (vat_main_t * vam)
8597 unformat_input_t *i = vam->input;
8598 vl_api_sr_mpls_policy_del_t *mp;
8602 /* Parse args required to build the message */
8603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8605 if (unformat (i, "bsid %d", &bsid))
8609 clib_warning ("parse error '%U'", format_unformat_error, i);
8616 errmsg ("bsid not set");
8620 /* Construct the API message */
8621 M (SR_MPLS_POLICY_DEL, mp);
8623 mp->bsid = htonl (bsid);
8628 /* Wait for a reply... */
8634 api_bier_table_add_del (vat_main_t * vam)
8636 unformat_input_t *i = vam->input;
8637 vl_api_bier_table_add_del_t *mp;
8639 u32 set = 0, sub_domain = 0, hdr_len = 3;
8640 mpls_label_t local_label = MPLS_LABEL_INVALID;
8643 /* Parse args required to build the message */
8644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8646 if (unformat (i, "sub-domain %d", &sub_domain))
8648 else if (unformat (i, "set %d", &set))
8650 else if (unformat (i, "label %d", &local_label))
8652 else if (unformat (i, "hdr-len %d", &hdr_len))
8654 else if (unformat (i, "add"))
8656 else if (unformat (i, "del"))
8660 clib_warning ("parse error '%U'", format_unformat_error, i);
8665 if (MPLS_LABEL_INVALID == local_label)
8667 errmsg ("missing label\n");
8671 /* Construct the API message */
8672 M (BIER_TABLE_ADD_DEL, mp);
8674 mp->bt_is_add = is_add;
8675 mp->bt_label = ntohl (local_label);
8676 mp->bt_tbl_id.bt_set = set;
8677 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8678 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8683 /* Wait for a reply... */
8690 api_bier_route_add_del (vat_main_t * vam)
8692 unformat_input_t *i = vam->input;
8693 vl_api_bier_route_add_del_t *mp;
8695 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8696 ip4_address_t v4_next_hop_address;
8697 ip6_address_t v6_next_hop_address;
8698 u8 next_hop_set = 0;
8699 u8 next_hop_proto_is_ip4 = 1;
8700 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8703 /* Parse args required to build the message */
8704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8706 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8708 next_hop_proto_is_ip4 = 1;
8711 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8713 next_hop_proto_is_ip4 = 0;
8716 if (unformat (i, "sub-domain %d", &sub_domain))
8718 else if (unformat (i, "set %d", &set))
8720 else if (unformat (i, "hdr-len %d", &hdr_len))
8722 else if (unformat (i, "bp %d", &bp))
8724 else if (unformat (i, "add"))
8726 else if (unformat (i, "del"))
8728 else if (unformat (i, "out-label %d", &next_hop_out_label))
8732 clib_warning ("parse error '%U'", format_unformat_error, i);
8737 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8739 errmsg ("next hop / label set\n");
8744 errmsg ("bit=position not set\n");
8748 /* Construct the API message */
8749 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8751 mp->br_is_add = is_add;
8752 mp->br_route.br_tbl_id.bt_set = set;
8753 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8754 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8755 mp->br_route.br_bp = ntohs (bp);
8756 mp->br_route.br_n_paths = 1;
8757 mp->br_route.br_paths[0].n_labels = 1;
8758 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8759 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8760 FIB_API_PATH_NH_PROTO_IP4 :
8761 FIB_API_PATH_NH_PROTO_IP6);
8763 if (next_hop_proto_is_ip4)
8765 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8766 &v4_next_hop_address, sizeof (v4_next_hop_address));
8770 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8771 &v6_next_hop_address, sizeof (v6_next_hop_address));
8777 /* Wait for a reply... */
8784 api_mpls_tunnel_add_del (vat_main_t * vam)
8786 unformat_input_t *i = vam->input;
8787 vl_api_mpls_tunnel_add_del_t *mp;
8789 vl_api_fib_path_t paths[8];
8790 u32 sw_if_index = ~0;
8796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8798 if (unformat (i, "add"))
8802 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8804 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8806 else if (unformat (i, "l2-only"))
8810 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8813 if (8 == path_count)
8815 errmsg ("max 8 paths");
8821 clib_warning ("parse error '%U'", format_unformat_error, i);
8826 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8828 mp->mt_is_add = is_add;
8829 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8830 mp->mt_tunnel.mt_l2_only = l2_only;
8831 mp->mt_tunnel.mt_is_multicast = 0;
8832 mp->mt_tunnel.mt_n_paths = path_count;
8834 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8835 sizeof (paths[0]) * path_count);
8843 api_sw_interface_set_unnumbered (vat_main_t * vam)
8845 unformat_input_t *i = vam->input;
8846 vl_api_sw_interface_set_unnumbered_t *mp;
8848 u32 unnum_sw_index = ~0;
8850 u8 sw_if_index_set = 0;
8853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8855 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8856 sw_if_index_set = 1;
8857 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8858 sw_if_index_set = 1;
8859 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8861 else if (unformat (i, "del"))
8865 clib_warning ("parse error '%U'", format_unformat_error, i);
8870 if (sw_if_index_set == 0)
8872 errmsg ("missing interface name or sw_if_index");
8876 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8878 mp->sw_if_index = ntohl (sw_if_index);
8879 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8880 mp->is_add = is_add;
8889 api_create_vlan_subif (vat_main_t * vam)
8891 unformat_input_t *i = vam->input;
8892 vl_api_create_vlan_subif_t *mp;
8894 u8 sw_if_index_set = 0;
8899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8901 if (unformat (i, "sw_if_index %d", &sw_if_index))
8902 sw_if_index_set = 1;
8904 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8905 sw_if_index_set = 1;
8906 else if (unformat (i, "vlan %d", &vlan_id))
8910 clib_warning ("parse error '%U'", format_unformat_error, i);
8915 if (sw_if_index_set == 0)
8917 errmsg ("missing interface name or sw_if_index");
8921 if (vlan_id_set == 0)
8923 errmsg ("missing vlan_id");
8926 M (CREATE_VLAN_SUBIF, mp);
8928 mp->sw_if_index = ntohl (sw_if_index);
8929 mp->vlan_id = ntohl (vlan_id);
8936 #define foreach_create_subif_bit \
8943 _(outer_vlan_id_any) \
8944 _(inner_vlan_id_any)
8946 #define foreach_create_subif_flag \
8951 _(4, "exact_match") \
8952 _(5, "default_sub") \
8953 _(6, "outer_vlan_id_any") \
8954 _(7, "inner_vlan_id_any")
8957 api_create_subif (vat_main_t * vam)
8959 unformat_input_t *i = vam->input;
8960 vl_api_create_subif_t *mp;
8962 u8 sw_if_index_set = 0;
8965 u32 __attribute__ ((unused)) no_tags = 0;
8966 u32 __attribute__ ((unused)) one_tag = 0;
8967 u32 __attribute__ ((unused)) two_tags = 0;
8968 u32 __attribute__ ((unused)) dot1ad = 0;
8969 u32 __attribute__ ((unused)) exact_match = 0;
8970 u32 __attribute__ ((unused)) default_sub = 0;
8971 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8972 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8974 u16 outer_vlan_id = 0;
8975 u16 inner_vlan_id = 0;
8978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8980 if (unformat (i, "sw_if_index %d", &sw_if_index))
8981 sw_if_index_set = 1;
8983 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8984 sw_if_index_set = 1;
8985 else if (unformat (i, "sub_id %d", &sub_id))
8987 else if (unformat (i, "outer_vlan_id %d", &tmp))
8988 outer_vlan_id = tmp;
8989 else if (unformat (i, "inner_vlan_id %d", &tmp))
8990 inner_vlan_id = tmp;
8992 #define _(a) else if (unformat (i, #a)) a = 1 ;
8993 foreach_create_subif_bit
8997 clib_warning ("parse error '%U'", format_unformat_error, i);
9002 if (sw_if_index_set == 0)
9004 errmsg ("missing interface name or sw_if_index");
9008 if (sub_id_set == 0)
9010 errmsg ("missing sub_id");
9013 M (CREATE_SUBIF, mp);
9015 mp->sw_if_index = ntohl (sw_if_index);
9016 mp->sub_id = ntohl (sub_id);
9018 #define _(a,b) mp->sub_if_flags |= (1 << a);
9019 foreach_create_subif_flag;
9022 mp->outer_vlan_id = ntohs (outer_vlan_id);
9023 mp->inner_vlan_id = ntohs (inner_vlan_id);
9031 api_ip_table_replace_begin (vat_main_t * vam)
9033 unformat_input_t *i = vam->input;
9034 vl_api_ip_table_replace_begin_t *mp;
9039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9041 if (unformat (i, "table %d", &table_id))
9043 else if (unformat (i, "ipv6"))
9047 clib_warning ("parse error '%U'", format_unformat_error, i);
9052 M (IP_TABLE_REPLACE_BEGIN, mp);
9054 mp->table.table_id = ntohl (table_id);
9055 mp->table.is_ip6 = is_ipv6;
9063 api_ip_table_flush (vat_main_t * vam)
9065 unformat_input_t *i = vam->input;
9066 vl_api_ip_table_flush_t *mp;
9071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9073 if (unformat (i, "table %d", &table_id))
9075 else if (unformat (i, "ipv6"))
9079 clib_warning ("parse error '%U'", format_unformat_error, i);
9084 M (IP_TABLE_FLUSH, mp);
9086 mp->table.table_id = ntohl (table_id);
9087 mp->table.is_ip6 = is_ipv6;
9095 api_ip_table_replace_end (vat_main_t * vam)
9097 unformat_input_t *i = vam->input;
9098 vl_api_ip_table_replace_end_t *mp;
9103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9105 if (unformat (i, "table %d", &table_id))
9107 else if (unformat (i, "ipv6"))
9111 clib_warning ("parse error '%U'", format_unformat_error, i);
9116 M (IP_TABLE_REPLACE_END, mp);
9118 mp->table.table_id = ntohl (table_id);
9119 mp->table.is_ip6 = is_ipv6;
9127 api_set_ip_flow_hash (vat_main_t * vam)
9129 unformat_input_t *i = vam->input;
9130 vl_api_set_ip_flow_hash_t *mp;
9142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9144 if (unformat (i, "vrf %d", &vrf_id))
9146 else if (unformat (i, "ipv6"))
9148 else if (unformat (i, "src"))
9150 else if (unformat (i, "dst"))
9152 else if (unformat (i, "sport"))
9154 else if (unformat (i, "dport"))
9156 else if (unformat (i, "proto"))
9158 else if (unformat (i, "reverse"))
9163 clib_warning ("parse error '%U'", format_unformat_error, i);
9168 if (vrf_id_set == 0)
9170 errmsg ("missing vrf id");
9174 M (SET_IP_FLOW_HASH, mp);
9180 mp->reverse = reverse;
9181 mp->vrf_id = ntohl (vrf_id);
9182 mp->is_ipv6 = is_ipv6;
9190 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9192 unformat_input_t *i = vam->input;
9193 vl_api_sw_interface_ip6_enable_disable_t *mp;
9195 u8 sw_if_index_set = 0;
9199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9201 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9202 sw_if_index_set = 1;
9203 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9204 sw_if_index_set = 1;
9205 else if (unformat (i, "enable"))
9207 else if (unformat (i, "disable"))
9211 clib_warning ("parse error '%U'", format_unformat_error, i);
9216 if (sw_if_index_set == 0)
9218 errmsg ("missing interface name or sw_if_index");
9222 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9224 mp->sw_if_index = ntohl (sw_if_index);
9225 mp->enable = enable;
9234 api_l2_patch_add_del (vat_main_t * vam)
9236 unformat_input_t *i = vam->input;
9237 vl_api_l2_patch_add_del_t *mp;
9239 u8 rx_sw_if_index_set = 0;
9241 u8 tx_sw_if_index_set = 0;
9245 /* Parse args required to build the message */
9246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9248 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9249 rx_sw_if_index_set = 1;
9250 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9251 tx_sw_if_index_set = 1;
9252 else if (unformat (i, "rx"))
9254 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9256 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9258 rx_sw_if_index_set = 1;
9263 else if (unformat (i, "tx"))
9265 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9267 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9269 tx_sw_if_index_set = 1;
9274 else if (unformat (i, "del"))
9280 if (rx_sw_if_index_set == 0)
9282 errmsg ("missing rx interface name or rx_sw_if_index");
9286 if (tx_sw_if_index_set == 0)
9288 errmsg ("missing tx interface name or tx_sw_if_index");
9292 M (L2_PATCH_ADD_DEL, mp);
9294 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9295 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9296 mp->is_add = is_add;
9304 u8 localsid_addr[16];
9313 api_sr_localsid_add_del (vat_main_t * vam)
9315 unformat_input_t *i = vam->input;
9316 vl_api_sr_localsid_add_del_t *mp;
9319 ip6_address_t localsid;
9323 u32 fib_table = ~(u32) 0;
9324 ip6_address_t nh_addr6;
9325 ip4_address_t nh_addr4;
9326 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9327 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9329 bool nexthop_set = 0;
9333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9335 if (unformat (i, "del"))
9337 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9338 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9340 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9342 else if (unformat (i, "behavior %u", &behavior));
9343 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9344 else if (unformat (i, "fib-table %u", &fib_table));
9345 else if (unformat (i, "end.psp %u", &behavior));
9350 M (SR_LOCALSID_ADD_DEL, mp);
9352 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9356 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9357 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9359 mp->behavior = behavior;
9360 mp->sw_if_index = ntohl (sw_if_index);
9361 mp->fib_table = ntohl (fib_table);
9362 mp->end_psp = end_psp;
9363 mp->is_del = is_del;
9371 api_ioam_enable (vat_main_t * vam)
9373 unformat_input_t *input = vam->input;
9374 vl_api_ioam_enable_t *mp;
9376 int has_trace_option = 0;
9377 int has_pot_option = 0;
9378 int has_seqno_option = 0;
9379 int has_analyse_option = 0;
9382 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9384 if (unformat (input, "trace"))
9385 has_trace_option = 1;
9386 else if (unformat (input, "pot"))
9388 else if (unformat (input, "seqno"))
9389 has_seqno_option = 1;
9390 else if (unformat (input, "analyse"))
9391 has_analyse_option = 1;
9395 M (IOAM_ENABLE, mp);
9396 mp->id = htons (id);
9397 mp->seqno = has_seqno_option;
9398 mp->analyse = has_analyse_option;
9399 mp->pot_enable = has_pot_option;
9400 mp->trace_enable = has_trace_option;
9409 api_ioam_disable (vat_main_t * vam)
9411 vl_api_ioam_disable_t *mp;
9414 M (IOAM_DISABLE, mp);
9420 #define foreach_tcp_proto_field \
9424 #define foreach_udp_proto_field \
9428 #define foreach_ip4_proto_field \
9440 u16 src_port, dst_port;
9443 #if VPP_API_TEST_BUILTIN == 0
9445 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9447 u8 **maskp = va_arg (*args, u8 **);
9449 u8 found_something = 0;
9452 #define _(a) u8 a=0;
9453 foreach_tcp_proto_field;
9456 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9459 #define _(a) else if (unformat (input, #a)) a=1;
9460 foreach_tcp_proto_field
9466 #define _(a) found_something += a;
9467 foreach_tcp_proto_field;
9470 if (found_something == 0)
9473 vec_validate (mask, sizeof (*tcp) - 1);
9475 tcp = (tcp_header_t *) mask;
9477 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9478 foreach_tcp_proto_field;
9486 unformat_udp_mask (unformat_input_t * input, va_list * args)
9488 u8 **maskp = va_arg (*args, u8 **);
9490 u8 found_something = 0;
9493 #define _(a) u8 a=0;
9494 foreach_udp_proto_field;
9497 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9500 #define _(a) else if (unformat (input, #a)) a=1;
9501 foreach_udp_proto_field
9507 #define _(a) found_something += a;
9508 foreach_udp_proto_field;
9511 if (found_something == 0)
9514 vec_validate (mask, sizeof (*udp) - 1);
9516 udp = (udp_header_t *) mask;
9518 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9519 foreach_udp_proto_field;
9527 unformat_l4_mask (unformat_input_t * input, va_list * args)
9529 u8 **maskp = va_arg (*args, u8 **);
9530 u16 src_port = 0, dst_port = 0;
9531 tcpudp_header_t *tcpudp;
9533 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9535 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9537 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9539 else if (unformat (input, "src_port"))
9541 else if (unformat (input, "dst_port"))
9547 if (!src_port && !dst_port)
9551 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9553 tcpudp = (tcpudp_header_t *) mask;
9554 tcpudp->src_port = src_port;
9555 tcpudp->dst_port = dst_port;
9563 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9565 u8 **maskp = va_arg (*args, u8 **);
9567 u8 found_something = 0;
9570 #define _(a) u8 a=0;
9571 foreach_ip4_proto_field;
9577 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9579 if (unformat (input, "version"))
9581 else if (unformat (input, "hdr_length"))
9583 else if (unformat (input, "src"))
9585 else if (unformat (input, "dst"))
9587 else if (unformat (input, "proto"))
9590 #define _(a) else if (unformat (input, #a)) a=1;
9591 foreach_ip4_proto_field
9597 #define _(a) found_something += a;
9598 foreach_ip4_proto_field;
9601 if (found_something == 0)
9604 vec_validate (mask, sizeof (*ip) - 1);
9606 ip = (ip4_header_t *) mask;
9608 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9609 foreach_ip4_proto_field;
9612 ip->ip_version_and_header_length = 0;
9615 ip->ip_version_and_header_length |= 0xF0;
9618 ip->ip_version_and_header_length |= 0x0F;
9624 #define foreach_ip6_proto_field \
9632 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9634 u8 **maskp = va_arg (*args, u8 **);
9636 u8 found_something = 0;
9638 u32 ip_version_traffic_class_and_flow_label;
9640 #define _(a) u8 a=0;
9641 foreach_ip6_proto_field;
9644 u8 traffic_class = 0;
9647 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9649 if (unformat (input, "version"))
9651 else if (unformat (input, "traffic-class"))
9653 else if (unformat (input, "flow-label"))
9655 else if (unformat (input, "src"))
9657 else if (unformat (input, "dst"))
9659 else if (unformat (input, "proto"))
9662 #define _(a) else if (unformat (input, #a)) a=1;
9663 foreach_ip6_proto_field
9669 #define _(a) found_something += a;
9670 foreach_ip6_proto_field;
9673 if (found_something == 0)
9676 vec_validate (mask, sizeof (*ip) - 1);
9678 ip = (ip6_header_t *) mask;
9680 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9681 foreach_ip6_proto_field;
9684 ip_version_traffic_class_and_flow_label = 0;
9687 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9690 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9693 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9695 ip->ip_version_traffic_class_and_flow_label =
9696 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9703 unformat_l3_mask (unformat_input_t * input, va_list * args)
9705 u8 **maskp = va_arg (*args, u8 **);
9707 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9709 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9711 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9720 unformat_l2_mask (unformat_input_t * input, va_list * args)
9722 u8 **maskp = va_arg (*args, u8 **);
9737 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9739 if (unformat (input, "src"))
9741 else if (unformat (input, "dst"))
9743 else if (unformat (input, "proto"))
9745 else if (unformat (input, "tag1"))
9747 else if (unformat (input, "tag2"))
9749 else if (unformat (input, "ignore-tag1"))
9751 else if (unformat (input, "ignore-tag2"))
9753 else if (unformat (input, "cos1"))
9755 else if (unformat (input, "cos2"))
9757 else if (unformat (input, "dot1q"))
9759 else if (unformat (input, "dot1ad"))
9764 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9765 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9768 if (tag1 || ignore_tag1 || cos1 || dot1q)
9770 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9773 vec_validate (mask, len - 1);
9776 clib_memset (mask, 0xff, 6);
9779 clib_memset (mask + 6, 0xff, 6);
9783 /* inner vlan tag */
9792 mask[21] = mask[20] = 0xff;
9813 mask[16] = mask[17] = 0xff;
9823 mask[12] = mask[13] = 0xff;
9830 unformat_classify_mask (unformat_input_t * input, va_list * args)
9832 u8 **maskp = va_arg (*args, u8 **);
9833 u32 *skipp = va_arg (*args, u32 *);
9834 u32 *matchp = va_arg (*args, u32 *);
9842 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9844 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9846 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9848 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9850 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9864 if (mask || l2 || l3 || l4)
9868 /* "With a free Ethernet header in every package" */
9870 vec_validate (l2, 13);
9874 vec_append (mask, l3);
9879 vec_append (mask, l4);
9884 /* Scan forward looking for the first significant mask octet */
9885 for (i = 0; i < vec_len (mask); i++)
9889 /* compute (skip, match) params */
9890 *skipp = i / sizeof (u32x4);
9891 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9893 /* Pad mask to an even multiple of the vector size */
9894 while (vec_len (mask) % sizeof (u32x4))
9897 match = vec_len (mask) / sizeof (u32x4);
9899 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9901 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9902 if (*tmp || *(tmp + 1))
9907 clib_warning ("BUG: match 0");
9909 _vec_len (mask) = match * sizeof (u32x4);
9919 #endif /* VPP_API_TEST_BUILTIN */
9921 #define foreach_l2_next \
9923 _(ethernet, ETHERNET_INPUT) \
9928 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9930 u32 *miss_next_indexp = va_arg (*args, u32 *);
9935 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9939 if (unformat (input, "%d", &tmp))
9948 *miss_next_indexp = next_index;
9952 #define foreach_ip_next \
9958 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9960 u32 *miss_next_indexp = va_arg (*args, u32 *);
9965 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9969 if (unformat (input, "%d", &tmp))
9978 *miss_next_indexp = next_index;
9982 #define foreach_acl_next \
9986 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9988 u32 *miss_next_indexp = va_arg (*args, u32 *);
9993 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9997 if (unformat (input, "permit"))
10002 else if (unformat (input, "%d", &tmp))
10011 *miss_next_indexp = next_index;
10016 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10018 u32 *r = va_arg (*args, u32 *);
10020 if (unformat (input, "conform-color"))
10021 *r = POLICE_CONFORM;
10022 else if (unformat (input, "exceed-color"))
10023 *r = POLICE_EXCEED;
10031 api_classify_add_del_table (vat_main_t * vam)
10033 unformat_input_t *i = vam->input;
10034 vl_api_classify_add_del_table_t *mp;
10041 u32 table_index = ~0;
10042 u32 next_table_index = ~0;
10043 u32 miss_next_index = ~0;
10044 u32 memory_size = 32 << 20;
10046 u32 current_data_flag = 0;
10047 int current_data_offset = 0;
10050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10052 if (unformat (i, "del"))
10054 else if (unformat (i, "del-chain"))
10059 else if (unformat (i, "buckets %d", &nbuckets))
10061 else if (unformat (i, "memory_size %d", &memory_size))
10063 else if (unformat (i, "skip %d", &skip))
10065 else if (unformat (i, "match %d", &match))
10067 else if (unformat (i, "table %d", &table_index))
10069 else if (unformat (i, "mask %U", unformat_classify_mask,
10070 &mask, &skip, &match))
10072 else if (unformat (i, "next-table %d", &next_table_index))
10074 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10077 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10080 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10083 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10085 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10091 if (is_add && mask == 0)
10093 errmsg ("Mask required");
10097 if (is_add && skip == ~0)
10099 errmsg ("skip count required");
10103 if (is_add && match == ~0)
10105 errmsg ("match count required");
10109 if (!is_add && table_index == ~0)
10111 errmsg ("table index required for delete");
10115 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10117 mp->is_add = is_add;
10118 mp->del_chain = del_chain;
10119 mp->table_index = ntohl (table_index);
10120 mp->nbuckets = ntohl (nbuckets);
10121 mp->memory_size = ntohl (memory_size);
10122 mp->skip_n_vectors = ntohl (skip);
10123 mp->match_n_vectors = ntohl (match);
10124 mp->next_table_index = ntohl (next_table_index);
10125 mp->miss_next_index = ntohl (miss_next_index);
10126 mp->current_data_flag = ntohl (current_data_flag);
10127 mp->current_data_offset = ntohl (current_data_offset);
10128 mp->mask_len = ntohl (vec_len (mask));
10129 clib_memcpy (mp->mask, mask, vec_len (mask));
10138 #if VPP_API_TEST_BUILTIN == 0
10140 unformat_l4_match (unformat_input_t * input, va_list * args)
10142 u8 **matchp = va_arg (*args, u8 **);
10144 u8 *proto_header = 0;
10150 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10152 if (unformat (input, "src_port %d", &src_port))
10154 else if (unformat (input, "dst_port %d", &dst_port))
10160 h.src_port = clib_host_to_net_u16 (src_port);
10161 h.dst_port = clib_host_to_net_u16 (dst_port);
10162 vec_validate (proto_header, sizeof (h) - 1);
10163 memcpy (proto_header, &h, sizeof (h));
10165 *matchp = proto_header;
10171 unformat_ip4_match (unformat_input_t * input, va_list * args)
10173 u8 **matchp = va_arg (*args, u8 **);
10178 int hdr_length = 0;
10179 u32 hdr_length_val;
10180 int src = 0, dst = 0;
10181 ip4_address_t src_val, dst_val;
10188 int fragment_id = 0;
10189 u32 fragment_id_val;
10195 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10197 if (unformat (input, "version %d", &version_val))
10199 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10201 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10203 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10205 else if (unformat (input, "proto %d", &proto_val))
10207 else if (unformat (input, "tos %d", &tos_val))
10209 else if (unformat (input, "length %d", &length_val))
10211 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10213 else if (unformat (input, "ttl %d", &ttl_val))
10215 else if (unformat (input, "checksum %d", &checksum_val))
10221 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10222 + ttl + checksum == 0)
10226 * Aligned because we use the real comparison functions
10228 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10230 ip = (ip4_header_t *) match;
10232 /* These are realistically matched in practice */
10234 ip->src_address.as_u32 = src_val.as_u32;
10237 ip->dst_address.as_u32 = dst_val.as_u32;
10240 ip->protocol = proto_val;
10243 /* These are not, but they're included for completeness */
10245 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10248 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10254 ip->length = clib_host_to_net_u16 (length_val);
10260 ip->checksum = clib_host_to_net_u16 (checksum_val);
10267 unformat_ip6_match (unformat_input_t * input, va_list * args)
10269 u8 **matchp = va_arg (*args, u8 **);
10274 u8 traffic_class = 0;
10275 u32 traffic_class_val = 0;
10278 int src = 0, dst = 0;
10279 ip6_address_t src_val, dst_val;
10282 int payload_length = 0;
10283 u32 payload_length_val;
10286 u32 ip_version_traffic_class_and_flow_label;
10288 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10290 if (unformat (input, "version %d", &version_val))
10292 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10294 else if (unformat (input, "flow_label %d", &flow_label_val))
10296 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10298 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10300 else if (unformat (input, "proto %d", &proto_val))
10302 else if (unformat (input, "payload_length %d", &payload_length_val))
10303 payload_length = 1;
10304 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10310 if (version + traffic_class + flow_label + src + dst + proto +
10311 payload_length + hop_limit == 0)
10315 * Aligned because we use the real comparison functions
10317 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10319 ip = (ip6_header_t *) match;
10322 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10325 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10328 ip->protocol = proto_val;
10330 ip_version_traffic_class_and_flow_label = 0;
10333 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10336 ip_version_traffic_class_and_flow_label |=
10337 (traffic_class_val & 0xFF) << 20;
10340 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10342 ip->ip_version_traffic_class_and_flow_label =
10343 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10345 if (payload_length)
10346 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10349 ip->hop_limit = hop_limit_val;
10356 unformat_l3_match (unformat_input_t * input, va_list * args)
10358 u8 **matchp = va_arg (*args, u8 **);
10360 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10362 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10364 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10373 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10375 u8 *tagp = va_arg (*args, u8 *);
10378 if (unformat (input, "%d", &tag))
10380 tagp[0] = (tag >> 8) & 0x0F;
10381 tagp[1] = tag & 0xFF;
10389 unformat_l2_match (unformat_input_t * input, va_list * args)
10391 u8 **matchp = va_arg (*args, u8 **);
10404 u8 ignore_tag1 = 0;
10405 u8 ignore_tag2 = 0;
10411 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10413 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10416 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10418 else if (unformat (input, "proto %U",
10419 unformat_ethernet_type_host_byte_order, &proto_val))
10421 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10423 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10425 else if (unformat (input, "ignore-tag1"))
10427 else if (unformat (input, "ignore-tag2"))
10429 else if (unformat (input, "cos1 %d", &cos1_val))
10431 else if (unformat (input, "cos2 %d", &cos2_val))
10436 if ((src + dst + proto + tag1 + tag2 +
10437 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10440 if (tag1 || ignore_tag1 || cos1)
10442 if (tag2 || ignore_tag2 || cos2)
10445 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10448 clib_memcpy (match, dst_val, 6);
10451 clib_memcpy (match + 6, src_val, 6);
10455 /* inner vlan tag */
10456 match[19] = tag2_val[1];
10457 match[18] = tag2_val[0];
10459 match[18] |= (cos2_val & 0x7) << 5;
10462 match[21] = proto_val & 0xff;
10463 match[20] = proto_val >> 8;
10467 match[15] = tag1_val[1];
10468 match[14] = tag1_val[0];
10471 match[14] |= (cos1_val & 0x7) << 5;
10477 match[15] = tag1_val[1];
10478 match[14] = tag1_val[0];
10481 match[17] = proto_val & 0xff;
10482 match[16] = proto_val >> 8;
10485 match[14] |= (cos1_val & 0x7) << 5;
10491 match[18] |= (cos2_val & 0x7) << 5;
10493 match[14] |= (cos1_val & 0x7) << 5;
10496 match[13] = proto_val & 0xff;
10497 match[12] = proto_val >> 8;
10505 unformat_qos_source (unformat_input_t * input, va_list * args)
10507 int *qs = va_arg (*args, int *);
10509 if (unformat (input, "ip"))
10510 *qs = QOS_SOURCE_IP;
10511 else if (unformat (input, "mpls"))
10512 *qs = QOS_SOURCE_MPLS;
10513 else if (unformat (input, "ext"))
10514 *qs = QOS_SOURCE_EXT;
10515 else if (unformat (input, "vlan"))
10516 *qs = QOS_SOURCE_VLAN;
10525 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10527 u8 **matchp = va_arg (*args, u8 **);
10528 u32 skip_n_vectors = va_arg (*args, u32);
10529 u32 match_n_vectors = va_arg (*args, u32);
10536 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10538 if (unformat (input, "hex %U", unformat_hex_string, &match))
10540 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10542 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10544 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10558 if (match || l2 || l3 || l4)
10560 if (l2 || l3 || l4)
10562 /* "Win a free Ethernet header in every packet" */
10564 vec_validate_aligned (l2, 13, sizeof (u32x4));
10568 vec_append_aligned (match, l3, sizeof (u32x4));
10573 vec_append_aligned (match, l4, sizeof (u32x4));
10578 /* Make sure the vector is big enough even if key is all 0's */
10579 vec_validate_aligned
10580 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10583 /* Set size, include skipped vectors */
10584 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10595 api_classify_add_del_session (vat_main_t * vam)
10597 unformat_input_t *i = vam->input;
10598 vl_api_classify_add_del_session_t *mp;
10600 u32 table_index = ~0;
10601 u32 hit_next_index = ~0;
10602 u32 opaque_index = ~0;
10605 u32 skip_n_vectors = 0;
10606 u32 match_n_vectors = 0;
10612 * Warning: you have to supply skip_n and match_n
10613 * because the API client cant simply look at the classify
10617 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10619 if (unformat (i, "del"))
10621 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10624 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10627 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10630 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10632 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10634 else if (unformat (i, "opaque-index %d", &opaque_index))
10636 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10638 else if (unformat (i, "match_n %d", &match_n_vectors))
10640 else if (unformat (i, "match %U", api_unformat_classify_match,
10641 &match, skip_n_vectors, match_n_vectors))
10643 else if (unformat (i, "advance %d", &advance))
10645 else if (unformat (i, "table-index %d", &table_index))
10647 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10649 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10651 else if (unformat (i, "action %d", &action))
10653 else if (unformat (i, "metadata %d", &metadata))
10659 if (table_index == ~0)
10661 errmsg ("Table index required");
10665 if (is_add && match == 0)
10667 errmsg ("Match value required");
10671 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10673 mp->is_add = is_add;
10674 mp->table_index = ntohl (table_index);
10675 mp->hit_next_index = ntohl (hit_next_index);
10676 mp->opaque_index = ntohl (opaque_index);
10677 mp->advance = ntohl (advance);
10678 mp->action = action;
10679 mp->metadata = ntohl (metadata);
10680 mp->match_len = ntohl (vec_len (match));
10681 clib_memcpy (mp->match, match, vec_len (match));
10690 api_classify_set_interface_ip_table (vat_main_t * vam)
10692 unformat_input_t *i = vam->input;
10693 vl_api_classify_set_interface_ip_table_t *mp;
10695 int sw_if_index_set;
10696 u32 table_index = ~0;
10700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10702 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10703 sw_if_index_set = 1;
10704 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10705 sw_if_index_set = 1;
10706 else if (unformat (i, "table %d", &table_index))
10710 clib_warning ("parse error '%U'", format_unformat_error, i);
10715 if (sw_if_index_set == 0)
10717 errmsg ("missing interface name or sw_if_index");
10722 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10724 mp->sw_if_index = ntohl (sw_if_index);
10725 mp->table_index = ntohl (table_index);
10726 mp->is_ipv6 = is_ipv6;
10734 api_classify_set_interface_l2_tables (vat_main_t * vam)
10736 unformat_input_t *i = vam->input;
10737 vl_api_classify_set_interface_l2_tables_t *mp;
10739 int sw_if_index_set;
10740 u32 ip4_table_index = ~0;
10741 u32 ip6_table_index = ~0;
10742 u32 other_table_index = ~0;
10746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10748 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10749 sw_if_index_set = 1;
10750 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10751 sw_if_index_set = 1;
10752 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10754 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10756 else if (unformat (i, "other-table %d", &other_table_index))
10758 else if (unformat (i, "is-input %d", &is_input))
10762 clib_warning ("parse error '%U'", format_unformat_error, i);
10767 if (sw_if_index_set == 0)
10769 errmsg ("missing interface name or sw_if_index");
10774 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10776 mp->sw_if_index = ntohl (sw_if_index);
10777 mp->ip4_table_index = ntohl (ip4_table_index);
10778 mp->ip6_table_index = ntohl (ip6_table_index);
10779 mp->other_table_index = ntohl (other_table_index);
10780 mp->is_input = (u8) is_input;
10788 api_set_ipfix_exporter (vat_main_t * vam)
10790 unformat_input_t *i = vam->input;
10791 vl_api_set_ipfix_exporter_t *mp;
10792 ip4_address_t collector_address;
10793 u8 collector_address_set = 0;
10794 u32 collector_port = ~0;
10795 ip4_address_t src_address;
10796 u8 src_address_set = 0;
10799 u32 template_interval = ~0;
10800 u8 udp_checksum = 0;
10803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10805 if (unformat (i, "collector_address %U", unformat_ip4_address,
10806 &collector_address))
10807 collector_address_set = 1;
10808 else if (unformat (i, "collector_port %d", &collector_port))
10810 else if (unformat (i, "src_address %U", unformat_ip4_address,
10812 src_address_set = 1;
10813 else if (unformat (i, "vrf_id %d", &vrf_id))
10815 else if (unformat (i, "path_mtu %d", &path_mtu))
10817 else if (unformat (i, "template_interval %d", &template_interval))
10819 else if (unformat (i, "udp_checksum"))
10825 if (collector_address_set == 0)
10827 errmsg ("collector_address required");
10831 if (src_address_set == 0)
10833 errmsg ("src_address required");
10837 M (SET_IPFIX_EXPORTER, mp);
10839 memcpy (mp->collector_address.un.ip4, collector_address.data,
10840 sizeof (collector_address.data));
10841 mp->collector_port = htons ((u16) collector_port);
10842 memcpy (mp->src_address.un.ip4, src_address.data,
10843 sizeof (src_address.data));
10844 mp->vrf_id = htonl (vrf_id);
10845 mp->path_mtu = htonl (path_mtu);
10846 mp->template_interval = htonl (template_interval);
10847 mp->udp_checksum = udp_checksum;
10855 api_set_ipfix_classify_stream (vat_main_t * vam)
10857 unformat_input_t *i = vam->input;
10858 vl_api_set_ipfix_classify_stream_t *mp;
10860 u32 src_port = UDP_DST_PORT_ipfix;
10863 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10865 if (unformat (i, "domain %d", &domain_id))
10867 else if (unformat (i, "src_port %d", &src_port))
10871 errmsg ("unknown input `%U'", format_unformat_error, i);
10876 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10878 mp->domain_id = htonl (domain_id);
10879 mp->src_port = htons ((u16) src_port);
10887 api_ipfix_classify_table_add_del (vat_main_t * vam)
10889 unformat_input_t *i = vam->input;
10890 vl_api_ipfix_classify_table_add_del_t *mp;
10892 u32 classify_table_index = ~0;
10894 u8 transport_protocol = 255;
10897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10899 if (unformat (i, "add"))
10901 else if (unformat (i, "del"))
10903 else if (unformat (i, "table %d", &classify_table_index))
10905 else if (unformat (i, "ip4"))
10907 else if (unformat (i, "ip6"))
10909 else if (unformat (i, "tcp"))
10910 transport_protocol = 6;
10911 else if (unformat (i, "udp"))
10912 transport_protocol = 17;
10915 errmsg ("unknown input `%U'", format_unformat_error, i);
10922 errmsg ("expecting: add|del");
10925 if (classify_table_index == ~0)
10927 errmsg ("classifier table not specified");
10930 if (ip_version == 0)
10932 errmsg ("IP version not specified");
10936 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10938 mp->is_add = is_add;
10939 mp->table_id = htonl (classify_table_index);
10940 mp->ip_version = ip_version;
10941 mp->transport_protocol = transport_protocol;
10949 api_get_node_index (vat_main_t * vam)
10951 unformat_input_t *i = vam->input;
10952 vl_api_get_node_index_t *mp;
10956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10958 if (unformat (i, "node %s", &name))
10965 errmsg ("node name required");
10968 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10970 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10974 M (GET_NODE_INDEX, mp);
10975 clib_memcpy (mp->node_name, name, vec_len (name));
10984 api_get_next_index (vat_main_t * vam)
10986 unformat_input_t *i = vam->input;
10987 vl_api_get_next_index_t *mp;
10988 u8 *node_name = 0, *next_node_name = 0;
10991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10993 if (unformat (i, "node-name %s", &node_name))
10995 else if (unformat (i, "next-node-name %s", &next_node_name))
10999 if (node_name == 0)
11001 errmsg ("node name required");
11004 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11006 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11010 if (next_node_name == 0)
11012 errmsg ("next node name required");
11015 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11017 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11021 M (GET_NEXT_INDEX, mp);
11022 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11023 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11024 vec_free (node_name);
11025 vec_free (next_node_name);
11033 api_add_node_next (vat_main_t * vam)
11035 unformat_input_t *i = vam->input;
11036 vl_api_add_node_next_t *mp;
11041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11043 if (unformat (i, "node %s", &name))
11045 else if (unformat (i, "next %s", &next))
11052 errmsg ("node name required");
11055 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11057 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11062 errmsg ("next node required");
11065 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11067 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11071 M (ADD_NODE_NEXT, mp);
11072 clib_memcpy (mp->node_name, name, vec_len (name));
11073 clib_memcpy (mp->next_name, next, vec_len (next));
11083 api_l2tpv3_create_tunnel (vat_main_t * vam)
11085 unformat_input_t *i = vam->input;
11086 ip6_address_t client_address, our_address;
11087 int client_address_set = 0;
11088 int our_address_set = 0;
11089 u32 local_session_id = 0;
11090 u32 remote_session_id = 0;
11091 u64 local_cookie = 0;
11092 u64 remote_cookie = 0;
11093 u8 l2_sublayer_present = 0;
11094 vl_api_l2tpv3_create_tunnel_t *mp;
11097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11099 if (unformat (i, "client_address %U", unformat_ip6_address,
11101 client_address_set = 1;
11102 else if (unformat (i, "our_address %U", unformat_ip6_address,
11104 our_address_set = 1;
11105 else if (unformat (i, "local_session_id %d", &local_session_id))
11107 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11109 else if (unformat (i, "local_cookie %lld", &local_cookie))
11111 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11113 else if (unformat (i, "l2-sublayer-present"))
11114 l2_sublayer_present = 1;
11119 if (client_address_set == 0)
11121 errmsg ("client_address required");
11125 if (our_address_set == 0)
11127 errmsg ("our_address required");
11131 M (L2TPV3_CREATE_TUNNEL, mp);
11133 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11134 sizeof (ip6_address_t));
11136 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11137 sizeof (ip6_address_t));
11139 mp->local_session_id = ntohl (local_session_id);
11140 mp->remote_session_id = ntohl (remote_session_id);
11141 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11142 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11143 mp->l2_sublayer_present = l2_sublayer_present;
11151 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11153 unformat_input_t *i = vam->input;
11155 u8 sw_if_index_set = 0;
11156 u64 new_local_cookie = 0;
11157 u64 new_remote_cookie = 0;
11158 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11161 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11163 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11164 sw_if_index_set = 1;
11165 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11166 sw_if_index_set = 1;
11167 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11169 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11175 if (sw_if_index_set == 0)
11177 errmsg ("missing interface name or sw_if_index");
11181 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11183 mp->sw_if_index = ntohl (sw_if_index);
11184 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11185 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11193 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11195 unformat_input_t *i = vam->input;
11196 vl_api_l2tpv3_interface_enable_disable_t *mp;
11198 u8 sw_if_index_set = 0;
11199 u8 enable_disable = 1;
11202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11205 sw_if_index_set = 1;
11206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11207 sw_if_index_set = 1;
11208 else if (unformat (i, "enable"))
11209 enable_disable = 1;
11210 else if (unformat (i, "disable"))
11211 enable_disable = 0;
11216 if (sw_if_index_set == 0)
11218 errmsg ("missing interface name or sw_if_index");
11222 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11224 mp->sw_if_index = ntohl (sw_if_index);
11225 mp->enable_disable = enable_disable;
11233 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11235 unformat_input_t *i = vam->input;
11236 vl_api_l2tpv3_set_lookup_key_t *mp;
11240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11242 if (unformat (i, "lookup_v6_src"))
11243 key = L2T_LOOKUP_SRC_ADDRESS;
11244 else if (unformat (i, "lookup_v6_dst"))
11245 key = L2T_LOOKUP_DST_ADDRESS;
11246 else if (unformat (i, "lookup_session_id"))
11247 key = L2T_LOOKUP_SESSION_ID;
11252 if (key == (u8) ~ 0)
11254 errmsg ("l2tp session lookup key unset");
11258 M (L2TPV3_SET_LOOKUP_KEY, mp);
11267 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11268 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11270 vat_main_t *vam = &vat_main;
11272 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11273 format_ip6_address, mp->our_address,
11274 format_ip6_address, mp->client_address,
11275 clib_net_to_host_u32 (mp->sw_if_index));
11278 " local cookies %016llx %016llx remote cookie %016llx",
11279 clib_net_to_host_u64 (mp->local_cookie[0]),
11280 clib_net_to_host_u64 (mp->local_cookie[1]),
11281 clib_net_to_host_u64 (mp->remote_cookie));
11283 print (vam->ofp, " local session-id %d remote session-id %d",
11284 clib_net_to_host_u32 (mp->local_session_id),
11285 clib_net_to_host_u32 (mp->remote_session_id));
11287 print (vam->ofp, " l2 specific sublayer %s\n",
11288 mp->l2_sublayer_present ? "preset" : "absent");
11292 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11293 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11295 vat_main_t *vam = &vat_main;
11296 vat_json_node_t *node = NULL;
11297 struct in6_addr addr;
11299 if (VAT_JSON_ARRAY != vam->json_tree.type)
11301 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11302 vat_json_init_array (&vam->json_tree);
11304 node = vat_json_array_add (&vam->json_tree);
11306 vat_json_init_object (node);
11308 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11309 vat_json_object_add_ip6 (node, "our_address", addr);
11310 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11311 vat_json_object_add_ip6 (node, "client_address", addr);
11313 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11314 vat_json_init_array (lc);
11315 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11316 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11317 vat_json_object_add_uint (node, "remote_cookie",
11318 clib_net_to_host_u64 (mp->remote_cookie));
11320 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11321 vat_json_object_add_uint (node, "local_session_id",
11322 clib_net_to_host_u32 (mp->local_session_id));
11323 vat_json_object_add_uint (node, "remote_session_id",
11324 clib_net_to_host_u32 (mp->remote_session_id));
11325 vat_json_object_add_string_copy (node, "l2_sublayer",
11326 mp->l2_sublayer_present ? (u8 *) "present"
11327 : (u8 *) "absent");
11331 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11333 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11334 vl_api_control_ping_t *mp_ping;
11337 /* Get list of l2tpv3-tunnel interfaces */
11338 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11341 /* Use a control ping for synchronization */
11342 MPING (CONTROL_PING, mp_ping);
11350 static void vl_api_sw_interface_tap_v2_details_t_handler
11351 (vl_api_sw_interface_tap_v2_details_t * mp)
11353 vat_main_t *vam = &vat_main;
11356 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11357 mp->host_ip4_prefix.len);
11359 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11360 mp->host_ip6_prefix.len);
11363 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11364 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11365 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11366 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11367 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11373 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11374 (vl_api_sw_interface_tap_v2_details_t * mp)
11376 vat_main_t *vam = &vat_main;
11377 vat_json_node_t *node = NULL;
11379 if (VAT_JSON_ARRAY != vam->json_tree.type)
11381 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11382 vat_json_init_array (&vam->json_tree);
11384 node = vat_json_array_add (&vam->json_tree);
11386 vat_json_init_object (node);
11387 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11388 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11389 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11390 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11391 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11392 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11393 vat_json_object_add_string_copy (node, "host_mac_addr",
11394 format (0, "%U", format_ethernet_address,
11395 &mp->host_mac_addr));
11396 vat_json_object_add_string_copy (node, "host_namespace",
11397 mp->host_namespace);
11398 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11399 vat_json_object_add_string_copy (node, "host_ip4_addr",
11400 format (0, "%U/%d", format_ip4_address,
11401 mp->host_ip4_prefix.address,
11402 mp->host_ip4_prefix.len));
11403 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11404 format (0, "%U/%d", format_ip6_address,
11405 mp->host_ip6_prefix.address,
11406 mp->host_ip6_prefix.len));
11411 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11413 vl_api_sw_interface_tap_v2_dump_t *mp;
11414 vl_api_control_ping_t *mp_ping;
11418 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11419 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11420 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11423 /* Get list of tap interfaces */
11424 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11427 /* Use a control ping for synchronization */
11428 MPING (CONTROL_PING, mp_ping);
11435 static void vl_api_sw_interface_virtio_pci_details_t_handler
11436 (vl_api_sw_interface_virtio_pci_details_t * mp)
11438 vat_main_t *vam = &vat_main;
11453 addr.domain = ntohs (mp->pci_addr.domain);
11454 addr.bus = mp->pci_addr.bus;
11455 addr.slot = mp->pci_addr.slot;
11456 addr.function = mp->pci_addr.function;
11458 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11459 addr.slot, addr.function);
11462 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11463 pci_addr, ntohl (mp->sw_if_index),
11464 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11465 format_ethernet_address, mp->mac_addr,
11466 clib_net_to_host_u64 (mp->features));
11467 vec_free (pci_addr);
11470 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11471 (vl_api_sw_interface_virtio_pci_details_t * mp)
11473 vat_main_t *vam = &vat_main;
11474 vat_json_node_t *node = NULL;
11475 vlib_pci_addr_t pci_addr;
11477 if (VAT_JSON_ARRAY != vam->json_tree.type)
11479 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11480 vat_json_init_array (&vam->json_tree);
11482 node = vat_json_array_add (&vam->json_tree);
11484 pci_addr.domain = ntohs (mp->pci_addr.domain);
11485 pci_addr.bus = mp->pci_addr.bus;
11486 pci_addr.slot = mp->pci_addr.slot;
11487 pci_addr.function = mp->pci_addr.function;
11489 vat_json_init_object (node);
11490 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11491 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11492 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11493 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11494 vat_json_object_add_uint (node, "features",
11495 clib_net_to_host_u64 (mp->features));
11496 vat_json_object_add_string_copy (node, "mac_addr",
11497 format (0, "%U", format_ethernet_address,
11502 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11504 vl_api_sw_interface_virtio_pci_dump_t *mp;
11505 vl_api_control_ping_t *mp_ping;
11509 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11510 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11511 "mac_addr", "features");
11513 /* Get list of tap interfaces */
11514 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11517 /* Use a control ping for synchronization */
11518 MPING (CONTROL_PING, mp_ping);
11526 api_vxlan_offload_rx (vat_main_t * vam)
11528 unformat_input_t *line_input = vam->input;
11529 vl_api_vxlan_offload_rx_t *mp;
11530 u32 hw_if_index = ~0, rx_if_index = ~0;
11534 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11536 if (unformat (line_input, "del"))
11538 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11541 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11543 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11546 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11550 errmsg ("parse error '%U'", format_unformat_error, line_input);
11555 if (hw_if_index == ~0)
11557 errmsg ("no hw interface");
11561 if (rx_if_index == ~0)
11563 errmsg ("no rx tunnel");
11567 M (VXLAN_OFFLOAD_RX, mp);
11569 mp->hw_if_index = ntohl (hw_if_index);
11570 mp->sw_if_index = ntohl (rx_if_index);
11571 mp->enable = is_add;
11578 static uword unformat_vxlan_decap_next
11579 (unformat_input_t * input, va_list * args)
11581 u32 *result = va_arg (*args, u32 *);
11584 if (unformat (input, "l2"))
11585 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11586 else if (unformat (input, "%d", &tmp))
11594 api_vxlan_add_del_tunnel (vat_main_t * vam)
11596 unformat_input_t *line_input = vam->input;
11597 vl_api_vxlan_add_del_tunnel_t *mp;
11598 ip46_address_t src, dst;
11600 u8 ipv4_set = 0, ipv6_set = 0;
11605 u32 mcast_sw_if_index = ~0;
11606 u32 encap_vrf_id = 0;
11607 u32 decap_next_index = ~0;
11611 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11612 clib_memset (&src, 0, sizeof src);
11613 clib_memset (&dst, 0, sizeof dst);
11615 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11617 if (unformat (line_input, "del"))
11619 else if (unformat (line_input, "instance %d", &instance))
11622 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11628 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11634 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11640 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11645 else if (unformat (line_input, "group %U %U",
11646 unformat_ip4_address, &dst.ip4,
11647 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11649 grp_set = dst_set = 1;
11652 else if (unformat (line_input, "group %U",
11653 unformat_ip4_address, &dst.ip4))
11655 grp_set = dst_set = 1;
11658 else if (unformat (line_input, "group %U %U",
11659 unformat_ip6_address, &dst.ip6,
11660 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11662 grp_set = dst_set = 1;
11665 else if (unformat (line_input, "group %U",
11666 unformat_ip6_address, &dst.ip6))
11668 grp_set = dst_set = 1;
11672 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11674 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11676 else if (unformat (line_input, "decap-next %U",
11677 unformat_vxlan_decap_next, &decap_next_index))
11679 else if (unformat (line_input, "vni %d", &vni))
11683 errmsg ("parse error '%U'", format_unformat_error, line_input);
11690 errmsg ("tunnel src address not specified");
11695 errmsg ("tunnel dst address not specified");
11699 if (grp_set && !ip46_address_is_multicast (&dst))
11701 errmsg ("tunnel group address not multicast");
11704 if (grp_set && mcast_sw_if_index == ~0)
11706 errmsg ("tunnel nonexistent multicast device");
11709 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11711 errmsg ("tunnel dst address must be unicast");
11716 if (ipv4_set && ipv6_set)
11718 errmsg ("both IPv4 and IPv6 addresses specified");
11722 if ((vni == 0) || (vni >> 24))
11724 errmsg ("vni not specified or out of range");
11728 M (VXLAN_ADD_DEL_TUNNEL, mp);
11732 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
11733 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
11737 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
11738 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
11741 mp->instance = htonl (instance);
11742 mp->encap_vrf_id = ntohl (encap_vrf_id);
11743 mp->decap_next_index = ntohl (decap_next_index);
11744 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11745 mp->vni = ntohl (vni);
11746 mp->is_add = is_add;
11747 mp->is_ipv6 = ipv6_set;
11754 static void vl_api_vxlan_tunnel_details_t_handler
11755 (vl_api_vxlan_tunnel_details_t * mp)
11757 vat_main_t *vam = &vat_main;
11758 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
11759 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
11761 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11762 ntohl (mp->sw_if_index),
11763 ntohl (mp->instance),
11764 format_ip46_address, &src, IP46_TYPE_ANY,
11765 format_ip46_address, &dst, IP46_TYPE_ANY,
11766 ntohl (mp->encap_vrf_id),
11767 ntohl (mp->decap_next_index), ntohl (mp->vni),
11768 ntohl (mp->mcast_sw_if_index));
11771 static void vl_api_vxlan_tunnel_details_t_handler_json
11772 (vl_api_vxlan_tunnel_details_t * mp)
11774 vat_main_t *vam = &vat_main;
11775 vat_json_node_t *node = NULL;
11777 if (VAT_JSON_ARRAY != vam->json_tree.type)
11779 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11780 vat_json_init_array (&vam->json_tree);
11782 node = vat_json_array_add (&vam->json_tree);
11784 vat_json_init_object (node);
11785 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11787 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11791 struct in6_addr ip6;
11793 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
11794 vat_json_object_add_ip6 (node, "src_address", ip6);
11795 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
11796 vat_json_object_add_ip6 (node, "dst_address", ip6);
11800 struct in_addr ip4;
11802 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
11803 vat_json_object_add_ip4 (node, "src_address", ip4);
11804 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
11805 vat_json_object_add_ip4 (node, "dst_address", ip4);
11807 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11808 vat_json_object_add_uint (node, "decap_next_index",
11809 ntohl (mp->decap_next_index));
11810 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11811 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11812 vat_json_object_add_uint (node, "mcast_sw_if_index",
11813 ntohl (mp->mcast_sw_if_index));
11817 api_vxlan_tunnel_dump (vat_main_t * vam)
11819 unformat_input_t *i = vam->input;
11820 vl_api_vxlan_tunnel_dump_t *mp;
11821 vl_api_control_ping_t *mp_ping;
11823 u8 sw_if_index_set = 0;
11826 /* Parse args required to build the message */
11827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11829 if (unformat (i, "sw_if_index %d", &sw_if_index))
11830 sw_if_index_set = 1;
11835 if (sw_if_index_set == 0)
11840 if (!vam->json_output)
11842 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11843 "sw_if_index", "instance", "src_address", "dst_address",
11844 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11847 /* Get list of vxlan-tunnel interfaces */
11848 M (VXLAN_TUNNEL_DUMP, mp);
11850 mp->sw_if_index = htonl (sw_if_index);
11854 /* Use a control ping for synchronization */
11855 MPING (CONTROL_PING, mp_ping);
11862 static uword unformat_geneve_decap_next
11863 (unformat_input_t * input, va_list * args)
11865 u32 *result = va_arg (*args, u32 *);
11868 if (unformat (input, "l2"))
11869 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11870 else if (unformat (input, "%d", &tmp))
11878 api_geneve_add_del_tunnel (vat_main_t * vam)
11880 unformat_input_t *line_input = vam->input;
11881 vl_api_geneve_add_del_tunnel_t *mp;
11882 ip46_address_t src, dst;
11884 u8 ipv4_set = 0, ipv6_set = 0;
11888 u32 mcast_sw_if_index = ~0;
11889 u32 encap_vrf_id = 0;
11890 u32 decap_next_index = ~0;
11894 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11895 clib_memset (&src, 0, sizeof src);
11896 clib_memset (&dst, 0, sizeof dst);
11898 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11900 if (unformat (line_input, "del"))
11903 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11909 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11915 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11921 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11926 else if (unformat (line_input, "group %U %U",
11927 unformat_ip4_address, &dst.ip4,
11928 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11930 grp_set = dst_set = 1;
11933 else if (unformat (line_input, "group %U",
11934 unformat_ip4_address, &dst.ip4))
11936 grp_set = dst_set = 1;
11939 else if (unformat (line_input, "group %U %U",
11940 unformat_ip6_address, &dst.ip6,
11941 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11943 grp_set = dst_set = 1;
11946 else if (unformat (line_input, "group %U",
11947 unformat_ip6_address, &dst.ip6))
11949 grp_set = dst_set = 1;
11953 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11955 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11957 else if (unformat (line_input, "decap-next %U",
11958 unformat_geneve_decap_next, &decap_next_index))
11960 else if (unformat (line_input, "vni %d", &vni))
11964 errmsg ("parse error '%U'", format_unformat_error, line_input);
11971 errmsg ("tunnel src address not specified");
11976 errmsg ("tunnel dst address not specified");
11980 if (grp_set && !ip46_address_is_multicast (&dst))
11982 errmsg ("tunnel group address not multicast");
11985 if (grp_set && mcast_sw_if_index == ~0)
11987 errmsg ("tunnel nonexistent multicast device");
11990 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11992 errmsg ("tunnel dst address must be unicast");
11997 if (ipv4_set && ipv6_set)
11999 errmsg ("both IPv4 and IPv6 addresses specified");
12003 if ((vni == 0) || (vni >> 24))
12005 errmsg ("vni not specified or out of range");
12009 M (GENEVE_ADD_DEL_TUNNEL, mp);
12013 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12014 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12018 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12019 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12021 mp->encap_vrf_id = ntohl (encap_vrf_id);
12022 mp->decap_next_index = ntohl (decap_next_index);
12023 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12024 mp->vni = ntohl (vni);
12025 mp->is_add = is_add;
12032 static void vl_api_geneve_tunnel_details_t_handler
12033 (vl_api_geneve_tunnel_details_t * mp)
12035 vat_main_t *vam = &vat_main;
12036 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12037 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12039 if (mp->src_address.af == ADDRESS_IP6)
12041 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12042 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12046 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12047 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12050 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12051 ntohl (mp->sw_if_index),
12052 format_ip46_address, &src, IP46_TYPE_ANY,
12053 format_ip46_address, &dst, IP46_TYPE_ANY,
12054 ntohl (mp->encap_vrf_id),
12055 ntohl (mp->decap_next_index), ntohl (mp->vni),
12056 ntohl (mp->mcast_sw_if_index));
12059 static void vl_api_geneve_tunnel_details_t_handler_json
12060 (vl_api_geneve_tunnel_details_t * mp)
12062 vat_main_t *vam = &vat_main;
12063 vat_json_node_t *node = NULL;
12066 if (VAT_JSON_ARRAY != vam->json_tree.type)
12068 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12069 vat_json_init_array (&vam->json_tree);
12071 node = vat_json_array_add (&vam->json_tree);
12073 vat_json_init_object (node);
12074 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12075 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12078 struct in6_addr ip6;
12080 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12081 vat_json_object_add_ip6 (node, "src_address", ip6);
12082 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12083 vat_json_object_add_ip6 (node, "dst_address", ip6);
12087 struct in_addr ip4;
12089 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12090 vat_json_object_add_ip4 (node, "src_address", ip4);
12091 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12092 vat_json_object_add_ip4 (node, "dst_address", ip4);
12094 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12095 vat_json_object_add_uint (node, "decap_next_index",
12096 ntohl (mp->decap_next_index));
12097 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12098 vat_json_object_add_uint (node, "mcast_sw_if_index",
12099 ntohl (mp->mcast_sw_if_index));
12103 api_geneve_tunnel_dump (vat_main_t * vam)
12105 unformat_input_t *i = vam->input;
12106 vl_api_geneve_tunnel_dump_t *mp;
12107 vl_api_control_ping_t *mp_ping;
12109 u8 sw_if_index_set = 0;
12112 /* Parse args required to build the message */
12113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12115 if (unformat (i, "sw_if_index %d", &sw_if_index))
12116 sw_if_index_set = 1;
12121 if (sw_if_index_set == 0)
12126 if (!vam->json_output)
12128 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12129 "sw_if_index", "local_address", "remote_address",
12130 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12133 /* Get list of geneve-tunnel interfaces */
12134 M (GENEVE_TUNNEL_DUMP, mp);
12136 mp->sw_if_index = htonl (sw_if_index);
12140 /* Use a control ping for synchronization */
12141 M (CONTROL_PING, mp_ping);
12149 api_gre_tunnel_add_del (vat_main_t * vam)
12151 unformat_input_t *line_input = vam->input;
12152 vl_api_address_t src = { }, dst =
12155 vl_api_gre_tunnel_add_del_t *mp;
12156 vl_api_gre_tunnel_type_t t_type;
12160 u32 outer_table_id = 0;
12161 u32 session_id = 0;
12165 t_type = GRE_API_TUNNEL_TYPE_L3;
12167 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12169 if (unformat (line_input, "del"))
12171 else if (unformat (line_input, "instance %d", &instance))
12173 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12177 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12181 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12183 else if (unformat (line_input, "teb"))
12184 t_type = GRE_API_TUNNEL_TYPE_TEB;
12185 else if (unformat (line_input, "erspan %d", &session_id))
12186 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12189 errmsg ("parse error '%U'", format_unformat_error, line_input);
12196 errmsg ("tunnel src address not specified");
12201 errmsg ("tunnel dst address not specified");
12205 M (GRE_TUNNEL_ADD_DEL, mp);
12207 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12208 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12210 mp->tunnel.instance = htonl (instance);
12211 mp->tunnel.outer_table_id = htonl (outer_table_id);
12212 mp->is_add = is_add;
12213 mp->tunnel.session_id = htons ((u16) session_id);
12214 mp->tunnel.type = htonl (t_type);
12221 static void vl_api_gre_tunnel_details_t_handler
12222 (vl_api_gre_tunnel_details_t * mp)
12224 vat_main_t *vam = &vat_main;
12226 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12227 ntohl (mp->tunnel.sw_if_index),
12228 ntohl (mp->tunnel.instance),
12229 format_vl_api_address, &mp->tunnel.src,
12230 format_vl_api_address, &mp->tunnel.dst,
12231 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12232 ntohl (mp->tunnel.session_id));
12235 static void vl_api_gre_tunnel_details_t_handler_json
12236 (vl_api_gre_tunnel_details_t * mp)
12238 vat_main_t *vam = &vat_main;
12239 vat_json_node_t *node = NULL;
12241 if (VAT_JSON_ARRAY != vam->json_tree.type)
12243 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12244 vat_json_init_array (&vam->json_tree);
12246 node = vat_json_array_add (&vam->json_tree);
12248 vat_json_init_object (node);
12249 vat_json_object_add_uint (node, "sw_if_index",
12250 ntohl (mp->tunnel.sw_if_index));
12251 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12253 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12254 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12255 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12256 vat_json_object_add_uint (node, "outer_table_id",
12257 ntohl (mp->tunnel.outer_table_id));
12258 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12262 api_gre_tunnel_dump (vat_main_t * vam)
12264 unformat_input_t *i = vam->input;
12265 vl_api_gre_tunnel_dump_t *mp;
12266 vl_api_control_ping_t *mp_ping;
12268 u8 sw_if_index_set = 0;
12271 /* Parse args required to build the message */
12272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12274 if (unformat (i, "sw_if_index %d", &sw_if_index))
12275 sw_if_index_set = 1;
12280 if (sw_if_index_set == 0)
12285 if (!vam->json_output)
12287 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12288 "sw_if_index", "instance", "src_address", "dst_address",
12289 "tunnel_type", "outer_fib_id", "session_id");
12292 /* Get list of gre-tunnel interfaces */
12293 M (GRE_TUNNEL_DUMP, mp);
12295 mp->sw_if_index = htonl (sw_if_index);
12299 /* Use a control ping for synchronization */
12300 MPING (CONTROL_PING, mp_ping);
12308 api_l2_fib_clear_table (vat_main_t * vam)
12310 // unformat_input_t * i = vam->input;
12311 vl_api_l2_fib_clear_table_t *mp;
12314 M (L2_FIB_CLEAR_TABLE, mp);
12322 api_l2_interface_efp_filter (vat_main_t * vam)
12324 unformat_input_t *i = vam->input;
12325 vl_api_l2_interface_efp_filter_t *mp;
12328 u8 sw_if_index_set = 0;
12331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12333 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12334 sw_if_index_set = 1;
12335 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12336 sw_if_index_set = 1;
12337 else if (unformat (i, "enable"))
12339 else if (unformat (i, "disable"))
12343 clib_warning ("parse error '%U'", format_unformat_error, i);
12348 if (sw_if_index_set == 0)
12350 errmsg ("missing sw_if_index");
12354 M (L2_INTERFACE_EFP_FILTER, mp);
12356 mp->sw_if_index = ntohl (sw_if_index);
12357 mp->enable_disable = enable;
12364 #define foreach_vtr_op \
12365 _("disable", L2_VTR_DISABLED) \
12366 _("push-1", L2_VTR_PUSH_1) \
12367 _("push-2", L2_VTR_PUSH_2) \
12368 _("pop-1", L2_VTR_POP_1) \
12369 _("pop-2", L2_VTR_POP_2) \
12370 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12371 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12372 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12373 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12376 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12378 unformat_input_t *i = vam->input;
12379 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12381 u8 sw_if_index_set = 0;
12384 u32 push_dot1q = 1;
12389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12391 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12392 sw_if_index_set = 1;
12393 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12394 sw_if_index_set = 1;
12395 else if (unformat (i, "vtr_op %d", &vtr_op))
12397 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12400 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12402 else if (unformat (i, "tag1 %d", &tag1))
12404 else if (unformat (i, "tag2 %d", &tag2))
12408 clib_warning ("parse error '%U'", format_unformat_error, i);
12413 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12415 errmsg ("missing vtr operation or sw_if_index");
12419 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12420 mp->sw_if_index = ntohl (sw_if_index);
12421 mp->vtr_op = ntohl (vtr_op);
12422 mp->push_dot1q = ntohl (push_dot1q);
12423 mp->tag1 = ntohl (tag1);
12424 mp->tag2 = ntohl (tag2);
12432 api_create_vhost_user_if (vat_main_t * vam)
12434 unformat_input_t *i = vam->input;
12435 vl_api_create_vhost_user_if_t *mp;
12438 u8 file_name_set = 0;
12439 u32 custom_dev_instance = ~0;
12441 u8 use_custom_mac = 0;
12442 u8 disable_mrg_rxbuf = 0;
12443 u8 disable_indirect_desc = 0;
12448 /* Shut up coverity */
12449 clib_memset (hwaddr, 0, sizeof (hwaddr));
12451 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12453 if (unformat (i, "socket %s", &file_name))
12457 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12459 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12460 use_custom_mac = 1;
12461 else if (unformat (i, "server"))
12463 else if (unformat (i, "disable_mrg_rxbuf"))
12464 disable_mrg_rxbuf = 1;
12465 else if (unformat (i, "disable_indirect_desc"))
12466 disable_indirect_desc = 1;
12467 else if (unformat (i, "gso"))
12469 else if (unformat (i, "tag %s", &tag))
12475 if (file_name_set == 0)
12477 errmsg ("missing socket file name");
12481 if (vec_len (file_name) > 255)
12483 errmsg ("socket file name too long");
12486 vec_add1 (file_name, 0);
12488 M (CREATE_VHOST_USER_IF, mp);
12490 mp->is_server = is_server;
12491 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12492 mp->disable_indirect_desc = disable_indirect_desc;
12493 mp->enable_gso = enable_gso;
12494 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12495 vec_free (file_name);
12496 if (custom_dev_instance != ~0)
12499 mp->custom_dev_instance = ntohl (custom_dev_instance);
12502 mp->use_custom_mac = use_custom_mac;
12503 clib_memcpy (mp->mac_address, hwaddr, 6);
12505 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12514 api_modify_vhost_user_if (vat_main_t * vam)
12516 unformat_input_t *i = vam->input;
12517 vl_api_modify_vhost_user_if_t *mp;
12520 u8 file_name_set = 0;
12521 u32 custom_dev_instance = ~0;
12522 u8 sw_if_index_set = 0;
12523 u32 sw_if_index = (u32) ~ 0;
12527 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12529 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12530 sw_if_index_set = 1;
12531 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12532 sw_if_index_set = 1;
12533 else if (unformat (i, "socket %s", &file_name))
12537 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12539 else if (unformat (i, "server"))
12541 else if (unformat (i, "gso"))
12547 if (sw_if_index_set == 0)
12549 errmsg ("missing sw_if_index or interface name");
12553 if (file_name_set == 0)
12555 errmsg ("missing socket file name");
12559 if (vec_len (file_name) > 255)
12561 errmsg ("socket file name too long");
12564 vec_add1 (file_name, 0);
12566 M (MODIFY_VHOST_USER_IF, mp);
12568 mp->sw_if_index = ntohl (sw_if_index);
12569 mp->is_server = is_server;
12570 mp->enable_gso = enable_gso;
12571 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12572 vec_free (file_name);
12573 if (custom_dev_instance != ~0)
12576 mp->custom_dev_instance = ntohl (custom_dev_instance);
12585 api_delete_vhost_user_if (vat_main_t * vam)
12587 unformat_input_t *i = vam->input;
12588 vl_api_delete_vhost_user_if_t *mp;
12589 u32 sw_if_index = ~0;
12590 u8 sw_if_index_set = 0;
12593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12595 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12596 sw_if_index_set = 1;
12597 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12598 sw_if_index_set = 1;
12603 if (sw_if_index_set == 0)
12605 errmsg ("missing sw_if_index or interface name");
12610 M (DELETE_VHOST_USER_IF, mp);
12612 mp->sw_if_index = ntohl (sw_if_index);
12619 static void vl_api_sw_interface_vhost_user_details_t_handler
12620 (vl_api_sw_interface_vhost_user_details_t * mp)
12622 vat_main_t *vam = &vat_main;
12626 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12627 clib_net_to_host_u32
12628 (mp->features_last_32) <<
12631 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12632 (char *) mp->interface_name,
12633 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12634 features, mp->is_server,
12635 ntohl (mp->num_regions), (char *) mp->sock_filename);
12636 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12639 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12640 (vl_api_sw_interface_vhost_user_details_t * mp)
12642 vat_main_t *vam = &vat_main;
12643 vat_json_node_t *node = NULL;
12645 if (VAT_JSON_ARRAY != vam->json_tree.type)
12647 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12648 vat_json_init_array (&vam->json_tree);
12650 node = vat_json_array_add (&vam->json_tree);
12652 vat_json_init_object (node);
12653 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12654 vat_json_object_add_string_copy (node, "interface_name",
12655 mp->interface_name);
12656 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12657 ntohl (mp->virtio_net_hdr_sz));
12658 vat_json_object_add_uint (node, "features_first_32",
12659 clib_net_to_host_u32 (mp->features_first_32));
12660 vat_json_object_add_uint (node, "features_last_32",
12661 clib_net_to_host_u32 (mp->features_last_32));
12662 vat_json_object_add_uint (node, "is_server", mp->is_server);
12663 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12664 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12665 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12669 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12671 vl_api_sw_interface_vhost_user_dump_t *mp;
12672 vl_api_control_ping_t *mp_ping;
12675 "Interface name idx hdr_sz features server regions filename");
12677 /* Get list of vhost-user interfaces */
12678 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12679 mp->sw_if_index = ntohl (~0);
12682 /* Use a control ping for synchronization */
12683 MPING (CONTROL_PING, mp_ping);
12691 api_show_version (vat_main_t * vam)
12693 vl_api_show_version_t *mp;
12696 M (SHOW_VERSION, mp);
12705 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12707 unformat_input_t *line_input = vam->input;
12708 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12709 ip4_address_t local4, remote4;
12710 ip6_address_t local6, remote6;
12712 u8 ipv4_set = 0, ipv6_set = 0;
12716 u32 mcast_sw_if_index = ~0;
12717 u32 encap_vrf_id = 0;
12718 u32 decap_vrf_id = 0;
12724 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12725 clib_memset (&local4, 0, sizeof local4);
12726 clib_memset (&remote4, 0, sizeof remote4);
12727 clib_memset (&local6, 0, sizeof local6);
12728 clib_memset (&remote6, 0, sizeof remote6);
12730 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12732 if (unformat (line_input, "del"))
12734 else if (unformat (line_input, "local %U",
12735 unformat_ip4_address, &local4))
12740 else if (unformat (line_input, "remote %U",
12741 unformat_ip4_address, &remote4))
12746 else if (unformat (line_input, "local %U",
12747 unformat_ip6_address, &local6))
12752 else if (unformat (line_input, "remote %U",
12753 unformat_ip6_address, &remote6))
12758 else if (unformat (line_input, "group %U %U",
12759 unformat_ip4_address, &remote4,
12760 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12762 grp_set = remote_set = 1;
12765 else if (unformat (line_input, "group %U",
12766 unformat_ip4_address, &remote4))
12768 grp_set = remote_set = 1;
12771 else if (unformat (line_input, "group %U %U",
12772 unformat_ip6_address, &remote6,
12773 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12775 grp_set = remote_set = 1;
12778 else if (unformat (line_input, "group %U",
12779 unformat_ip6_address, &remote6))
12781 grp_set = remote_set = 1;
12785 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12787 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12789 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12791 else if (unformat (line_input, "vni %d", &vni))
12793 else if (unformat (line_input, "next-ip4"))
12795 else if (unformat (line_input, "next-ip6"))
12797 else if (unformat (line_input, "next-ethernet"))
12799 else if (unformat (line_input, "next-nsh"))
12803 errmsg ("parse error '%U'", format_unformat_error, line_input);
12808 if (local_set == 0)
12810 errmsg ("tunnel local address not specified");
12813 if (remote_set == 0)
12815 errmsg ("tunnel remote address not specified");
12818 if (grp_set && mcast_sw_if_index == ~0)
12820 errmsg ("tunnel nonexistent multicast device");
12823 if (ipv4_set && ipv6_set)
12825 errmsg ("both IPv4 and IPv6 addresses specified");
12831 errmsg ("vni not specified");
12835 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12840 clib_memcpy (&mp->local, &local6, sizeof (local6));
12841 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
12845 clib_memcpy (&mp->local, &local4, sizeof (local4));
12846 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
12849 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12850 mp->encap_vrf_id = ntohl (encap_vrf_id);
12851 mp->decap_vrf_id = ntohl (decap_vrf_id);
12852 mp->protocol = protocol;
12853 mp->vni = ntohl (vni);
12854 mp->is_add = is_add;
12855 mp->is_ipv6 = ipv6_set;
12862 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12863 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12865 vat_main_t *vam = &vat_main;
12866 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
12867 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
12869 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12870 ntohl (mp->sw_if_index),
12871 format_ip46_address, &local, IP46_TYPE_ANY,
12872 format_ip46_address, &remote, IP46_TYPE_ANY,
12873 ntohl (mp->vni), mp->protocol,
12874 ntohl (mp->mcast_sw_if_index),
12875 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12879 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12880 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12882 vat_main_t *vam = &vat_main;
12883 vat_json_node_t *node = NULL;
12884 struct in_addr ip4;
12885 struct in6_addr ip6;
12887 if (VAT_JSON_ARRAY != vam->json_tree.type)
12889 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12890 vat_json_init_array (&vam->json_tree);
12892 node = vat_json_array_add (&vam->json_tree);
12894 vat_json_init_object (node);
12895 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12898 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
12899 vat_json_object_add_ip6 (node, "local", ip6);
12900 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
12901 vat_json_object_add_ip6 (node, "remote", ip6);
12905 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
12906 vat_json_object_add_ip4 (node, "local", ip4);
12907 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
12908 vat_json_object_add_ip4 (node, "remote", ip4);
12910 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12911 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12912 vat_json_object_add_uint (node, "mcast_sw_if_index",
12913 ntohl (mp->mcast_sw_if_index));
12914 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12915 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12916 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12920 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12922 unformat_input_t *i = vam->input;
12923 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12924 vl_api_control_ping_t *mp_ping;
12926 u8 sw_if_index_set = 0;
12929 /* Parse args required to build the message */
12930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12932 if (unformat (i, "sw_if_index %d", &sw_if_index))
12933 sw_if_index_set = 1;
12938 if (sw_if_index_set == 0)
12943 if (!vam->json_output)
12945 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12946 "sw_if_index", "local", "remote", "vni",
12947 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12950 /* Get list of vxlan-tunnel interfaces */
12951 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12953 mp->sw_if_index = htonl (sw_if_index);
12957 /* Use a control ping for synchronization */
12958 MPING (CONTROL_PING, mp_ping);
12965 static void vl_api_l2_fib_table_details_t_handler
12966 (vl_api_l2_fib_table_details_t * mp)
12968 vat_main_t *vam = &vat_main;
12970 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12972 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12973 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12977 static void vl_api_l2_fib_table_details_t_handler_json
12978 (vl_api_l2_fib_table_details_t * mp)
12980 vat_main_t *vam = &vat_main;
12981 vat_json_node_t *node = NULL;
12983 if (VAT_JSON_ARRAY != vam->json_tree.type)
12985 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12986 vat_json_init_array (&vam->json_tree);
12988 node = vat_json_array_add (&vam->json_tree);
12990 vat_json_init_object (node);
12991 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12992 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12993 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12994 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12995 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12996 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13000 api_l2_fib_table_dump (vat_main_t * vam)
13002 unformat_input_t *i = vam->input;
13003 vl_api_l2_fib_table_dump_t *mp;
13004 vl_api_control_ping_t *mp_ping;
13009 /* Parse args required to build the message */
13010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13012 if (unformat (i, "bd_id %d", &bd_id))
13018 if (bd_id_set == 0)
13020 errmsg ("missing bridge domain");
13024 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13026 /* Get list of l2 fib entries */
13027 M (L2_FIB_TABLE_DUMP, mp);
13029 mp->bd_id = ntohl (bd_id);
13032 /* Use a control ping for synchronization */
13033 MPING (CONTROL_PING, mp_ping);
13042 api_interface_name_renumber (vat_main_t * vam)
13044 unformat_input_t *line_input = vam->input;
13045 vl_api_interface_name_renumber_t *mp;
13046 u32 sw_if_index = ~0;
13047 u32 new_show_dev_instance = ~0;
13050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13052 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13055 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13057 else if (unformat (line_input, "new_show_dev_instance %d",
13058 &new_show_dev_instance))
13064 if (sw_if_index == ~0)
13066 errmsg ("missing interface name or sw_if_index");
13070 if (new_show_dev_instance == ~0)
13072 errmsg ("missing new_show_dev_instance");
13076 M (INTERFACE_NAME_RENUMBER, mp);
13078 mp->sw_if_index = ntohl (sw_if_index);
13079 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13087 api_want_l2_macs_events (vat_main_t * vam)
13089 unformat_input_t *line_input = vam->input;
13090 vl_api_want_l2_macs_events_t *mp;
13091 u8 enable_disable = 1;
13092 u32 scan_delay = 0;
13093 u32 max_macs_in_event = 0;
13094 u32 learn_limit = 0;
13097 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13099 if (unformat (line_input, "learn-limit %d", &learn_limit))
13101 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13103 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13105 else if (unformat (line_input, "disable"))
13106 enable_disable = 0;
13111 M (WANT_L2_MACS_EVENTS, mp);
13112 mp->enable_disable = enable_disable;
13113 mp->pid = htonl (getpid ());
13114 mp->learn_limit = htonl (learn_limit);
13115 mp->scan_delay = (u8) scan_delay;
13116 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13123 api_input_acl_set_interface (vat_main_t * vam)
13125 unformat_input_t *i = vam->input;
13126 vl_api_input_acl_set_interface_t *mp;
13128 int sw_if_index_set;
13129 u32 ip4_table_index = ~0;
13130 u32 ip6_table_index = ~0;
13131 u32 l2_table_index = ~0;
13135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13137 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13138 sw_if_index_set = 1;
13139 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13140 sw_if_index_set = 1;
13141 else if (unformat (i, "del"))
13143 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13145 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13147 else if (unformat (i, "l2-table %d", &l2_table_index))
13151 clib_warning ("parse error '%U'", format_unformat_error, i);
13156 if (sw_if_index_set == 0)
13158 errmsg ("missing interface name or sw_if_index");
13162 M (INPUT_ACL_SET_INTERFACE, mp);
13164 mp->sw_if_index = ntohl (sw_if_index);
13165 mp->ip4_table_index = ntohl (ip4_table_index);
13166 mp->ip6_table_index = ntohl (ip6_table_index);
13167 mp->l2_table_index = ntohl (l2_table_index);
13168 mp->is_add = is_add;
13176 api_output_acl_set_interface (vat_main_t * vam)
13178 unformat_input_t *i = vam->input;
13179 vl_api_output_acl_set_interface_t *mp;
13181 int sw_if_index_set;
13182 u32 ip4_table_index = ~0;
13183 u32 ip6_table_index = ~0;
13184 u32 l2_table_index = ~0;
13188 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13190 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13191 sw_if_index_set = 1;
13192 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13193 sw_if_index_set = 1;
13194 else if (unformat (i, "del"))
13196 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13198 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13200 else if (unformat (i, "l2-table %d", &l2_table_index))
13204 clib_warning ("parse error '%U'", format_unformat_error, i);
13209 if (sw_if_index_set == 0)
13211 errmsg ("missing interface name or sw_if_index");
13215 M (OUTPUT_ACL_SET_INTERFACE, mp);
13217 mp->sw_if_index = ntohl (sw_if_index);
13218 mp->ip4_table_index = ntohl (ip4_table_index);
13219 mp->ip6_table_index = ntohl (ip6_table_index);
13220 mp->l2_table_index = ntohl (l2_table_index);
13221 mp->is_add = is_add;
13229 api_ip_address_dump (vat_main_t * vam)
13231 unformat_input_t *i = vam->input;
13232 vl_api_ip_address_dump_t *mp;
13233 vl_api_control_ping_t *mp_ping;
13234 u32 sw_if_index = ~0;
13235 u8 sw_if_index_set = 0;
13240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13242 if (unformat (i, "sw_if_index %d", &sw_if_index))
13243 sw_if_index_set = 1;
13245 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13246 sw_if_index_set = 1;
13247 else if (unformat (i, "ipv4"))
13249 else if (unformat (i, "ipv6"))
13255 if (ipv4_set && ipv6_set)
13257 errmsg ("ipv4 and ipv6 flags cannot be both set");
13261 if ((!ipv4_set) && (!ipv6_set))
13263 errmsg ("no ipv4 nor ipv6 flag set");
13267 if (sw_if_index_set == 0)
13269 errmsg ("missing interface name or sw_if_index");
13273 vam->current_sw_if_index = sw_if_index;
13274 vam->is_ipv6 = ipv6_set;
13276 M (IP_ADDRESS_DUMP, mp);
13277 mp->sw_if_index = ntohl (sw_if_index);
13278 mp->is_ipv6 = ipv6_set;
13281 /* Use a control ping for synchronization */
13282 MPING (CONTROL_PING, mp_ping);
13290 api_ip_dump (vat_main_t * vam)
13292 vl_api_ip_dump_t *mp;
13293 vl_api_control_ping_t *mp_ping;
13294 unformat_input_t *in = vam->input;
13301 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13303 if (unformat (in, "ipv4"))
13305 else if (unformat (in, "ipv6"))
13311 if (ipv4_set && ipv6_set)
13313 errmsg ("ipv4 and ipv6 flags cannot be both set");
13317 if ((!ipv4_set) && (!ipv6_set))
13319 errmsg ("no ipv4 nor ipv6 flag set");
13323 is_ipv6 = ipv6_set;
13324 vam->is_ipv6 = is_ipv6;
13326 /* free old data */
13327 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13329 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13331 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13334 mp->is_ipv6 = ipv6_set;
13337 /* Use a control ping for synchronization */
13338 MPING (CONTROL_PING, mp_ping);
13346 api_ipsec_spd_add_del (vat_main_t * vam)
13348 unformat_input_t *i = vam->input;
13349 vl_api_ipsec_spd_add_del_t *mp;
13354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13356 if (unformat (i, "spd_id %d", &spd_id))
13358 else if (unformat (i, "del"))
13362 clib_warning ("parse error '%U'", format_unformat_error, i);
13368 errmsg ("spd_id must be set");
13372 M (IPSEC_SPD_ADD_DEL, mp);
13374 mp->spd_id = ntohl (spd_id);
13375 mp->is_add = is_add;
13383 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13385 unformat_input_t *i = vam->input;
13386 vl_api_ipsec_interface_add_del_spd_t *mp;
13388 u8 sw_if_index_set = 0;
13389 u32 spd_id = (u32) ~ 0;
13393 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13395 if (unformat (i, "del"))
13397 else if (unformat (i, "spd_id %d", &spd_id))
13400 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13401 sw_if_index_set = 1;
13402 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13403 sw_if_index_set = 1;
13406 clib_warning ("parse error '%U'", format_unformat_error, i);
13412 if (spd_id == (u32) ~ 0)
13414 errmsg ("spd_id must be set");
13418 if (sw_if_index_set == 0)
13420 errmsg ("missing interface name or sw_if_index");
13424 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13426 mp->spd_id = ntohl (spd_id);
13427 mp->sw_if_index = ntohl (sw_if_index);
13428 mp->is_add = is_add;
13436 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13438 unformat_input_t *i = vam->input;
13439 vl_api_ipsec_spd_entry_add_del_t *mp;
13440 u8 is_add = 1, is_outbound = 0;
13441 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13443 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13444 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13445 vl_api_address_t laddr_start = { }, laddr_stop =
13454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13456 if (unformat (i, "del"))
13458 if (unformat (i, "outbound"))
13460 if (unformat (i, "inbound"))
13462 else if (unformat (i, "spd_id %d", &spd_id))
13464 else if (unformat (i, "sa_id %d", &sa_id))
13466 else if (unformat (i, "priority %d", &priority))
13468 else if (unformat (i, "protocol %d", &protocol))
13470 else if (unformat (i, "lport_start %d", &lport_start))
13472 else if (unformat (i, "lport_stop %d", &lport_stop))
13474 else if (unformat (i, "rport_start %d", &rport_start))
13476 else if (unformat (i, "rport_stop %d", &rport_stop))
13478 else if (unformat (i, "laddr_start %U",
13479 unformat_vl_api_address, &laddr_start))
13481 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13484 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13487 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13491 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13493 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13495 clib_warning ("unsupported action: 'resolve'");
13501 clib_warning ("parse error '%U'", format_unformat_error, i);
13507 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13509 mp->is_add = is_add;
13511 mp->entry.spd_id = ntohl (spd_id);
13512 mp->entry.priority = ntohl (priority);
13513 mp->entry.is_outbound = is_outbound;
13515 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13516 sizeof (vl_api_address_t));
13517 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13518 sizeof (vl_api_address_t));
13519 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13520 sizeof (vl_api_address_t));
13521 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13522 sizeof (vl_api_address_t));
13524 mp->entry.protocol = (u8) protocol;
13525 mp->entry.local_port_start = ntohs ((u16) lport_start);
13526 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13527 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13528 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13529 mp->entry.policy = (u8) policy;
13530 mp->entry.sa_id = ntohl (sa_id);
13538 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13540 unformat_input_t *i = vam->input;
13541 vl_api_ipsec_sad_entry_add_del_t *mp;
13542 u32 sad_id = 0, spi = 0;
13543 u8 *ck = 0, *ik = 0;
13546 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13547 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13548 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13549 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13550 vl_api_address_t tun_src, tun_dst;
13553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13555 if (unformat (i, "del"))
13557 else if (unformat (i, "sad_id %d", &sad_id))
13559 else if (unformat (i, "spi %d", &spi))
13561 else if (unformat (i, "esp"))
13562 protocol = IPSEC_API_PROTO_ESP;
13564 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13566 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13567 if (ADDRESS_IP6 == tun_src.af)
13568 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13571 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13573 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13574 if (ADDRESS_IP6 == tun_src.af)
13575 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13578 if (unformat (i, "crypto_alg %U",
13579 unformat_ipsec_api_crypto_alg, &crypto_alg))
13581 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13583 else if (unformat (i, "integ_alg %U",
13584 unformat_ipsec_api_integ_alg, &integ_alg))
13586 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13590 clib_warning ("parse error '%U'", format_unformat_error, i);
13596 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13598 mp->is_add = is_add;
13599 mp->entry.sad_id = ntohl (sad_id);
13600 mp->entry.protocol = protocol;
13601 mp->entry.spi = ntohl (spi);
13602 mp->entry.flags = flags;
13604 mp->entry.crypto_algorithm = crypto_alg;
13605 mp->entry.integrity_algorithm = integ_alg;
13606 mp->entry.crypto_key.length = vec_len (ck);
13607 mp->entry.integrity_key.length = vec_len (ik);
13609 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13610 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13612 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13613 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13616 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13618 clib_memcpy (mp->entry.integrity_key.data, ik,
13619 mp->entry.integrity_key.length);
13621 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13623 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13624 sizeof (mp->entry.tunnel_src));
13625 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13626 sizeof (mp->entry.tunnel_dst));
13635 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13637 unformat_input_t *i = vam->input;
13638 vl_api_ipsec_tunnel_if_add_del_t *mp;
13639 u32 local_spi = 0, remote_spi = 0;
13640 u32 crypto_alg = 0, integ_alg = 0;
13641 u8 *lck = NULL, *rck = NULL;
13642 u8 *lik = NULL, *rik = NULL;
13643 vl_api_address_t local_ip = { 0 };
13644 vl_api_address_t remote_ip = { 0 };
13648 u8 anti_replay = 0;
13654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13656 if (unformat (i, "del"))
13658 else if (unformat (i, "esn"))
13660 else if (unformat (i, "anti-replay"))
13662 else if (unformat (i, "count %d", &count))
13664 else if (unformat (i, "local_spi %d", &local_spi))
13666 else if (unformat (i, "remote_spi %d", &remote_spi))
13669 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13672 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13674 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13677 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13679 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13681 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13685 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13687 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13689 errmsg ("unsupported crypto-alg: '%U'\n",
13690 format_ipsec_crypto_alg, crypto_alg);
13696 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13698 if (integ_alg >= IPSEC_INTEG_N_ALG)
13700 errmsg ("unsupported integ-alg: '%U'\n",
13701 format_ipsec_integ_alg, integ_alg);
13705 else if (unformat (i, "instance %u", &instance))
13709 errmsg ("parse error '%U'\n", format_unformat_error, i);
13716 /* Turn on async mode */
13717 vam->async_mode = 1;
13718 vam->async_errors = 0;
13719 before = vat_time_now (vam);
13722 for (jj = 0; jj < count; jj++)
13724 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13726 mp->is_add = is_add;
13728 mp->anti_replay = anti_replay;
13731 increment_address (&remote_ip);
13733 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13734 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13736 mp->local_spi = htonl (local_spi + jj);
13737 mp->remote_spi = htonl (remote_spi + jj);
13738 mp->crypto_alg = (u8) crypto_alg;
13740 mp->local_crypto_key_len = 0;
13743 mp->local_crypto_key_len = vec_len (lck);
13744 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13745 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13746 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13749 mp->remote_crypto_key_len = 0;
13752 mp->remote_crypto_key_len = vec_len (rck);
13753 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13754 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13755 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13758 mp->integ_alg = (u8) integ_alg;
13760 mp->local_integ_key_len = 0;
13763 mp->local_integ_key_len = vec_len (lik);
13764 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13765 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13766 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13769 mp->remote_integ_key_len = 0;
13772 mp->remote_integ_key_len = vec_len (rik);
13773 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13774 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13775 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13780 mp->renumber = renumber;
13781 mp->show_instance = ntohl (instance);
13786 /* When testing multiple add/del ops, use a control-ping to sync */
13789 vl_api_control_ping_t *mp_ping;
13793 /* Shut off async mode */
13794 vam->async_mode = 0;
13796 MPING (CONTROL_PING, mp_ping);
13799 timeout = vat_time_now (vam) + 1.0;
13800 while (vat_time_now (vam) < timeout)
13801 if (vam->result_ready == 1)
13806 if (vam->retval == -99)
13807 errmsg ("timeout");
13809 if (vam->async_errors > 0)
13811 errmsg ("%d asynchronous errors", vam->async_errors);
13814 vam->async_errors = 0;
13815 after = vat_time_now (vam);
13817 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13821 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13822 count, after - before, count / (after - before));
13826 /* Wait for a reply... */
13835 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13837 vat_main_t *vam = &vat_main;
13839 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13840 "crypto_key %U integ_alg %u integ_key %U flags %x "
13841 "tunnel_src_addr %U tunnel_dst_addr %U "
13842 "salt %u seq_outbound %lu last_seq_inbound %lu "
13843 "replay_window %lu\n",
13844 ntohl (mp->entry.sad_id),
13845 ntohl (mp->sw_if_index),
13846 ntohl (mp->entry.spi),
13847 ntohl (mp->entry.protocol),
13848 ntohl (mp->entry.crypto_algorithm),
13849 format_hex_bytes, mp->entry.crypto_key.data,
13850 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13851 format_hex_bytes, mp->entry.integrity_key.data,
13852 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13853 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13854 &mp->entry.tunnel_dst, ntohl (mp->salt),
13855 clib_net_to_host_u64 (mp->seq_outbound),
13856 clib_net_to_host_u64 (mp->last_seq_inbound),
13857 clib_net_to_host_u64 (mp->replay_window));
13860 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13861 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13863 static void vl_api_ipsec_sa_details_t_handler_json
13864 (vl_api_ipsec_sa_details_t * mp)
13866 vat_main_t *vam = &vat_main;
13867 vat_json_node_t *node = NULL;
13868 vl_api_ipsec_sad_flags_t flags;
13870 if (VAT_JSON_ARRAY != vam->json_tree.type)
13872 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13873 vat_json_init_array (&vam->json_tree);
13875 node = vat_json_array_add (&vam->json_tree);
13877 vat_json_init_object (node);
13878 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13879 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13880 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13881 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13882 vat_json_object_add_uint (node, "crypto_alg",
13883 ntohl (mp->entry.crypto_algorithm));
13884 vat_json_object_add_uint (node, "integ_alg",
13885 ntohl (mp->entry.integrity_algorithm));
13886 flags = ntohl (mp->entry.flags);
13887 vat_json_object_add_uint (node, "use_esn",
13888 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13889 vat_json_object_add_uint (node, "use_anti_replay",
13890 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13891 vat_json_object_add_uint (node, "is_tunnel",
13892 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13893 vat_json_object_add_uint (node, "is_tunnel_ip6",
13894 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13895 vat_json_object_add_uint (node, "udp_encap",
13896 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13897 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13898 mp->entry.crypto_key.length);
13899 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13900 mp->entry.integrity_key.length);
13901 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13902 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13903 vat_json_object_add_uint (node, "replay_window",
13904 clib_net_to_host_u64 (mp->replay_window));
13908 api_ipsec_sa_dump (vat_main_t * vam)
13910 unformat_input_t *i = vam->input;
13911 vl_api_ipsec_sa_dump_t *mp;
13912 vl_api_control_ping_t *mp_ping;
13916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13918 if (unformat (i, "sa_id %d", &sa_id))
13922 clib_warning ("parse error '%U'", format_unformat_error, i);
13927 M (IPSEC_SA_DUMP, mp);
13929 mp->sa_id = ntohl (sa_id);
13933 /* Use a control ping for synchronization */
13934 M (CONTROL_PING, mp_ping);
13942 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13944 unformat_input_t *i = vam->input;
13945 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13946 u32 sw_if_index = ~0;
13948 u8 is_outbound = (u8) ~ 0;
13951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13953 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13955 else if (unformat (i, "sa_id %d", &sa_id))
13957 else if (unformat (i, "outbound"))
13959 else if (unformat (i, "inbound"))
13963 clib_warning ("parse error '%U'", format_unformat_error, i);
13968 if (sw_if_index == ~0)
13970 errmsg ("interface must be specified");
13976 errmsg ("SA ID must be specified");
13980 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13982 mp->sw_if_index = htonl (sw_if_index);
13983 mp->sa_id = htonl (sa_id);
13984 mp->is_outbound = is_outbound;
13993 api_get_first_msg_id (vat_main_t * vam)
13995 vl_api_get_first_msg_id_t *mp;
13996 unformat_input_t *i = vam->input;
14001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14003 if (unformat (i, "client %s", &name))
14011 errmsg ("missing client name");
14014 vec_add1 (name, 0);
14016 if (vec_len (name) > 63)
14018 errmsg ("client name too long");
14022 M (GET_FIRST_MSG_ID, mp);
14023 clib_memcpy (mp->name, name, vec_len (name));
14030 api_cop_interface_enable_disable (vat_main_t * vam)
14032 unformat_input_t *line_input = vam->input;
14033 vl_api_cop_interface_enable_disable_t *mp;
14034 u32 sw_if_index = ~0;
14035 u8 enable_disable = 1;
14038 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14040 if (unformat (line_input, "disable"))
14041 enable_disable = 0;
14042 if (unformat (line_input, "enable"))
14043 enable_disable = 1;
14044 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14045 vam, &sw_if_index))
14047 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14053 if (sw_if_index == ~0)
14055 errmsg ("missing interface name or sw_if_index");
14059 /* Construct the API message */
14060 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14061 mp->sw_if_index = ntohl (sw_if_index);
14062 mp->enable_disable = enable_disable;
14066 /* Wait for the reply */
14072 api_cop_whitelist_enable_disable (vat_main_t * vam)
14074 unformat_input_t *line_input = vam->input;
14075 vl_api_cop_whitelist_enable_disable_t *mp;
14076 u32 sw_if_index = ~0;
14077 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14081 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14083 if (unformat (line_input, "ip4"))
14085 else if (unformat (line_input, "ip6"))
14087 else if (unformat (line_input, "default"))
14089 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14090 vam, &sw_if_index))
14092 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14094 else if (unformat (line_input, "fib-id %d", &fib_id))
14100 if (sw_if_index == ~0)
14102 errmsg ("missing interface name or sw_if_index");
14106 /* Construct the API message */
14107 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14108 mp->sw_if_index = ntohl (sw_if_index);
14109 mp->fib_id = ntohl (fib_id);
14112 mp->default_cop = default_cop;
14116 /* Wait for the reply */
14122 api_get_node_graph (vat_main_t * vam)
14124 vl_api_get_node_graph_t *mp;
14127 M (GET_NODE_GRAPH, mp);
14131 /* Wait for the reply */
14137 /** Used for parsing LISP eids */
14138 typedef CLIB_PACKED(struct{
14139 u8 addr[16]; /**< eid address */
14140 u32 len; /**< prefix length if IP */
14141 u8 type; /**< type of eid */
14146 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14148 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14150 clib_memset (a, 0, sizeof (a[0]));
14152 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14154 a->type = 0; /* ipv4 type */
14156 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14158 a->type = 1; /* ipv6 type */
14160 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14162 a->type = 2; /* mac type */
14164 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14166 a->type = 3; /* NSH type */
14167 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14168 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14175 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14184 lisp_eid_size_vat (u8 type)
14201 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14203 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14207 api_one_add_del_locator_set (vat_main_t * vam)
14209 unformat_input_t *input = vam->input;
14210 vl_api_one_add_del_locator_set_t *mp;
14212 u8 *locator_set_name = NULL;
14213 u8 locator_set_name_set = 0;
14214 vl_api_local_locator_t locator, *locators = 0;
14215 u32 sw_if_index, priority, weight;
14219 /* Parse args required to build the message */
14220 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14222 if (unformat (input, "del"))
14226 else if (unformat (input, "locator-set %s", &locator_set_name))
14228 locator_set_name_set = 1;
14230 else if (unformat (input, "sw_if_index %u p %u w %u",
14231 &sw_if_index, &priority, &weight))
14233 locator.sw_if_index = htonl (sw_if_index);
14234 locator.priority = priority;
14235 locator.weight = weight;
14236 vec_add1 (locators, locator);
14240 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14241 &sw_if_index, &priority, &weight))
14243 locator.sw_if_index = htonl (sw_if_index);
14244 locator.priority = priority;
14245 locator.weight = weight;
14246 vec_add1 (locators, locator);
14252 if (locator_set_name_set == 0)
14254 errmsg ("missing locator-set name");
14255 vec_free (locators);
14259 if (vec_len (locator_set_name) > 64)
14261 errmsg ("locator-set name too long");
14262 vec_free (locator_set_name);
14263 vec_free (locators);
14266 vec_add1 (locator_set_name, 0);
14268 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14270 /* Construct the API message */
14271 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14273 mp->is_add = is_add;
14274 clib_memcpy (mp->locator_set_name, locator_set_name,
14275 vec_len (locator_set_name));
14276 vec_free (locator_set_name);
14278 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14280 clib_memcpy (mp->locators, locators, data_len);
14281 vec_free (locators);
14286 /* Wait for a reply... */
14291 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14294 api_one_add_del_locator (vat_main_t * vam)
14296 unformat_input_t *input = vam->input;
14297 vl_api_one_add_del_locator_t *mp;
14298 u32 tmp_if_index = ~0;
14299 u32 sw_if_index = ~0;
14300 u8 sw_if_index_set = 0;
14301 u8 sw_if_index_if_name_set = 0;
14303 u8 priority_set = 0;
14307 u8 *locator_set_name = NULL;
14308 u8 locator_set_name_set = 0;
14311 /* Parse args required to build the message */
14312 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14314 if (unformat (input, "del"))
14318 else if (unformat (input, "locator-set %s", &locator_set_name))
14320 locator_set_name_set = 1;
14322 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14325 sw_if_index_if_name_set = 1;
14326 sw_if_index = tmp_if_index;
14328 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14330 sw_if_index_set = 1;
14331 sw_if_index = tmp_if_index;
14333 else if (unformat (input, "p %d", &priority))
14337 else if (unformat (input, "w %d", &weight))
14345 if (locator_set_name_set == 0)
14347 errmsg ("missing locator-set name");
14351 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14353 errmsg ("missing sw_if_index");
14354 vec_free (locator_set_name);
14358 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14360 errmsg ("cannot use both params interface name and sw_if_index");
14361 vec_free (locator_set_name);
14365 if (priority_set == 0)
14367 errmsg ("missing locator-set priority");
14368 vec_free (locator_set_name);
14372 if (weight_set == 0)
14374 errmsg ("missing locator-set weight");
14375 vec_free (locator_set_name);
14379 if (vec_len (locator_set_name) > 64)
14381 errmsg ("locator-set name too long");
14382 vec_free (locator_set_name);
14385 vec_add1 (locator_set_name, 0);
14387 /* Construct the API message */
14388 M (ONE_ADD_DEL_LOCATOR, mp);
14390 mp->is_add = is_add;
14391 mp->sw_if_index = ntohl (sw_if_index);
14392 mp->priority = priority;
14393 mp->weight = weight;
14394 clib_memcpy (mp->locator_set_name, locator_set_name,
14395 vec_len (locator_set_name));
14396 vec_free (locator_set_name);
14401 /* Wait for a reply... */
14406 #define api_lisp_add_del_locator api_one_add_del_locator
14409 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14411 u32 *key_id = va_arg (*args, u32 *);
14414 if (unformat (input, "%s", &s))
14416 if (!strcmp ((char *) s, "sha1"))
14417 key_id[0] = HMAC_SHA_1_96;
14418 else if (!strcmp ((char *) s, "sha256"))
14419 key_id[0] = HMAC_SHA_256_128;
14422 clib_warning ("invalid key_id: '%s'", s);
14423 key_id[0] = HMAC_NO_KEY;
14434 api_one_add_del_local_eid (vat_main_t * vam)
14436 unformat_input_t *input = vam->input;
14437 vl_api_one_add_del_local_eid_t *mp;
14440 lisp_eid_vat_t _eid, *eid = &_eid;
14441 u8 *locator_set_name = 0;
14442 u8 locator_set_name_set = 0;
14448 /* Parse args required to build the message */
14449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14451 if (unformat (input, "del"))
14455 else if (unformat (input, "vni %d", &vni))
14459 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14463 else if (unformat (input, "locator-set %s", &locator_set_name))
14465 locator_set_name_set = 1;
14467 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14469 else if (unformat (input, "secret-key %_%v%_", &key))
14475 if (locator_set_name_set == 0)
14477 errmsg ("missing locator-set name");
14483 errmsg ("EID address not set!");
14484 vec_free (locator_set_name);
14488 if (key && (0 == key_id))
14490 errmsg ("invalid key_id!");
14494 if (vec_len (key) > 64)
14496 errmsg ("key too long");
14501 if (vec_len (locator_set_name) > 64)
14503 errmsg ("locator-set name too long");
14504 vec_free (locator_set_name);
14507 vec_add1 (locator_set_name, 0);
14509 /* Construct the API message */
14510 M (ONE_ADD_DEL_LOCAL_EID, mp);
14512 mp->is_add = is_add;
14513 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14514 mp->eid_type = eid->type;
14515 mp->prefix_len = eid->len;
14516 mp->vni = clib_host_to_net_u32 (vni);
14517 mp->key_id = clib_host_to_net_u16 (key_id);
14518 clib_memcpy (mp->locator_set_name, locator_set_name,
14519 vec_len (locator_set_name));
14520 clib_memcpy (mp->key, key, vec_len (key));
14522 vec_free (locator_set_name);
14528 /* Wait for a reply... */
14533 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14536 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14538 u32 dp_table = 0, vni = 0;;
14539 unformat_input_t *input = vam->input;
14540 vl_api_gpe_add_del_fwd_entry_t *mp;
14542 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14543 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14544 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14545 u32 action = ~0, w;
14546 ip4_address_t rmt_rloc4, lcl_rloc4;
14547 ip6_address_t rmt_rloc6, lcl_rloc6;
14548 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14551 clib_memset (&rloc, 0, sizeof (rloc));
14553 /* Parse args required to build the message */
14554 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14556 if (unformat (input, "del"))
14558 else if (unformat (input, "add"))
14560 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14564 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14568 else if (unformat (input, "vrf %d", &dp_table))
14570 else if (unformat (input, "bd %d", &dp_table))
14572 else if (unformat (input, "vni %d", &vni))
14574 else if (unformat (input, "w %d", &w))
14578 errmsg ("No RLOC configured for setting priority/weight!");
14581 curr_rloc->weight = w;
14583 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14584 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14588 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14590 vec_add1 (lcl_locs, rloc);
14592 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14593 vec_add1 (rmt_locs, rloc);
14594 /* weight saved in rmt loc */
14595 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14597 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14598 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14601 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14603 vec_add1 (lcl_locs, rloc);
14605 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14606 vec_add1 (rmt_locs, rloc);
14607 /* weight saved in rmt loc */
14608 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14610 else if (unformat (input, "action %d", &action))
14616 clib_warning ("parse error '%U'", format_unformat_error, input);
14623 errmsg ("remote eid addresses not set");
14627 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14629 errmsg ("eid types don't match");
14633 if (0 == rmt_locs && (u32) ~ 0 == action)
14635 errmsg ("action not set for negative mapping");
14639 /* Construct the API message */
14640 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14641 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14643 mp->is_add = is_add;
14644 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14645 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14646 mp->eid_type = rmt_eid->type;
14647 mp->dp_table = clib_host_to_net_u32 (dp_table);
14648 mp->vni = clib_host_to_net_u32 (vni);
14649 mp->rmt_len = rmt_eid->len;
14650 mp->lcl_len = lcl_eid->len;
14651 mp->action = action;
14653 if (0 != rmt_locs && 0 != lcl_locs)
14655 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14656 clib_memcpy (mp->locs, lcl_locs,
14657 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14659 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14660 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14661 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14663 vec_free (lcl_locs);
14664 vec_free (rmt_locs);
14669 /* Wait for a reply... */
14675 api_one_add_del_map_server (vat_main_t * vam)
14677 unformat_input_t *input = vam->input;
14678 vl_api_one_add_del_map_server_t *mp;
14682 ip4_address_t ipv4;
14683 ip6_address_t ipv6;
14686 /* Parse args required to build the message */
14687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14689 if (unformat (input, "del"))
14693 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14697 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14705 if (ipv4_set && ipv6_set)
14707 errmsg ("both eid v4 and v6 addresses set");
14711 if (!ipv4_set && !ipv6_set)
14713 errmsg ("eid addresses not set");
14717 /* Construct the API message */
14718 M (ONE_ADD_DEL_MAP_SERVER, mp);
14720 mp->is_add = is_add;
14724 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14729 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14735 /* Wait for a reply... */
14740 #define api_lisp_add_del_map_server api_one_add_del_map_server
14743 api_one_add_del_map_resolver (vat_main_t * vam)
14745 unformat_input_t *input = vam->input;
14746 vl_api_one_add_del_map_resolver_t *mp;
14750 ip4_address_t ipv4;
14751 ip6_address_t ipv6;
14754 /* Parse args required to build the message */
14755 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14757 if (unformat (input, "del"))
14761 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14765 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14773 if (ipv4_set && ipv6_set)
14775 errmsg ("both eid v4 and v6 addresses set");
14779 if (!ipv4_set && !ipv6_set)
14781 errmsg ("eid addresses not set");
14785 /* Construct the API message */
14786 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14788 mp->is_add = is_add;
14792 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14797 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14803 /* Wait for a reply... */
14808 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14811 api_lisp_gpe_enable_disable (vat_main_t * vam)
14813 unformat_input_t *input = vam->input;
14814 vl_api_gpe_enable_disable_t *mp;
14819 /* Parse args required to build the message */
14820 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14822 if (unformat (input, "enable"))
14827 else if (unformat (input, "disable"))
14838 errmsg ("Value not set");
14842 /* Construct the API message */
14843 M (GPE_ENABLE_DISABLE, mp);
14850 /* Wait for a reply... */
14856 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14858 unformat_input_t *input = vam->input;
14859 vl_api_one_rloc_probe_enable_disable_t *mp;
14864 /* Parse args required to build the message */
14865 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14867 if (unformat (input, "enable"))
14872 else if (unformat (input, "disable"))
14880 errmsg ("Value not set");
14884 /* Construct the API message */
14885 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14887 mp->is_enabled = is_en;
14892 /* Wait for a reply... */
14897 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14900 api_one_map_register_enable_disable (vat_main_t * vam)
14902 unformat_input_t *input = vam->input;
14903 vl_api_one_map_register_enable_disable_t *mp;
14908 /* Parse args required to build the message */
14909 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14911 if (unformat (input, "enable"))
14916 else if (unformat (input, "disable"))
14924 errmsg ("Value not set");
14928 /* Construct the API message */
14929 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14931 mp->is_enabled = is_en;
14936 /* Wait for a reply... */
14941 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14944 api_one_enable_disable (vat_main_t * vam)
14946 unformat_input_t *input = vam->input;
14947 vl_api_one_enable_disable_t *mp;
14952 /* Parse args required to build the message */
14953 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14955 if (unformat (input, "enable"))
14960 else if (unformat (input, "disable"))
14970 errmsg ("Value not set");
14974 /* Construct the API message */
14975 M (ONE_ENABLE_DISABLE, mp);
14982 /* Wait for a reply... */
14987 #define api_lisp_enable_disable api_one_enable_disable
14990 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14992 unformat_input_t *input = vam->input;
14993 vl_api_one_enable_disable_xtr_mode_t *mp;
14998 /* Parse args required to build the message */
14999 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15001 if (unformat (input, "enable"))
15006 else if (unformat (input, "disable"))
15016 errmsg ("Value not set");
15020 /* Construct the API message */
15021 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15028 /* Wait for a reply... */
15034 api_one_show_xtr_mode (vat_main_t * vam)
15036 vl_api_one_show_xtr_mode_t *mp;
15039 /* Construct the API message */
15040 M (ONE_SHOW_XTR_MODE, mp);
15045 /* Wait for a reply... */
15051 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15053 unformat_input_t *input = vam->input;
15054 vl_api_one_enable_disable_pitr_mode_t *mp;
15059 /* Parse args required to build the message */
15060 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15062 if (unformat (input, "enable"))
15067 else if (unformat (input, "disable"))
15077 errmsg ("Value not set");
15081 /* Construct the API message */
15082 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15089 /* Wait for a reply... */
15095 api_one_show_pitr_mode (vat_main_t * vam)
15097 vl_api_one_show_pitr_mode_t *mp;
15100 /* Construct the API message */
15101 M (ONE_SHOW_PITR_MODE, mp);
15106 /* Wait for a reply... */
15112 api_one_enable_disable_petr_mode (vat_main_t * vam)
15114 unformat_input_t *input = vam->input;
15115 vl_api_one_enable_disable_petr_mode_t *mp;
15120 /* Parse args required to build the message */
15121 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15123 if (unformat (input, "enable"))
15128 else if (unformat (input, "disable"))
15138 errmsg ("Value not set");
15142 /* Construct the API message */
15143 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15150 /* Wait for a reply... */
15156 api_one_show_petr_mode (vat_main_t * vam)
15158 vl_api_one_show_petr_mode_t *mp;
15161 /* Construct the API message */
15162 M (ONE_SHOW_PETR_MODE, mp);
15167 /* Wait for a reply... */
15173 api_show_one_map_register_state (vat_main_t * vam)
15175 vl_api_show_one_map_register_state_t *mp;
15178 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15183 /* wait for reply */
15188 #define api_show_lisp_map_register_state api_show_one_map_register_state
15191 api_show_one_rloc_probe_state (vat_main_t * vam)
15193 vl_api_show_one_rloc_probe_state_t *mp;
15196 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15201 /* wait for reply */
15206 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15209 api_one_add_del_ndp_entry (vat_main_t * vam)
15211 vl_api_one_add_del_ndp_entry_t *mp;
15212 unformat_input_t *input = vam->input;
15217 u8 mac[6] = { 0, };
15218 u8 ip6[16] = { 0, };
15222 /* Parse args required to build the message */
15223 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15225 if (unformat (input, "del"))
15227 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15229 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15231 else if (unformat (input, "bd %d", &bd))
15235 errmsg ("parse error '%U'", format_unformat_error, input);
15240 if (!bd_set || !ip_set || (!mac_set && is_add))
15242 errmsg ("Missing BD, IP or MAC!");
15246 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15247 mp->is_add = is_add;
15248 clib_memcpy (mp->mac, mac, 6);
15249 mp->bd = clib_host_to_net_u32 (bd);
15250 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15255 /* wait for reply */
15261 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15263 vl_api_one_add_del_l2_arp_entry_t *mp;
15264 unformat_input_t *input = vam->input;
15269 u8 mac[6] = { 0, };
15270 u32 ip4 = 0, bd = ~0;
15273 /* Parse args required to build the message */
15274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15276 if (unformat (input, "del"))
15278 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15280 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15282 else if (unformat (input, "bd %d", &bd))
15286 errmsg ("parse error '%U'", format_unformat_error, input);
15291 if (!bd_set || !ip_set || (!mac_set && is_add))
15293 errmsg ("Missing BD, IP or MAC!");
15297 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15298 mp->is_add = is_add;
15299 clib_memcpy (mp->mac, mac, 6);
15300 mp->bd = clib_host_to_net_u32 (bd);
15306 /* wait for reply */
15312 api_one_ndp_bd_get (vat_main_t * vam)
15314 vl_api_one_ndp_bd_get_t *mp;
15317 M (ONE_NDP_BD_GET, mp);
15322 /* wait for reply */
15328 api_one_ndp_entries_get (vat_main_t * vam)
15330 vl_api_one_ndp_entries_get_t *mp;
15331 unformat_input_t *input = vam->input;
15336 /* Parse args required to build the message */
15337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15339 if (unformat (input, "bd %d", &bd))
15343 errmsg ("parse error '%U'", format_unformat_error, input);
15350 errmsg ("Expected bridge domain!");
15354 M (ONE_NDP_ENTRIES_GET, mp);
15355 mp->bd = clib_host_to_net_u32 (bd);
15360 /* wait for reply */
15366 api_one_l2_arp_bd_get (vat_main_t * vam)
15368 vl_api_one_l2_arp_bd_get_t *mp;
15371 M (ONE_L2_ARP_BD_GET, mp);
15376 /* wait for reply */
15382 api_one_l2_arp_entries_get (vat_main_t * vam)
15384 vl_api_one_l2_arp_entries_get_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, "bd %d", &bd))
15397 errmsg ("parse error '%U'", format_unformat_error, input);
15404 errmsg ("Expected bridge domain!");
15408 M (ONE_L2_ARP_ENTRIES_GET, mp);
15409 mp->bd = clib_host_to_net_u32 (bd);
15414 /* wait for reply */
15420 api_one_stats_enable_disable (vat_main_t * vam)
15422 vl_api_one_stats_enable_disable_t *mp;
15423 unformat_input_t *input = vam->input;
15428 /* Parse args required to build the message */
15429 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15431 if (unformat (input, "enable"))
15436 else if (unformat (input, "disable"))
15446 errmsg ("Value not set");
15450 M (ONE_STATS_ENABLE_DISABLE, mp);
15456 /* wait for reply */
15462 api_show_one_stats_enable_disable (vat_main_t * vam)
15464 vl_api_show_one_stats_enable_disable_t *mp;
15467 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15472 /* wait for reply */
15478 api_show_one_map_request_mode (vat_main_t * vam)
15480 vl_api_show_one_map_request_mode_t *mp;
15483 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15488 /* wait for reply */
15493 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15496 api_one_map_request_mode (vat_main_t * vam)
15498 unformat_input_t *input = vam->input;
15499 vl_api_one_map_request_mode_t *mp;
15503 /* Parse args required to build the message */
15504 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15506 if (unformat (input, "dst-only"))
15508 else if (unformat (input, "src-dst"))
15512 errmsg ("parse error '%U'", format_unformat_error, input);
15517 M (ONE_MAP_REQUEST_MODE, mp);
15524 /* wait for reply */
15529 #define api_lisp_map_request_mode api_one_map_request_mode
15532 * Enable/disable ONE proxy ITR.
15534 * @param vam vpp API test context
15535 * @return return code
15538 api_one_pitr_set_locator_set (vat_main_t * vam)
15540 u8 ls_name_set = 0;
15541 unformat_input_t *input = vam->input;
15542 vl_api_one_pitr_set_locator_set_t *mp;
15547 /* Parse args required to build the message */
15548 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15550 if (unformat (input, "del"))
15552 else if (unformat (input, "locator-set %s", &ls_name))
15556 errmsg ("parse error '%U'", format_unformat_error, input);
15563 errmsg ("locator-set name not set!");
15567 M (ONE_PITR_SET_LOCATOR_SET, mp);
15569 mp->is_add = is_add;
15570 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15571 vec_free (ls_name);
15576 /* wait for reply */
15581 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15584 api_one_nsh_set_locator_set (vat_main_t * vam)
15586 u8 ls_name_set = 0;
15587 unformat_input_t *input = vam->input;
15588 vl_api_one_nsh_set_locator_set_t *mp;
15593 /* Parse args required to build the message */
15594 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15596 if (unformat (input, "del"))
15598 else if (unformat (input, "ls %s", &ls_name))
15602 errmsg ("parse error '%U'", format_unformat_error, input);
15607 if (!ls_name_set && is_add)
15609 errmsg ("locator-set name not set!");
15613 M (ONE_NSH_SET_LOCATOR_SET, mp);
15615 mp->is_add = is_add;
15616 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15617 vec_free (ls_name);
15622 /* wait for reply */
15628 api_show_one_pitr (vat_main_t * vam)
15630 vl_api_show_one_pitr_t *mp;
15633 if (!vam->json_output)
15635 print (vam->ofp, "%=20s", "lisp status:");
15638 M (SHOW_ONE_PITR, mp);
15642 /* Wait for a reply... */
15647 #define api_show_lisp_pitr api_show_one_pitr
15650 api_one_use_petr (vat_main_t * vam)
15652 unformat_input_t *input = vam->input;
15653 vl_api_one_use_petr_t *mp;
15658 clib_memset (&ip, 0, sizeof (ip));
15660 /* Parse args required to build the message */
15661 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15663 if (unformat (input, "disable"))
15666 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15669 ip_addr_version (&ip) = AF_IP4;
15672 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15675 ip_addr_version (&ip) = AF_IP6;
15679 errmsg ("parse error '%U'", format_unformat_error, input);
15684 M (ONE_USE_PETR, mp);
15686 mp->is_add = is_add;
15689 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15691 clib_memcpy (mp->address, &ip, 4);
15693 clib_memcpy (mp->address, &ip, 16);
15699 /* wait for reply */
15704 #define api_lisp_use_petr api_one_use_petr
15707 api_show_one_nsh_mapping (vat_main_t * vam)
15709 vl_api_show_one_use_petr_t *mp;
15712 if (!vam->json_output)
15714 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15717 M (SHOW_ONE_NSH_MAPPING, mp);
15721 /* Wait for a reply... */
15727 api_show_one_use_petr (vat_main_t * vam)
15729 vl_api_show_one_use_petr_t *mp;
15732 if (!vam->json_output)
15734 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15737 M (SHOW_ONE_USE_PETR, mp);
15741 /* Wait for a reply... */
15746 #define api_show_lisp_use_petr api_show_one_use_petr
15749 * Add/delete mapping between vni and vrf
15752 api_one_eid_table_add_del_map (vat_main_t * vam)
15754 unformat_input_t *input = vam->input;
15755 vl_api_one_eid_table_add_del_map_t *mp;
15756 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15757 u32 vni, vrf, bd_index;
15760 /* Parse args required to build the message */
15761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15763 if (unformat (input, "del"))
15765 else if (unformat (input, "vrf %d", &vrf))
15767 else if (unformat (input, "bd_index %d", &bd_index))
15769 else if (unformat (input, "vni %d", &vni))
15775 if (!vni_set || (!vrf_set && !bd_index_set))
15777 errmsg ("missing arguments!");
15781 if (vrf_set && bd_index_set)
15783 errmsg ("error: both vrf and bd entered!");
15787 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15789 mp->is_add = is_add;
15790 mp->vni = htonl (vni);
15791 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15792 mp->is_l2 = bd_index_set;
15797 /* wait for reply */
15802 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15805 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15807 u32 *action = va_arg (*args, u32 *);
15810 if (unformat (input, "%s", &s))
15812 if (!strcmp ((char *) s, "no-action"))
15814 else if (!strcmp ((char *) s, "natively-forward"))
15816 else if (!strcmp ((char *) s, "send-map-request"))
15818 else if (!strcmp ((char *) s, "drop"))
15822 clib_warning ("invalid action: '%s'", s);
15834 * Add/del remote mapping to/from ONE control plane
15836 * @param vam vpp API test context
15837 * @return return code
15840 api_one_add_del_remote_mapping (vat_main_t * vam)
15842 unformat_input_t *input = vam->input;
15843 vl_api_one_add_del_remote_mapping_t *mp;
15845 lisp_eid_vat_t _eid, *eid = &_eid;
15846 lisp_eid_vat_t _seid, *seid = &_seid;
15847 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15848 u32 action = ~0, p, w, data_len;
15849 ip4_address_t rloc4;
15850 ip6_address_t rloc6;
15851 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15854 clib_memset (&rloc, 0, sizeof (rloc));
15856 /* Parse args required to build the message */
15857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15859 if (unformat (input, "del-all"))
15863 else if (unformat (input, "del"))
15867 else if (unformat (input, "add"))
15871 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15875 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15879 else if (unformat (input, "vni %d", &vni))
15883 else if (unformat (input, "p %d w %d", &p, &w))
15887 errmsg ("No RLOC configured for setting priority/weight!");
15890 curr_rloc->priority = p;
15891 curr_rloc->weight = w;
15893 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15896 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15897 vec_add1 (rlocs, rloc);
15898 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15900 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15903 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15904 vec_add1 (rlocs, rloc);
15905 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15907 else if (unformat (input, "action %U",
15908 unformat_negative_mapping_action, &action))
15914 clib_warning ("parse error '%U'", format_unformat_error, input);
15921 errmsg ("missing params!");
15925 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15927 errmsg ("no action set for negative map-reply!");
15931 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15933 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15934 mp->is_add = is_add;
15935 mp->vni = htonl (vni);
15936 mp->action = (u8) action;
15937 mp->is_src_dst = seid_set;
15938 mp->eid_len = eid->len;
15939 mp->seid_len = seid->len;
15940 mp->del_all = del_all;
15941 mp->eid_type = eid->type;
15942 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15943 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15945 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15946 clib_memcpy (mp->rlocs, rlocs, data_len);
15952 /* Wait for a reply... */
15957 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15960 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15961 * forwarding entries in data-plane accordingly.
15963 * @param vam vpp API test context
15964 * @return return code
15967 api_one_add_del_adjacency (vat_main_t * vam)
15969 unformat_input_t *input = vam->input;
15970 vl_api_one_add_del_adjacency_t *mp;
15972 ip4_address_t leid4, reid4;
15973 ip6_address_t leid6, reid6;
15974 u8 reid_mac[6] = { 0 };
15975 u8 leid_mac[6] = { 0 };
15976 u8 reid_type, leid_type;
15977 u32 leid_len = 0, reid_len = 0, len;
15981 leid_type = reid_type = (u8) ~ 0;
15983 /* Parse args required to build the message */
15984 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15986 if (unformat (input, "del"))
15990 else if (unformat (input, "add"))
15994 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15997 reid_type = 0; /* ipv4 */
16000 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
16003 reid_type = 1; /* ipv6 */
16006 else if (unformat (input, "reid %U", unformat_ethernet_address,
16009 reid_type = 2; /* mac */
16011 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
16014 leid_type = 0; /* ipv4 */
16017 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
16020 leid_type = 1; /* ipv6 */
16023 else if (unformat (input, "leid %U", unformat_ethernet_address,
16026 leid_type = 2; /* mac */
16028 else if (unformat (input, "vni %d", &vni))
16034 errmsg ("parse error '%U'", format_unformat_error, input);
16039 if ((u8) ~ 0 == reid_type)
16041 errmsg ("missing params!");
16045 if (leid_type != reid_type)
16047 errmsg ("remote and local EIDs are of different types!");
16051 M (ONE_ADD_DEL_ADJACENCY, mp);
16052 mp->is_add = is_add;
16053 mp->vni = htonl (vni);
16054 mp->leid_len = leid_len;
16055 mp->reid_len = reid_len;
16056 mp->eid_type = reid_type;
16058 switch (mp->eid_type)
16061 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16062 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16065 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16066 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16069 clib_memcpy (mp->leid, leid_mac, 6);
16070 clib_memcpy (mp->reid, reid_mac, 6);
16073 errmsg ("unknown EID type %d!", mp->eid_type);
16080 /* Wait for a reply... */
16085 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16088 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16090 u32 *mode = va_arg (*args, u32 *);
16092 if (unformat (input, "lisp"))
16094 else if (unformat (input, "vxlan"))
16103 api_gpe_get_encap_mode (vat_main_t * vam)
16105 vl_api_gpe_get_encap_mode_t *mp;
16108 /* Construct the API message */
16109 M (GPE_GET_ENCAP_MODE, mp);
16114 /* Wait for a reply... */
16120 api_gpe_set_encap_mode (vat_main_t * vam)
16122 unformat_input_t *input = vam->input;
16123 vl_api_gpe_set_encap_mode_t *mp;
16127 /* Parse args required to build the message */
16128 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16130 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16136 /* Construct the API message */
16137 M (GPE_SET_ENCAP_MODE, mp);
16144 /* Wait for a reply... */
16150 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16152 unformat_input_t *input = vam->input;
16153 vl_api_gpe_add_del_iface_t *mp;
16154 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16155 u32 dp_table = 0, vni = 0;
16158 /* Parse args required to build the message */
16159 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16161 if (unformat (input, "up"))
16166 else if (unformat (input, "down"))
16171 else if (unformat (input, "table_id %d", &dp_table))
16175 else if (unformat (input, "bd_id %d", &dp_table))
16180 else if (unformat (input, "vni %d", &vni))
16188 if (action_set == 0)
16190 errmsg ("Action not set");
16193 if (dp_table_set == 0 || vni_set == 0)
16195 errmsg ("vni and dp_table must be set");
16199 /* Construct the API message */
16200 M (GPE_ADD_DEL_IFACE, mp);
16202 mp->is_add = is_add;
16203 mp->dp_table = clib_host_to_net_u32 (dp_table);
16205 mp->vni = clib_host_to_net_u32 (vni);
16210 /* Wait for a reply... */
16216 api_one_map_register_fallback_threshold (vat_main_t * vam)
16218 unformat_input_t *input = vam->input;
16219 vl_api_one_map_register_fallback_threshold_t *mp;
16224 /* Parse args required to build the message */
16225 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16227 if (unformat (input, "%u", &value))
16231 clib_warning ("parse error '%U'", format_unformat_error, input);
16238 errmsg ("fallback threshold value is missing!");
16242 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16243 mp->value = clib_host_to_net_u32 (value);
16248 /* Wait for a reply... */
16254 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16256 vl_api_show_one_map_register_fallback_threshold_t *mp;
16259 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16264 /* Wait for a reply... */
16270 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16272 u32 *proto = va_arg (*args, u32 *);
16274 if (unformat (input, "udp"))
16276 else if (unformat (input, "api"))
16285 api_one_set_transport_protocol (vat_main_t * vam)
16287 unformat_input_t *input = vam->input;
16288 vl_api_one_set_transport_protocol_t *mp;
16293 /* Parse args required to build the message */
16294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16296 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16300 clib_warning ("parse error '%U'", format_unformat_error, input);
16307 errmsg ("Transport protocol missing!");
16311 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16312 mp->protocol = (u8) protocol;
16317 /* Wait for a reply... */
16323 api_one_get_transport_protocol (vat_main_t * vam)
16325 vl_api_one_get_transport_protocol_t *mp;
16328 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16333 /* Wait for a reply... */
16339 api_one_map_register_set_ttl (vat_main_t * vam)
16341 unformat_input_t *input = vam->input;
16342 vl_api_one_map_register_set_ttl_t *mp;
16347 /* Parse args required to build the message */
16348 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16350 if (unformat (input, "%u", &ttl))
16354 clib_warning ("parse error '%U'", format_unformat_error, input);
16361 errmsg ("TTL value missing!");
16365 M (ONE_MAP_REGISTER_SET_TTL, mp);
16366 mp->ttl = clib_host_to_net_u32 (ttl);
16371 /* Wait for a reply... */
16377 api_show_one_map_register_ttl (vat_main_t * vam)
16379 vl_api_show_one_map_register_ttl_t *mp;
16382 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16387 /* Wait for a reply... */
16393 * Add/del map request itr rlocs from ONE control plane and updates
16395 * @param vam vpp API test context
16396 * @return return code
16399 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16401 unformat_input_t *input = vam->input;
16402 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16403 u8 *locator_set_name = 0;
16404 u8 locator_set_name_set = 0;
16408 /* Parse args required to build the message */
16409 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16411 if (unformat (input, "del"))
16415 else if (unformat (input, "%_%v%_", &locator_set_name))
16417 locator_set_name_set = 1;
16421 clib_warning ("parse error '%U'", format_unformat_error, input);
16426 if (is_add && !locator_set_name_set)
16428 errmsg ("itr-rloc is not set!");
16432 if (is_add && vec_len (locator_set_name) > 64)
16434 errmsg ("itr-rloc locator-set name too long");
16435 vec_free (locator_set_name);
16439 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16440 mp->is_add = is_add;
16443 clib_memcpy (mp->locator_set_name, locator_set_name,
16444 vec_len (locator_set_name));
16448 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16450 vec_free (locator_set_name);
16455 /* Wait for a reply... */
16460 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16463 api_one_locator_dump (vat_main_t * vam)
16465 unformat_input_t *input = vam->input;
16466 vl_api_one_locator_dump_t *mp;
16467 vl_api_control_ping_t *mp_ping;
16468 u8 is_index_set = 0, is_name_set = 0;
16473 /* Parse args required to build the message */
16474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16476 if (unformat (input, "ls_name %_%v%_", &ls_name))
16480 else if (unformat (input, "ls_index %d", &ls_index))
16486 errmsg ("parse error '%U'", format_unformat_error, input);
16491 if (!is_index_set && !is_name_set)
16493 errmsg ("error: expected one of index or name!");
16497 if (is_index_set && is_name_set)
16499 errmsg ("error: only one param expected!");
16503 if (vec_len (ls_name) > 62)
16505 errmsg ("error: locator set name too long!");
16509 if (!vam->json_output)
16511 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16514 M (ONE_LOCATOR_DUMP, mp);
16515 mp->is_index_set = is_index_set;
16518 mp->ls_index = clib_host_to_net_u32 (ls_index);
16521 vec_add1 (ls_name, 0);
16522 strncpy ((char *) mp->ls_name, (char *) ls_name,
16523 sizeof (mp->ls_name) - 1);
16529 /* Use a control ping for synchronization */
16530 MPING (CONTROL_PING, mp_ping);
16533 /* Wait for a reply... */
16538 #define api_lisp_locator_dump api_one_locator_dump
16541 api_one_locator_set_dump (vat_main_t * vam)
16543 vl_api_one_locator_set_dump_t *mp;
16544 vl_api_control_ping_t *mp_ping;
16545 unformat_input_t *input = vam->input;
16549 /* Parse args required to build the message */
16550 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16552 if (unformat (input, "local"))
16556 else if (unformat (input, "remote"))
16562 errmsg ("parse error '%U'", format_unformat_error, input);
16567 if (!vam->json_output)
16569 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16572 M (ONE_LOCATOR_SET_DUMP, mp);
16574 mp->filter = filter;
16579 /* Use a control ping for synchronization */
16580 MPING (CONTROL_PING, mp_ping);
16583 /* Wait for a reply... */
16588 #define api_lisp_locator_set_dump api_one_locator_set_dump
16591 api_one_eid_table_map_dump (vat_main_t * vam)
16595 unformat_input_t *input = vam->input;
16596 vl_api_one_eid_table_map_dump_t *mp;
16597 vl_api_control_ping_t *mp_ping;
16600 /* Parse args required to build the message */
16601 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16603 if (unformat (input, "l2"))
16608 else if (unformat (input, "l3"))
16615 errmsg ("parse error '%U'", format_unformat_error, input);
16622 errmsg ("expected one of 'l2' or 'l3' parameter!");
16626 if (!vam->json_output)
16628 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16631 M (ONE_EID_TABLE_MAP_DUMP, mp);
16637 /* Use a control ping for synchronization */
16638 MPING (CONTROL_PING, mp_ping);
16641 /* Wait for a reply... */
16646 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16649 api_one_eid_table_vni_dump (vat_main_t * vam)
16651 vl_api_one_eid_table_vni_dump_t *mp;
16652 vl_api_control_ping_t *mp_ping;
16655 if (!vam->json_output)
16657 print (vam->ofp, "VNI");
16660 M (ONE_EID_TABLE_VNI_DUMP, mp);
16665 /* Use a control ping for synchronization */
16666 MPING (CONTROL_PING, mp_ping);
16669 /* Wait for a reply... */
16674 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16677 api_one_eid_table_dump (vat_main_t * vam)
16679 unformat_input_t *i = vam->input;
16680 vl_api_one_eid_table_dump_t *mp;
16681 vl_api_control_ping_t *mp_ping;
16682 struct in_addr ip4;
16683 struct in6_addr ip6;
16685 u8 eid_type = ~0, eid_set = 0;
16686 u32 prefix_length = ~0, t, vni = 0;
16689 lisp_nsh_api_t nsh;
16691 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16693 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16699 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16705 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16710 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16715 else if (unformat (i, "vni %d", &t))
16719 else if (unformat (i, "local"))
16723 else if (unformat (i, "remote"))
16729 errmsg ("parse error '%U'", format_unformat_error, i);
16734 if (!vam->json_output)
16736 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16737 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16740 M (ONE_EID_TABLE_DUMP, mp);
16742 mp->filter = filter;
16746 mp->vni = htonl (vni);
16747 mp->eid_type = eid_type;
16751 mp->prefix_length = prefix_length;
16752 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16755 mp->prefix_length = prefix_length;
16756 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16759 clib_memcpy (mp->eid, mac, sizeof (mac));
16762 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16765 errmsg ("unknown EID type %d!", eid_type);
16773 /* Use a control ping for synchronization */
16774 MPING (CONTROL_PING, mp_ping);
16777 /* Wait for a reply... */
16782 #define api_lisp_eid_table_dump api_one_eid_table_dump
16785 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16787 unformat_input_t *i = vam->input;
16788 vl_api_gpe_fwd_entries_get_t *mp;
16793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16795 if (unformat (i, "vni %d", &vni))
16801 errmsg ("parse error '%U'", format_unformat_error, i);
16808 errmsg ("vni not set!");
16812 if (!vam->json_output)
16814 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16818 M (GPE_FWD_ENTRIES_GET, mp);
16819 mp->vni = clib_host_to_net_u32 (vni);
16824 /* Wait for a reply... */
16829 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16830 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16831 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16832 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16833 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16834 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16835 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16836 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16839 api_one_adjacencies_get (vat_main_t * vam)
16841 unformat_input_t *i = vam->input;
16842 vl_api_one_adjacencies_get_t *mp;
16847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16849 if (unformat (i, "vni %d", &vni))
16855 errmsg ("parse error '%U'", format_unformat_error, i);
16862 errmsg ("vni not set!");
16866 if (!vam->json_output)
16868 print (vam->ofp, "%s %40s", "leid", "reid");
16871 M (ONE_ADJACENCIES_GET, mp);
16872 mp->vni = clib_host_to_net_u32 (vni);
16877 /* Wait for a reply... */
16882 #define api_lisp_adjacencies_get api_one_adjacencies_get
16885 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16887 unformat_input_t *i = vam->input;
16888 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16890 u8 ip_family_set = 0, is_ip4 = 1;
16892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16894 if (unformat (i, "ip4"))
16899 else if (unformat (i, "ip6"))
16906 errmsg ("parse error '%U'", format_unformat_error, i);
16911 if (!ip_family_set)
16913 errmsg ("ip family not set!");
16917 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16918 mp->is_ip4 = is_ip4;
16923 /* Wait for a reply... */
16929 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16931 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16934 if (!vam->json_output)
16936 print (vam->ofp, "VNIs");
16939 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16944 /* Wait for a reply... */
16950 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16952 unformat_input_t *i = vam->input;
16953 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16955 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16956 struct in_addr ip4;
16957 struct in6_addr ip6;
16958 u32 table_id = 0, nh_sw_if_index = ~0;
16960 clib_memset (&ip4, 0, sizeof (ip4));
16961 clib_memset (&ip6, 0, sizeof (ip6));
16963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16965 if (unformat (i, "del"))
16967 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16968 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16973 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16974 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16979 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16983 nh_sw_if_index = ~0;
16985 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16989 nh_sw_if_index = ~0;
16991 else if (unformat (i, "table %d", &table_id))
16995 errmsg ("parse error '%U'", format_unformat_error, i);
17002 errmsg ("nh addr not set!");
17006 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
17007 mp->is_add = is_add;
17008 mp->table_id = clib_host_to_net_u32 (table_id);
17009 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
17010 mp->is_ip4 = is_ip4;
17012 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
17014 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
17019 /* Wait for a reply... */
17025 api_one_map_server_dump (vat_main_t * vam)
17027 vl_api_one_map_server_dump_t *mp;
17028 vl_api_control_ping_t *mp_ping;
17031 if (!vam->json_output)
17033 print (vam->ofp, "%=20s", "Map server");
17036 M (ONE_MAP_SERVER_DUMP, mp);
17040 /* Use a control ping for synchronization */
17041 MPING (CONTROL_PING, mp_ping);
17044 /* Wait for a reply... */
17049 #define api_lisp_map_server_dump api_one_map_server_dump
17052 api_one_map_resolver_dump (vat_main_t * vam)
17054 vl_api_one_map_resolver_dump_t *mp;
17055 vl_api_control_ping_t *mp_ping;
17058 if (!vam->json_output)
17060 print (vam->ofp, "%=20s", "Map resolver");
17063 M (ONE_MAP_RESOLVER_DUMP, mp);
17067 /* Use a control ping for synchronization */
17068 MPING (CONTROL_PING, mp_ping);
17071 /* Wait for a reply... */
17076 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17079 api_one_stats_flush (vat_main_t * vam)
17081 vl_api_one_stats_flush_t *mp;
17084 M (ONE_STATS_FLUSH, mp);
17091 api_one_stats_dump (vat_main_t * vam)
17093 vl_api_one_stats_dump_t *mp;
17094 vl_api_control_ping_t *mp_ping;
17097 M (ONE_STATS_DUMP, mp);
17101 /* Use a control ping for synchronization */
17102 MPING (CONTROL_PING, mp_ping);
17105 /* Wait for a reply... */
17111 api_show_one_status (vat_main_t * vam)
17113 vl_api_show_one_status_t *mp;
17116 if (!vam->json_output)
17118 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17121 M (SHOW_ONE_STATUS, mp);
17124 /* Wait for a reply... */
17129 #define api_show_lisp_status api_show_one_status
17132 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17134 vl_api_gpe_fwd_entry_path_dump_t *mp;
17135 vl_api_control_ping_t *mp_ping;
17136 unformat_input_t *i = vam->input;
17137 u32 fwd_entry_index = ~0;
17140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17142 if (unformat (i, "index %d", &fwd_entry_index))
17148 if (~0 == fwd_entry_index)
17150 errmsg ("no index specified!");
17154 if (!vam->json_output)
17156 print (vam->ofp, "first line");
17159 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17163 /* Use a control ping for synchronization */
17164 MPING (CONTROL_PING, mp_ping);
17167 /* Wait for a reply... */
17173 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17175 vl_api_one_get_map_request_itr_rlocs_t *mp;
17178 if (!vam->json_output)
17180 print (vam->ofp, "%=20s", "itr-rlocs:");
17183 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17186 /* Wait for a reply... */
17191 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17194 api_af_packet_create (vat_main_t * vam)
17196 unformat_input_t *i = vam->input;
17197 vl_api_af_packet_create_t *mp;
17198 u8 *host_if_name = 0;
17200 u8 random_hw_addr = 1;
17203 clib_memset (hw_addr, 0, sizeof (hw_addr));
17205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17207 if (unformat (i, "name %s", &host_if_name))
17208 vec_add1 (host_if_name, 0);
17209 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17210 random_hw_addr = 0;
17215 if (!vec_len (host_if_name))
17217 errmsg ("host-interface name must be specified");
17221 if (vec_len (host_if_name) > 64)
17223 errmsg ("host-interface name too long");
17227 M (AF_PACKET_CREATE, mp);
17229 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17230 clib_memcpy (mp->hw_addr, hw_addr, 6);
17231 mp->use_random_hw_addr = random_hw_addr;
17232 vec_free (host_if_name);
17240 fprintf (vam->ofp ? vam->ofp : stderr,
17241 " new sw_if_index = %d\n", vam->sw_if_index);
17248 api_af_packet_delete (vat_main_t * vam)
17250 unformat_input_t *i = vam->input;
17251 vl_api_af_packet_delete_t *mp;
17252 u8 *host_if_name = 0;
17255 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17257 if (unformat (i, "name %s", &host_if_name))
17258 vec_add1 (host_if_name, 0);
17263 if (!vec_len (host_if_name))
17265 errmsg ("host-interface name must be specified");
17269 if (vec_len (host_if_name) > 64)
17271 errmsg ("host-interface name too long");
17275 M (AF_PACKET_DELETE, mp);
17277 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17278 vec_free (host_if_name);
17285 static void vl_api_af_packet_details_t_handler
17286 (vl_api_af_packet_details_t * mp)
17288 vat_main_t *vam = &vat_main;
17290 print (vam->ofp, "%-16s %d",
17291 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17294 static void vl_api_af_packet_details_t_handler_json
17295 (vl_api_af_packet_details_t * mp)
17297 vat_main_t *vam = &vat_main;
17298 vat_json_node_t *node = NULL;
17300 if (VAT_JSON_ARRAY != vam->json_tree.type)
17302 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17303 vat_json_init_array (&vam->json_tree);
17305 node = vat_json_array_add (&vam->json_tree);
17307 vat_json_init_object (node);
17308 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17309 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17313 api_af_packet_dump (vat_main_t * vam)
17315 vl_api_af_packet_dump_t *mp;
17316 vl_api_control_ping_t *mp_ping;
17319 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17320 /* Get list of tap interfaces */
17321 M (AF_PACKET_DUMP, mp);
17324 /* Use a control ping for synchronization */
17325 MPING (CONTROL_PING, mp_ping);
17333 api_policer_add_del (vat_main_t * vam)
17335 unformat_input_t *i = vam->input;
17336 vl_api_policer_add_del_t *mp;
17346 u8 color_aware = 0;
17347 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17350 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17351 conform_action.dscp = 0;
17352 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17353 exceed_action.dscp = 0;
17354 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17355 violate_action.dscp = 0;
17357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17359 if (unformat (i, "del"))
17361 else if (unformat (i, "name %s", &name))
17362 vec_add1 (name, 0);
17363 else if (unformat (i, "cir %u", &cir))
17365 else if (unformat (i, "eir %u", &eir))
17367 else if (unformat (i, "cb %u", &cb))
17369 else if (unformat (i, "eb %u", &eb))
17371 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17374 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17377 else if (unformat (i, "type %U", unformat_policer_type, &type))
17379 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17382 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17385 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17388 else if (unformat (i, "color-aware"))
17394 if (!vec_len (name))
17396 errmsg ("policer name must be specified");
17400 if (vec_len (name) > 64)
17402 errmsg ("policer name too long");
17406 M (POLICER_ADD_DEL, mp);
17408 clib_memcpy (mp->name, name, vec_len (name));
17410 mp->is_add = is_add;
17411 mp->cir = ntohl (cir);
17412 mp->eir = ntohl (eir);
17413 mp->cb = clib_net_to_host_u64 (cb);
17414 mp->eb = clib_net_to_host_u64 (eb);
17415 mp->rate_type = rate_type;
17416 mp->round_type = round_type;
17418 mp->conform_action_type = conform_action.action_type;
17419 mp->conform_dscp = conform_action.dscp;
17420 mp->exceed_action_type = exceed_action.action_type;
17421 mp->exceed_dscp = exceed_action.dscp;
17422 mp->violate_action_type = violate_action.action_type;
17423 mp->violate_dscp = violate_action.dscp;
17424 mp->color_aware = color_aware;
17432 api_policer_dump (vat_main_t * vam)
17434 unformat_input_t *i = vam->input;
17435 vl_api_policer_dump_t *mp;
17436 vl_api_control_ping_t *mp_ping;
17437 u8 *match_name = 0;
17438 u8 match_name_valid = 0;
17441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17443 if (unformat (i, "name %s", &match_name))
17445 vec_add1 (match_name, 0);
17446 match_name_valid = 1;
17452 M (POLICER_DUMP, mp);
17453 mp->match_name_valid = match_name_valid;
17454 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17455 vec_free (match_name);
17459 /* Use a control ping for synchronization */
17460 MPING (CONTROL_PING, mp_ping);
17463 /* Wait for a reply... */
17469 api_policer_classify_set_interface (vat_main_t * vam)
17471 unformat_input_t *i = vam->input;
17472 vl_api_policer_classify_set_interface_t *mp;
17474 int sw_if_index_set;
17475 u32 ip4_table_index = ~0;
17476 u32 ip6_table_index = ~0;
17477 u32 l2_table_index = ~0;
17481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17483 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17484 sw_if_index_set = 1;
17485 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17486 sw_if_index_set = 1;
17487 else if (unformat (i, "del"))
17489 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17491 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17493 else if (unformat (i, "l2-table %d", &l2_table_index))
17497 clib_warning ("parse error '%U'", format_unformat_error, i);
17502 if (sw_if_index_set == 0)
17504 errmsg ("missing interface name or sw_if_index");
17508 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17510 mp->sw_if_index = ntohl (sw_if_index);
17511 mp->ip4_table_index = ntohl (ip4_table_index);
17512 mp->ip6_table_index = ntohl (ip6_table_index);
17513 mp->l2_table_index = ntohl (l2_table_index);
17514 mp->is_add = is_add;
17522 api_policer_classify_dump (vat_main_t * vam)
17524 unformat_input_t *i = vam->input;
17525 vl_api_policer_classify_dump_t *mp;
17526 vl_api_control_ping_t *mp_ping;
17527 u8 type = POLICER_CLASSIFY_N_TABLES;
17530 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17534 errmsg ("classify table type must be specified");
17538 if (!vam->json_output)
17540 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17543 M (POLICER_CLASSIFY_DUMP, mp);
17548 /* Use a control ping for synchronization */
17549 MPING (CONTROL_PING, mp_ping);
17552 /* Wait for a reply... */
17558 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17560 vl_api_fib_path_nh_proto_t proto =
17561 va_arg (*args, vl_api_fib_path_nh_proto_t);
17565 case FIB_API_PATH_NH_PROTO_IP4:
17566 s = format (s, "ip4");
17568 case FIB_API_PATH_NH_PROTO_IP6:
17569 s = format (s, "ip6");
17571 case FIB_API_PATH_NH_PROTO_MPLS:
17572 s = format (s, "mpls");
17574 case FIB_API_PATH_NH_PROTO_BIER:
17575 s = format (s, "bier");
17577 case FIB_API_PATH_NH_PROTO_ETHERNET:
17578 s = format (s, "ethernet");
17586 format_vl_api_ip_address_union (u8 * s, va_list * args)
17588 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
17589 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17594 s = format (s, "%U", format_ip4_address, u->ip4);
17597 s = format (s, "%U", format_ip6_address, u->ip6);
17604 format_vl_api_fib_path_type (u8 * s, va_list * args)
17606 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17610 case FIB_API_PATH_TYPE_NORMAL:
17611 s = format (s, "normal");
17613 case FIB_API_PATH_TYPE_LOCAL:
17614 s = format (s, "local");
17616 case FIB_API_PATH_TYPE_DROP:
17617 s = format (s, "drop");
17619 case FIB_API_PATH_TYPE_UDP_ENCAP:
17620 s = format (s, "udp-encap");
17622 case FIB_API_PATH_TYPE_BIER_IMP:
17623 s = format (s, "bier-imp");
17625 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17626 s = format (s, "unreach");
17628 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17629 s = format (s, "prohibit");
17631 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17632 s = format (s, "src-lookup");
17634 case FIB_API_PATH_TYPE_DVR:
17635 s = format (s, "dvr");
17637 case FIB_API_PATH_TYPE_INTERFACE_RX:
17638 s = format (s, "interface-rx");
17640 case FIB_API_PATH_TYPE_CLASSIFY:
17641 s = format (s, "classify");
17649 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17652 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17653 ntohl (fp->weight), ntohl (fp->sw_if_index),
17654 format_vl_api_fib_path_type, fp->type,
17655 format_fib_api_path_nh_proto, fp->proto,
17656 format_vl_api_ip_address_union, &fp->nh.address);
17660 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17661 vl_api_fib_path_t * fp)
17663 struct in_addr ip4;
17664 struct in6_addr ip6;
17666 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17667 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17668 vat_json_object_add_uint (node, "type", fp->type);
17669 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17670 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17672 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17673 vat_json_object_add_ip4 (node, "next_hop", ip4);
17675 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17677 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17678 vat_json_object_add_ip6 (node, "next_hop", ip6);
17683 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17685 vat_main_t *vam = &vat_main;
17686 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17687 vl_api_fib_path_t *fp;
17690 print (vam->ofp, "sw_if_index %d via:",
17691 ntohl (mp->mt_tunnel.mt_sw_if_index));
17692 fp = mp->mt_tunnel.mt_paths;
17693 for (i = 0; i < count; i++)
17695 vl_api_fib_path_print (vam, fp);
17699 print (vam->ofp, "");
17702 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17703 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17706 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17708 vat_main_t *vam = &vat_main;
17709 vat_json_node_t *node = NULL;
17710 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17711 vl_api_fib_path_t *fp;
17714 if (VAT_JSON_ARRAY != vam->json_tree.type)
17716 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17717 vat_json_init_array (&vam->json_tree);
17719 node = vat_json_array_add (&vam->json_tree);
17721 vat_json_init_object (node);
17722 vat_json_object_add_uint (node, "sw_if_index",
17723 ntohl (mp->mt_tunnel.mt_sw_if_index));
17725 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17727 fp = mp->mt_tunnel.mt_paths;
17728 for (i = 0; i < count; i++)
17730 vl_api_mpls_fib_path_json_print (node, fp);
17736 api_mpls_tunnel_dump (vat_main_t * vam)
17738 vl_api_mpls_tunnel_dump_t *mp;
17739 vl_api_control_ping_t *mp_ping;
17742 M (MPLS_TUNNEL_DUMP, mp);
17746 /* Use a control ping for synchronization */
17747 MPING (CONTROL_PING, mp_ping);
17754 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17755 #define vl_api_mpls_table_details_t_print vl_noop_handler
17759 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17761 vat_main_t *vam = &vat_main;
17763 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17766 static void vl_api_mpls_table_details_t_handler_json
17767 (vl_api_mpls_table_details_t * mp)
17769 vat_main_t *vam = &vat_main;
17770 vat_json_node_t *node = NULL;
17772 if (VAT_JSON_ARRAY != vam->json_tree.type)
17774 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17775 vat_json_init_array (&vam->json_tree);
17777 node = vat_json_array_add (&vam->json_tree);
17779 vat_json_init_object (node);
17780 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17784 api_mpls_table_dump (vat_main_t * vam)
17786 vl_api_mpls_table_dump_t *mp;
17787 vl_api_control_ping_t *mp_ping;
17790 M (MPLS_TABLE_DUMP, mp);
17793 /* Use a control ping for synchronization */
17794 MPING (CONTROL_PING, mp_ping);
17801 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17802 #define vl_api_mpls_route_details_t_print vl_noop_handler
17805 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17807 vat_main_t *vam = &vat_main;
17808 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17809 vl_api_fib_path_t *fp;
17813 "table-id %d, label %u, ess_bit %u",
17814 ntohl (mp->mr_route.mr_table_id),
17815 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17816 fp = mp->mr_route.mr_paths;
17817 for (i = 0; i < count; i++)
17819 vl_api_fib_path_print (vam, fp);
17824 static void vl_api_mpls_route_details_t_handler_json
17825 (vl_api_mpls_route_details_t * mp)
17827 vat_main_t *vam = &vat_main;
17828 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17829 vat_json_node_t *node = NULL;
17830 vl_api_fib_path_t *fp;
17833 if (VAT_JSON_ARRAY != vam->json_tree.type)
17835 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17836 vat_json_init_array (&vam->json_tree);
17838 node = vat_json_array_add (&vam->json_tree);
17840 vat_json_init_object (node);
17841 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17842 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17843 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17844 vat_json_object_add_uint (node, "path_count", count);
17845 fp = mp->mr_route.mr_paths;
17846 for (i = 0; i < count; i++)
17848 vl_api_mpls_fib_path_json_print (node, fp);
17854 api_mpls_route_dump (vat_main_t * vam)
17856 unformat_input_t *input = vam->input;
17857 vl_api_mpls_route_dump_t *mp;
17858 vl_api_control_ping_t *mp_ping;
17862 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17864 if (unformat (input, "table_id %d", &table_id))
17869 if (table_id == ~0)
17871 errmsg ("missing table id");
17875 M (MPLS_ROUTE_DUMP, mp);
17877 mp->table.mt_table_id = ntohl (table_id);
17880 /* Use a control ping for synchronization */
17881 MPING (CONTROL_PING, mp_ping);
17888 #define vl_api_ip_table_details_t_endian vl_noop_handler
17889 #define vl_api_ip_table_details_t_print vl_noop_handler
17892 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17894 vat_main_t *vam = &vat_main;
17897 "%s; table-id %d, prefix %U/%d",
17898 mp->table.name, ntohl (mp->table.table_id));
17902 static void vl_api_ip_table_details_t_handler_json
17903 (vl_api_ip_table_details_t * mp)
17905 vat_main_t *vam = &vat_main;
17906 vat_json_node_t *node = NULL;
17908 if (VAT_JSON_ARRAY != vam->json_tree.type)
17910 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17911 vat_json_init_array (&vam->json_tree);
17913 node = vat_json_array_add (&vam->json_tree);
17915 vat_json_init_object (node);
17916 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17920 api_ip_table_dump (vat_main_t * vam)
17922 vl_api_ip_table_dump_t *mp;
17923 vl_api_control_ping_t *mp_ping;
17926 M (IP_TABLE_DUMP, mp);
17929 /* Use a control ping for synchronization */
17930 MPING (CONTROL_PING, mp_ping);
17938 api_ip_mtable_dump (vat_main_t * vam)
17940 vl_api_ip_mtable_dump_t *mp;
17941 vl_api_control_ping_t *mp_ping;
17944 M (IP_MTABLE_DUMP, mp);
17947 /* Use a control ping for synchronization */
17948 MPING (CONTROL_PING, mp_ping);
17956 api_ip_mroute_dump (vat_main_t * vam)
17958 unformat_input_t *input = vam->input;
17959 vl_api_control_ping_t *mp_ping;
17960 vl_api_ip_mroute_dump_t *mp;
17965 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17967 if (unformat (input, "table_id %d", &table_id))
17969 else if (unformat (input, "ip6"))
17971 else if (unformat (input, "ip4"))
17976 if (table_id == ~0)
17978 errmsg ("missing table id");
17982 M (IP_MROUTE_DUMP, mp);
17983 mp->table.table_id = table_id;
17984 mp->table.is_ip6 = is_ip6;
17987 /* Use a control ping for synchronization */
17988 MPING (CONTROL_PING, mp_ping);
17995 #define vl_api_ip_route_details_t_endian vl_noop_handler
17996 #define vl_api_ip_route_details_t_print vl_noop_handler
17999 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
18001 vat_main_t *vam = &vat_main;
18002 u8 count = mp->route.n_paths;
18003 vl_api_fib_path_t *fp;
18007 "table-id %d, prefix %U/%d",
18008 ntohl (mp->route.table_id),
18009 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
18010 for (i = 0; i < count; i++)
18012 fp = &mp->route.paths[i];
18014 vl_api_fib_path_print (vam, fp);
18019 static void vl_api_ip_route_details_t_handler_json
18020 (vl_api_ip_route_details_t * mp)
18022 vat_main_t *vam = &vat_main;
18023 u8 count = mp->route.n_paths;
18024 vat_json_node_t *node = NULL;
18025 struct in_addr ip4;
18026 struct in6_addr ip6;
18027 vl_api_fib_path_t *fp;
18030 if (VAT_JSON_ARRAY != vam->json_tree.type)
18032 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18033 vat_json_init_array (&vam->json_tree);
18035 node = vat_json_array_add (&vam->json_tree);
18037 vat_json_init_object (node);
18038 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18039 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18041 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18042 vat_json_object_add_ip6 (node, "prefix", ip6);
18046 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18047 vat_json_object_add_ip4 (node, "prefix", ip4);
18049 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18050 vat_json_object_add_uint (node, "path_count", count);
18051 for (i = 0; i < count; i++)
18053 fp = &mp->route.paths[i];
18054 vl_api_mpls_fib_path_json_print (node, fp);
18059 api_ip_route_dump (vat_main_t * vam)
18061 unformat_input_t *input = vam->input;
18062 vl_api_ip_route_dump_t *mp;
18063 vl_api_control_ping_t *mp_ping;
18069 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18071 if (unformat (input, "table_id %d", &table_id))
18073 else if (unformat (input, "ip6"))
18075 else if (unformat (input, "ip4"))
18080 if (table_id == ~0)
18082 errmsg ("missing table id");
18086 M (IP_ROUTE_DUMP, mp);
18088 mp->table.table_id = table_id;
18089 mp->table.is_ip6 = is_ip6;
18093 /* Use a control ping for synchronization */
18094 MPING (CONTROL_PING, mp_ping);
18102 api_classify_table_ids (vat_main_t * vam)
18104 vl_api_classify_table_ids_t *mp;
18107 /* Construct the API message */
18108 M (CLASSIFY_TABLE_IDS, mp);
18117 api_classify_table_by_interface (vat_main_t * vam)
18119 unformat_input_t *input = vam->input;
18120 vl_api_classify_table_by_interface_t *mp;
18122 u32 sw_if_index = ~0;
18124 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18126 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18128 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18133 if (sw_if_index == ~0)
18135 errmsg ("missing interface name or sw_if_index");
18139 /* Construct the API message */
18140 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18142 mp->sw_if_index = ntohl (sw_if_index);
18150 api_classify_table_info (vat_main_t * vam)
18152 unformat_input_t *input = vam->input;
18153 vl_api_classify_table_info_t *mp;
18157 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18159 if (unformat (input, "table_id %d", &table_id))
18164 if (table_id == ~0)
18166 errmsg ("missing table id");
18170 /* Construct the API message */
18171 M (CLASSIFY_TABLE_INFO, mp);
18173 mp->table_id = ntohl (table_id);
18181 api_classify_session_dump (vat_main_t * vam)
18183 unformat_input_t *input = vam->input;
18184 vl_api_classify_session_dump_t *mp;
18185 vl_api_control_ping_t *mp_ping;
18189 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18191 if (unformat (input, "table_id %d", &table_id))
18196 if (table_id == ~0)
18198 errmsg ("missing table id");
18202 /* Construct the API message */
18203 M (CLASSIFY_SESSION_DUMP, mp);
18205 mp->table_id = ntohl (table_id);
18208 /* Use a control ping for synchronization */
18209 MPING (CONTROL_PING, mp_ping);
18217 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18219 vat_main_t *vam = &vat_main;
18221 print (vam->ofp, "collector_address %U, collector_port %d, "
18222 "src_address %U, vrf_id %d, path_mtu %u, "
18223 "template_interval %u, udp_checksum %d",
18224 format_ip4_address, mp->collector_address,
18225 ntohs (mp->collector_port),
18226 format_ip4_address, mp->src_address,
18227 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18228 ntohl (mp->template_interval), mp->udp_checksum);
18231 vam->result_ready = 1;
18235 vl_api_ipfix_exporter_details_t_handler_json
18236 (vl_api_ipfix_exporter_details_t * mp)
18238 vat_main_t *vam = &vat_main;
18239 vat_json_node_t node;
18240 struct in_addr collector_address;
18241 struct in_addr src_address;
18243 vat_json_init_object (&node);
18244 clib_memcpy (&collector_address, &mp->collector_address,
18245 sizeof (collector_address));
18246 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18247 vat_json_object_add_uint (&node, "collector_port",
18248 ntohs (mp->collector_port));
18249 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18250 vat_json_object_add_ip4 (&node, "src_address", src_address);
18251 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18252 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18253 vat_json_object_add_uint (&node, "template_interval",
18254 ntohl (mp->template_interval));
18255 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18257 vat_json_print (vam->ofp, &node);
18258 vat_json_free (&node);
18260 vam->result_ready = 1;
18264 api_ipfix_exporter_dump (vat_main_t * vam)
18266 vl_api_ipfix_exporter_dump_t *mp;
18269 /* Construct the API message */
18270 M (IPFIX_EXPORTER_DUMP, mp);
18279 api_ipfix_classify_stream_dump (vat_main_t * vam)
18281 vl_api_ipfix_classify_stream_dump_t *mp;
18284 /* Construct the API message */
18285 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18296 vl_api_ipfix_classify_stream_details_t_handler
18297 (vl_api_ipfix_classify_stream_details_t * mp)
18299 vat_main_t *vam = &vat_main;
18300 print (vam->ofp, "domain_id %d, src_port %d",
18301 ntohl (mp->domain_id), ntohs (mp->src_port));
18303 vam->result_ready = 1;
18307 vl_api_ipfix_classify_stream_details_t_handler_json
18308 (vl_api_ipfix_classify_stream_details_t * mp)
18310 vat_main_t *vam = &vat_main;
18311 vat_json_node_t node;
18313 vat_json_init_object (&node);
18314 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18315 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18317 vat_json_print (vam->ofp, &node);
18318 vat_json_free (&node);
18320 vam->result_ready = 1;
18324 api_ipfix_classify_table_dump (vat_main_t * vam)
18326 vl_api_ipfix_classify_table_dump_t *mp;
18327 vl_api_control_ping_t *mp_ping;
18330 if (!vam->json_output)
18332 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18333 "transport_protocol");
18336 /* Construct the API message */
18337 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18342 /* Use a control ping for synchronization */
18343 MPING (CONTROL_PING, mp_ping);
18351 vl_api_ipfix_classify_table_details_t_handler
18352 (vl_api_ipfix_classify_table_details_t * mp)
18354 vat_main_t *vam = &vat_main;
18355 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18356 mp->transport_protocol);
18360 vl_api_ipfix_classify_table_details_t_handler_json
18361 (vl_api_ipfix_classify_table_details_t * mp)
18363 vat_json_node_t *node = NULL;
18364 vat_main_t *vam = &vat_main;
18366 if (VAT_JSON_ARRAY != vam->json_tree.type)
18368 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18369 vat_json_init_array (&vam->json_tree);
18372 node = vat_json_array_add (&vam->json_tree);
18373 vat_json_init_object (node);
18375 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18376 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18377 vat_json_object_add_uint (node, "transport_protocol",
18378 mp->transport_protocol);
18382 api_sw_interface_span_enable_disable (vat_main_t * vam)
18384 unformat_input_t *i = vam->input;
18385 vl_api_sw_interface_span_enable_disable_t *mp;
18386 u32 src_sw_if_index = ~0;
18387 u32 dst_sw_if_index = ~0;
18392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18395 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18397 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18401 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18403 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18405 else if (unformat (i, "disable"))
18407 else if (unformat (i, "rx"))
18409 else if (unformat (i, "tx"))
18411 else if (unformat (i, "both"))
18413 else if (unformat (i, "l2"))
18419 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18421 mp->sw_if_index_from = htonl (src_sw_if_index);
18422 mp->sw_if_index_to = htonl (dst_sw_if_index);
18432 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18435 vat_main_t *vam = &vat_main;
18436 u8 *sw_if_from_name = 0;
18437 u8 *sw_if_to_name = 0;
18438 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18439 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18440 char *states[] = { "none", "rx", "tx", "both" };
18444 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18446 if ((u32) p->value[0] == sw_if_index_from)
18448 sw_if_from_name = (u8 *)(p->key);
18452 if ((u32) p->value[0] == sw_if_index_to)
18454 sw_if_to_name = (u8 *)(p->key);
18455 if (sw_if_from_name)
18460 print (vam->ofp, "%20s => %20s (%s) %s",
18461 sw_if_from_name, sw_if_to_name, states[mp->state],
18462 mp->is_l2 ? "l2" : "device");
18466 vl_api_sw_interface_span_details_t_handler_json
18467 (vl_api_sw_interface_span_details_t * mp)
18469 vat_main_t *vam = &vat_main;
18470 vat_json_node_t *node = NULL;
18471 u8 *sw_if_from_name = 0;
18472 u8 *sw_if_to_name = 0;
18473 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18474 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18478 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18480 if ((u32) p->value[0] == sw_if_index_from)
18482 sw_if_from_name = (u8 *)(p->key);
18486 if ((u32) p->value[0] == sw_if_index_to)
18488 sw_if_to_name = (u8 *)(p->key);
18489 if (sw_if_from_name)
18495 if (VAT_JSON_ARRAY != vam->json_tree.type)
18497 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18498 vat_json_init_array (&vam->json_tree);
18500 node = vat_json_array_add (&vam->json_tree);
18502 vat_json_init_object (node);
18503 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18504 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18505 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18506 if (0 != sw_if_to_name)
18508 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18510 vat_json_object_add_uint (node, "state", mp->state);
18511 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18515 api_sw_interface_span_dump (vat_main_t * vam)
18517 unformat_input_t *input = vam->input;
18518 vl_api_sw_interface_span_dump_t *mp;
18519 vl_api_control_ping_t *mp_ping;
18523 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18525 if (unformat (input, "l2"))
18531 M (SW_INTERFACE_SPAN_DUMP, mp);
18535 /* Use a control ping for synchronization */
18536 MPING (CONTROL_PING, mp_ping);
18544 api_pg_create_interface (vat_main_t * vam)
18546 unformat_input_t *input = vam->input;
18547 vl_api_pg_create_interface_t *mp;
18549 u32 if_id = ~0, gso_size = 0;
18550 u8 gso_enabled = 0;
18552 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18554 if (unformat (input, "if_id %d", &if_id))
18556 else if (unformat (input, "gso-enabled"))
18559 if (unformat (input, "gso-size %u", &gso_size))
18563 errmsg ("missing gso-size");
18572 errmsg ("missing pg interface index");
18576 /* Construct the API message */
18577 M (PG_CREATE_INTERFACE, mp);
18579 mp->interface_id = ntohl (if_id);
18580 mp->gso_enabled = gso_enabled;
18588 api_pg_capture (vat_main_t * vam)
18590 unformat_input_t *input = vam->input;
18591 vl_api_pg_capture_t *mp;
18596 u8 pcap_file_set = 0;
18599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18601 if (unformat (input, "if_id %d", &if_id))
18603 else if (unformat (input, "pcap %s", &pcap_file))
18605 else if (unformat (input, "count %d", &count))
18607 else if (unformat (input, "disable"))
18614 errmsg ("missing pg interface index");
18617 if (pcap_file_set > 0)
18619 if (vec_len (pcap_file) > 255)
18621 errmsg ("pcap file name is too long");
18626 /* Construct the API message */
18627 M (PG_CAPTURE, mp);
18629 mp->interface_id = ntohl (if_id);
18630 mp->is_enabled = enable;
18631 mp->count = ntohl (count);
18632 if (pcap_file_set != 0)
18634 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
18636 vec_free (pcap_file);
18644 api_pg_enable_disable (vat_main_t * vam)
18646 unformat_input_t *input = vam->input;
18647 vl_api_pg_enable_disable_t *mp;
18650 u8 stream_name_set = 0;
18651 u8 *stream_name = 0;
18653 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18655 if (unformat (input, "stream %s", &stream_name))
18656 stream_name_set = 1;
18657 else if (unformat (input, "disable"))
18663 if (stream_name_set > 0)
18665 if (vec_len (stream_name) > 255)
18667 errmsg ("stream name too long");
18672 /* Construct the API message */
18673 M (PG_ENABLE_DISABLE, mp);
18675 mp->is_enabled = enable;
18676 if (stream_name_set != 0)
18678 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
18680 vec_free (stream_name);
18688 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18690 unformat_input_t *input = vam->input;
18691 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18693 u16 *low_ports = 0;
18694 u16 *high_ports = 0;
18697 vl_api_prefix_t prefix;
18704 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18706 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18708 else if (unformat (input, "vrf %d", &vrf_id))
18710 else if (unformat (input, "del"))
18712 else if (unformat (input, "port %d", &tmp))
18714 if (tmp == 0 || tmp > 65535)
18716 errmsg ("port %d out of range", tmp);
18720 this_hi = this_low + 1;
18721 vec_add1 (low_ports, this_low);
18722 vec_add1 (high_ports, this_hi);
18724 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18726 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18728 errmsg ("incorrect range parameters");
18732 /* Note: in debug CLI +1 is added to high before
18733 passing to real fn that does "the work"
18734 (ip_source_and_port_range_check_add_del).
18735 This fn is a wrapper around the binary API fn a
18736 control plane will call, which expects this increment
18737 to have occurred. Hence letting the binary API control
18738 plane fn do the increment for consistency between VAT
18739 and other control planes.
18742 vec_add1 (low_ports, this_low);
18743 vec_add1 (high_ports, this_hi);
18749 if (prefix_set == 0)
18751 errmsg ("<address>/<mask> not specified");
18757 errmsg ("VRF ID required, not specified");
18764 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18768 if (vec_len (low_ports) == 0)
18770 errmsg ("At least one port or port range required");
18774 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18776 mp->is_add = is_add;
18778 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18780 mp->number_of_ranges = vec_len (low_ports);
18782 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18783 vec_free (low_ports);
18785 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18786 vec_free (high_ports);
18788 mp->vrf_id = ntohl (vrf_id);
18796 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18798 unformat_input_t *input = vam->input;
18799 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18800 u32 sw_if_index = ~0;
18802 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18803 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18807 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18809 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18811 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18813 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18815 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18817 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18819 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18821 else if (unformat (input, "del"))
18827 if (sw_if_index == ~0)
18829 errmsg ("Interface required but not specified");
18835 errmsg ("VRF ID required but not specified");
18839 if (tcp_out_vrf_id == 0
18840 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18843 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18847 /* Construct the API message */
18848 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18850 mp->sw_if_index = ntohl (sw_if_index);
18851 mp->is_add = is_add;
18852 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18853 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18854 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18855 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18860 /* Wait for a reply... */
18866 api_set_punt (vat_main_t * vam)
18868 unformat_input_t *i = vam->input;
18869 vl_api_address_family_t af;
18870 vl_api_set_punt_t *mp;
18876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18878 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18880 else if (unformat (i, "protocol %d", &protocol))
18882 else if (unformat (i, "port %d", &port))
18884 else if (unformat (i, "del"))
18888 clib_warning ("parse error '%U'", format_unformat_error, i);
18895 mp->is_add = (u8) is_add;
18896 mp->punt.type = PUNT_API_TYPE_L4;
18897 mp->punt.punt.l4.af = af;
18898 mp->punt.punt.l4.protocol = (u8) protocol;
18899 mp->punt.punt.l4.port = htons ((u16) port);
18907 api_delete_subif (vat_main_t * vam)
18909 unformat_input_t *i = vam->input;
18910 vl_api_delete_subif_t *mp;
18911 u32 sw_if_index = ~0;
18914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18916 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18918 if (unformat (i, "sw_if_index %d", &sw_if_index))
18924 if (sw_if_index == ~0)
18926 errmsg ("missing sw_if_index");
18930 /* Construct the API message */
18931 M (DELETE_SUBIF, mp);
18932 mp->sw_if_index = ntohl (sw_if_index);
18939 #define foreach_pbb_vtr_op \
18940 _("disable", L2_VTR_DISABLED) \
18941 _("pop", L2_VTR_POP_2) \
18942 _("push", L2_VTR_PUSH_2)
18945 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18947 unformat_input_t *i = vam->input;
18948 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18949 u32 sw_if_index = ~0, vtr_op = ~0;
18950 u16 outer_tag = ~0;
18951 u8 dmac[6], smac[6];
18952 u8 dmac_set = 0, smac_set = 0;
18958 /* Shut up coverity */
18959 clib_memset (dmac, 0, sizeof (dmac));
18960 clib_memset (smac, 0, sizeof (smac));
18962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18964 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18968 else if (unformat (i, "vtr_op %d", &vtr_op))
18970 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18973 else if (unformat (i, "translate_pbb_stag"))
18975 if (unformat (i, "%d", &tmp))
18977 vtr_op = L2_VTR_TRANSLATE_2_1;
18983 ("translate_pbb_stag operation requires outer tag definition");
18987 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18989 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18991 else if (unformat (i, "sid %d", &sid))
18993 else if (unformat (i, "vlanid %d", &tmp))
18997 clib_warning ("parse error '%U'", format_unformat_error, i);
19002 if ((sw_if_index == ~0) || (vtr_op == ~0))
19004 errmsg ("missing sw_if_index or vtr operation");
19007 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
19008 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
19011 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
19015 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
19016 mp->sw_if_index = ntohl (sw_if_index);
19017 mp->vtr_op = ntohl (vtr_op);
19018 mp->outer_tag = ntohs (outer_tag);
19019 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
19020 clib_memcpy (mp->b_smac, smac, sizeof (smac));
19021 mp->b_vlanid = ntohs (vlanid);
19022 mp->i_sid = ntohl (sid);
19030 api_flow_classify_set_interface (vat_main_t * vam)
19032 unformat_input_t *i = vam->input;
19033 vl_api_flow_classify_set_interface_t *mp;
19035 int sw_if_index_set;
19036 u32 ip4_table_index = ~0;
19037 u32 ip6_table_index = ~0;
19041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19043 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19044 sw_if_index_set = 1;
19045 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19046 sw_if_index_set = 1;
19047 else if (unformat (i, "del"))
19049 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19051 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19055 clib_warning ("parse error '%U'", format_unformat_error, i);
19060 if (sw_if_index_set == 0)
19062 errmsg ("missing interface name or sw_if_index");
19066 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19068 mp->sw_if_index = ntohl (sw_if_index);
19069 mp->ip4_table_index = ntohl (ip4_table_index);
19070 mp->ip6_table_index = ntohl (ip6_table_index);
19071 mp->is_add = is_add;
19079 api_flow_classify_dump (vat_main_t * vam)
19081 unformat_input_t *i = vam->input;
19082 vl_api_flow_classify_dump_t *mp;
19083 vl_api_control_ping_t *mp_ping;
19084 u8 type = FLOW_CLASSIFY_N_TABLES;
19087 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19091 errmsg ("classify table type must be specified");
19095 if (!vam->json_output)
19097 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19100 M (FLOW_CLASSIFY_DUMP, mp);
19105 /* Use a control ping for synchronization */
19106 MPING (CONTROL_PING, mp_ping);
19109 /* Wait for a reply... */
19115 api_feature_enable_disable (vat_main_t * vam)
19117 unformat_input_t *i = vam->input;
19118 vl_api_feature_enable_disable_t *mp;
19120 u8 *feature_name = 0;
19121 u32 sw_if_index = ~0;
19125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19127 if (unformat (i, "arc_name %s", &arc_name))
19129 else if (unformat (i, "feature_name %s", &feature_name))
19132 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19134 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19136 else if (unformat (i, "disable"))
19144 errmsg ("missing arc name");
19147 if (vec_len (arc_name) > 63)
19149 errmsg ("arc name too long");
19152 if (feature_name == 0)
19154 errmsg ("missing feature name");
19157 if (vec_len (feature_name) > 63)
19159 errmsg ("feature name too long");
19162 if (sw_if_index == ~0)
19164 errmsg ("missing interface name or sw_if_index");
19168 /* Construct the API message */
19169 M (FEATURE_ENABLE_DISABLE, mp);
19170 mp->sw_if_index = ntohl (sw_if_index);
19171 mp->enable = enable;
19172 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19173 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19174 vec_free (arc_name);
19175 vec_free (feature_name);
19183 api_feature_gso_enable_disable (vat_main_t * vam)
19185 unformat_input_t *i = vam->input;
19186 vl_api_feature_gso_enable_disable_t *mp;
19187 u32 sw_if_index = ~0;
19191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19193 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19195 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19197 else if (unformat (i, "enable"))
19199 else if (unformat (i, "disable"))
19205 if (sw_if_index == ~0)
19207 errmsg ("missing interface name or sw_if_index");
19211 /* Construct the API message */
19212 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19213 mp->sw_if_index = ntohl (sw_if_index);
19214 mp->enable_disable = enable;
19222 api_sw_interface_tag_add_del (vat_main_t * vam)
19224 unformat_input_t *i = vam->input;
19225 vl_api_sw_interface_tag_add_del_t *mp;
19226 u32 sw_if_index = ~0;
19231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19233 if (unformat (i, "tag %s", &tag))
19235 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19237 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19239 else if (unformat (i, "del"))
19245 if (sw_if_index == ~0)
19247 errmsg ("missing interface name or sw_if_index");
19251 if (enable && (tag == 0))
19253 errmsg ("no tag specified");
19257 /* Construct the API message */
19258 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19259 mp->sw_if_index = ntohl (sw_if_index);
19260 mp->is_add = enable;
19262 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19271 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19273 unformat_input_t *i = vam->input;
19274 vl_api_mac_address_t mac = { 0 };
19275 vl_api_sw_interface_add_del_mac_address_t *mp;
19276 u32 sw_if_index = ~0;
19281 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19283 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19285 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19287 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19289 else if (unformat (i, "del"))
19295 if (sw_if_index == ~0)
19297 errmsg ("missing interface name or sw_if_index");
19303 errmsg ("missing MAC address");
19307 /* Construct the API message */
19308 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19309 mp->sw_if_index = ntohl (sw_if_index);
19310 mp->is_add = is_add;
19311 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19318 static void vl_api_l2_xconnect_details_t_handler
19319 (vl_api_l2_xconnect_details_t * mp)
19321 vat_main_t *vam = &vat_main;
19323 print (vam->ofp, "%15d%15d",
19324 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19327 static void vl_api_l2_xconnect_details_t_handler_json
19328 (vl_api_l2_xconnect_details_t * mp)
19330 vat_main_t *vam = &vat_main;
19331 vat_json_node_t *node = NULL;
19333 if (VAT_JSON_ARRAY != vam->json_tree.type)
19335 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19336 vat_json_init_array (&vam->json_tree);
19338 node = vat_json_array_add (&vam->json_tree);
19340 vat_json_init_object (node);
19341 vat_json_object_add_uint (node, "rx_sw_if_index",
19342 ntohl (mp->rx_sw_if_index));
19343 vat_json_object_add_uint (node, "tx_sw_if_index",
19344 ntohl (mp->tx_sw_if_index));
19348 api_l2_xconnect_dump (vat_main_t * vam)
19350 vl_api_l2_xconnect_dump_t *mp;
19351 vl_api_control_ping_t *mp_ping;
19354 if (!vam->json_output)
19356 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19359 M (L2_XCONNECT_DUMP, mp);
19363 /* Use a control ping for synchronization */
19364 MPING (CONTROL_PING, mp_ping);
19372 api_hw_interface_set_mtu (vat_main_t * vam)
19374 unformat_input_t *i = vam->input;
19375 vl_api_hw_interface_set_mtu_t *mp;
19376 u32 sw_if_index = ~0;
19380 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19382 if (unformat (i, "mtu %d", &mtu))
19384 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19386 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19392 if (sw_if_index == ~0)
19394 errmsg ("missing interface name or sw_if_index");
19400 errmsg ("no mtu specified");
19404 /* Construct the API message */
19405 M (HW_INTERFACE_SET_MTU, mp);
19406 mp->sw_if_index = ntohl (sw_if_index);
19407 mp->mtu = ntohs ((u16) mtu);
19415 api_p2p_ethernet_add (vat_main_t * vam)
19417 unformat_input_t *i = vam->input;
19418 vl_api_p2p_ethernet_add_t *mp;
19419 u32 parent_if_index = ~0;
19425 clib_memset (remote_mac, 0, sizeof (remote_mac));
19426 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19428 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19430 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19434 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19436 else if (unformat (i, "sub_id %d", &sub_id))
19440 clib_warning ("parse error '%U'", format_unformat_error, i);
19445 if (parent_if_index == ~0)
19447 errmsg ("missing interface name or sw_if_index");
19452 errmsg ("missing remote mac address");
19457 errmsg ("missing sub-interface id");
19461 M (P2P_ETHERNET_ADD, mp);
19462 mp->parent_if_index = ntohl (parent_if_index);
19463 mp->subif_id = ntohl (sub_id);
19464 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19472 api_p2p_ethernet_del (vat_main_t * vam)
19474 unformat_input_t *i = vam->input;
19475 vl_api_p2p_ethernet_del_t *mp;
19476 u32 parent_if_index = ~0;
19481 clib_memset (remote_mac, 0, sizeof (remote_mac));
19482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19484 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19486 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19490 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19494 clib_warning ("parse error '%U'", format_unformat_error, i);
19499 if (parent_if_index == ~0)
19501 errmsg ("missing interface name or sw_if_index");
19506 errmsg ("missing remote mac address");
19510 M (P2P_ETHERNET_DEL, mp);
19511 mp->parent_if_index = ntohl (parent_if_index);
19512 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19520 api_lldp_config (vat_main_t * vam)
19522 unformat_input_t *i = vam->input;
19523 vl_api_lldp_config_t *mp;
19525 int tx_interval = 0;
19526 u8 *sys_name = NULL;
19529 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19531 if (unformat (i, "system-name %s", &sys_name))
19533 else if (unformat (i, "tx-hold %d", &tx_hold))
19535 else if (unformat (i, "tx-interval %d", &tx_interval))
19539 clib_warning ("parse error '%U'", format_unformat_error, i);
19544 vec_add1 (sys_name, 0);
19546 M (LLDP_CONFIG, mp);
19547 mp->tx_hold = htonl (tx_hold);
19548 mp->tx_interval = htonl (tx_interval);
19549 vl_api_vec_to_api_string (sys_name, &mp->system_name);
19550 vec_free (sys_name);
19558 api_sw_interface_set_lldp (vat_main_t * vam)
19560 unformat_input_t *i = vam->input;
19561 vl_api_sw_interface_set_lldp_t *mp;
19562 u32 sw_if_index = ~0;
19564 u8 *port_desc = NULL, *mgmt_oid = NULL;
19565 ip4_address_t ip4_addr;
19566 ip6_address_t ip6_addr;
19569 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19570 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19572 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19574 if (unformat (i, "disable"))
19577 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19579 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19581 else if (unformat (i, "port-desc %s", &port_desc))
19583 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19585 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19587 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19593 if (sw_if_index == ~0)
19595 errmsg ("missing interface name or sw_if_index");
19599 /* Construct the API message */
19600 vec_add1 (port_desc, 0);
19601 vec_add1 (mgmt_oid, 0);
19602 M (SW_INTERFACE_SET_LLDP, mp);
19603 mp->sw_if_index = ntohl (sw_if_index);
19604 mp->enable = enable;
19605 vl_api_vec_to_api_string (port_desc, &mp->port_desc);
19606 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19607 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19608 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19609 vec_free (port_desc);
19610 vec_free (mgmt_oid);
19618 api_tcp_configure_src_addresses (vat_main_t * vam)
19620 vl_api_tcp_configure_src_addresses_t *mp;
19621 unformat_input_t *i = vam->input;
19622 vl_api_address_t first, last;
19627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19629 if (unformat (i, "%U - %U",
19630 unformat_vl_api_address, &first,
19631 unformat_vl_api_address, &last))
19635 errmsg ("one range per message (range already set)");
19640 else if (unformat (i, "vrf %d", &vrf_id))
19646 if (range_set == 0)
19648 errmsg ("address range not set");
19652 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19654 mp->vrf_id = ntohl (vrf_id);
19655 clib_memcpy (&mp->first_address, &first, sizeof (first));
19656 clib_memcpy (&mp->last_address, &last, sizeof (last));
19663 static void vl_api_app_namespace_add_del_reply_t_handler
19664 (vl_api_app_namespace_add_del_reply_t * mp)
19666 vat_main_t *vam = &vat_main;
19667 i32 retval = ntohl (mp->retval);
19668 if (vam->async_mode)
19670 vam->async_errors += (retval < 0);
19674 vam->retval = retval;
19676 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19677 vam->result_ready = 1;
19681 static void vl_api_app_namespace_add_del_reply_t_handler_json
19682 (vl_api_app_namespace_add_del_reply_t * mp)
19684 vat_main_t *vam = &vat_main;
19685 vat_json_node_t node;
19687 vat_json_init_object (&node);
19688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19689 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19691 vat_json_print (vam->ofp, &node);
19692 vat_json_free (&node);
19694 vam->retval = ntohl (mp->retval);
19695 vam->result_ready = 1;
19699 api_app_namespace_add_del (vat_main_t * vam)
19701 vl_api_app_namespace_add_del_t *mp;
19702 unformat_input_t *i = vam->input;
19703 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19704 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19710 if (unformat (i, "id %_%v%_", &ns_id))
19712 else if (unformat (i, "secret %lu", &secret))
19714 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19715 sw_if_index_set = 1;
19716 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19718 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19723 if (!ns_id || !secret_set || !sw_if_index_set)
19725 errmsg ("namespace id, secret and sw_if_index must be set");
19728 if (vec_len (ns_id) > 64)
19730 errmsg ("namespace id too long");
19733 M (APP_NAMESPACE_ADD_DEL, mp);
19735 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
19736 mp->namespace_id_len = vec_len (ns_id);
19737 mp->secret = clib_host_to_net_u64 (secret);
19738 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19739 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19740 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19748 api_sock_init_shm (vat_main_t * vam)
19750 #if VPP_API_TEST_BUILTIN == 0
19751 unformat_input_t *i = vam->input;
19752 vl_api_shm_elem_config_t *config = 0;
19753 u64 size = 64 << 20;
19756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19758 if (unformat (i, "size %U", unformat_memory_size, &size))
19765 * Canned custom ring allocator config.
19766 * Should probably parse all of this
19768 vec_validate (config, 6);
19769 config[0].type = VL_API_VLIB_RING;
19770 config[0].size = 256;
19771 config[0].count = 32;
19773 config[1].type = VL_API_VLIB_RING;
19774 config[1].size = 1024;
19775 config[1].count = 16;
19777 config[2].type = VL_API_VLIB_RING;
19778 config[2].size = 4096;
19779 config[2].count = 2;
19781 config[3].type = VL_API_CLIENT_RING;
19782 config[3].size = 256;
19783 config[3].count = 32;
19785 config[4].type = VL_API_CLIENT_RING;
19786 config[4].size = 1024;
19787 config[4].count = 16;
19789 config[5].type = VL_API_CLIENT_RING;
19790 config[5].size = 4096;
19791 config[5].count = 2;
19793 config[6].type = VL_API_QUEUE;
19794 config[6].count = 128;
19795 config[6].size = sizeof (uword);
19797 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19799 vam->client_index_invalid = 1;
19807 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19809 vat_main_t *vam = &vat_main;
19814 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19815 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19816 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
19817 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19818 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19819 clib_net_to_host_u32 (mp->action_index), mp->tag);
19824 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19825 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19826 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
19827 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19828 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
19829 clib_net_to_host_u32 (mp->action_index), mp->tag);
19834 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19837 vat_main_t *vam = &vat_main;
19838 vat_json_node_t *node = NULL;
19839 struct in6_addr ip6;
19840 struct in_addr ip4;
19842 if (VAT_JSON_ARRAY != vam->json_tree.type)
19844 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19845 vat_json_init_array (&vam->json_tree);
19847 node = vat_json_array_add (&vam->json_tree);
19848 vat_json_init_object (node);
19850 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
19851 vat_json_object_add_uint (node, "appns_index",
19852 clib_net_to_host_u32 (mp->appns_index));
19853 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19854 vat_json_object_add_uint (node, "scope", mp->scope);
19855 vat_json_object_add_uint (node, "action_index",
19856 clib_net_to_host_u32 (mp->action_index));
19857 vat_json_object_add_uint (node, "lcl_port",
19858 clib_net_to_host_u16 (mp->lcl_port));
19859 vat_json_object_add_uint (node, "rmt_port",
19860 clib_net_to_host_u16 (mp->rmt_port));
19861 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
19862 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
19863 vat_json_object_add_string_copy (node, "tag", mp->tag);
19866 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
19867 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19868 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
19869 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19873 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
19874 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19875 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
19876 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19881 api_session_rule_add_del (vat_main_t * vam)
19883 vl_api_session_rule_add_del_t *mp;
19884 unformat_input_t *i = vam->input;
19885 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19886 u32 appns_index = 0, scope = 0;
19887 ip4_address_t lcl_ip4, rmt_ip4;
19888 ip6_address_t lcl_ip6, rmt_ip6;
19889 u8 is_ip4 = 1, conn_set = 0;
19890 u8 is_add = 1, *tag = 0;
19893 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19895 if (unformat (i, "del"))
19897 else if (unformat (i, "add"))
19899 else if (unformat (i, "proto tcp"))
19901 else if (unformat (i, "proto udp"))
19903 else if (unformat (i, "appns %d", &appns_index))
19905 else if (unformat (i, "scope %d", &scope))
19907 else if (unformat (i, "tag %_%v%_", &tag))
19911 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19912 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19920 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19921 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19927 else if (unformat (i, "action %d", &action))
19932 if (proto == ~0 || !conn_set || action == ~0)
19934 errmsg ("transport proto, connection and action must be set");
19940 errmsg ("scope should be 0-3");
19944 M (SESSION_RULE_ADD_DEL, mp);
19946 mp->is_ip4 = is_ip4;
19947 mp->transport_proto = proto;
19948 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19949 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19950 mp->lcl_plen = lcl_plen;
19951 mp->rmt_plen = rmt_plen;
19952 mp->action_index = clib_host_to_net_u32 (action);
19953 mp->appns_index = clib_host_to_net_u32 (appns_index);
19955 mp->is_add = is_add;
19958 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
19959 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
19963 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
19964 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
19968 clib_memcpy (mp->tag, tag, vec_len (tag));
19978 api_session_rules_dump (vat_main_t * vam)
19980 vl_api_session_rules_dump_t *mp;
19981 vl_api_control_ping_t *mp_ping;
19984 if (!vam->json_output)
19986 print (vam->ofp, "%=20s", "Session Rules");
19989 M (SESSION_RULES_DUMP, mp);
19993 /* Use a control ping for synchronization */
19994 MPING (CONTROL_PING, mp_ping);
19997 /* Wait for a reply... */
20003 api_ip_container_proxy_add_del (vat_main_t * vam)
20005 vl_api_ip_container_proxy_add_del_t *mp;
20006 unformat_input_t *i = vam->input;
20007 u32 sw_if_index = ~0;
20008 vl_api_prefix_t pfx = { };
20012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20014 if (unformat (i, "del"))
20016 else if (unformat (i, "add"))
20018 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20020 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20025 if (sw_if_index == ~0 || pfx.len == 0)
20027 errmsg ("address and sw_if_index must be set");
20031 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20033 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20034 mp->is_add = is_add;
20035 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20043 api_qos_record_enable_disable (vat_main_t * vam)
20045 unformat_input_t *i = vam->input;
20046 vl_api_qos_record_enable_disable_t *mp;
20047 u32 sw_if_index, qs = 0xff;
20048 u8 sw_if_index_set = 0;
20052 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20054 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20055 sw_if_index_set = 1;
20056 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20057 sw_if_index_set = 1;
20058 else if (unformat (i, "%U", unformat_qos_source, &qs))
20060 else if (unformat (i, "disable"))
20064 clib_warning ("parse error '%U'", format_unformat_error, i);
20069 if (sw_if_index_set == 0)
20071 errmsg ("missing interface name or sw_if_index");
20076 errmsg ("input location must be specified");
20080 M (QOS_RECORD_ENABLE_DISABLE, mp);
20082 mp->record.sw_if_index = ntohl (sw_if_index);
20083 mp->record.input_source = qs;
20084 mp->enable = enable;
20093 q_or_quit (vat_main_t * vam)
20095 #if VPP_API_TEST_BUILTIN == 0
20096 longjmp (vam->jump_buf, 1);
20098 return 0; /* not so much */
20102 q (vat_main_t * vam)
20104 return q_or_quit (vam);
20108 quit (vat_main_t * vam)
20110 return q_or_quit (vam);
20114 comment (vat_main_t * vam)
20120 elog_save (vat_main_t * vam)
20122 #if VPP_API_TEST_BUILTIN == 0
20123 elog_main_t *em = &vam->elog_main;
20124 unformat_input_t *i = vam->input;
20125 char *file, *chroot_file;
20126 clib_error_t *error;
20128 if (!unformat (i, "%s", &file))
20130 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20134 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20135 if (strstr (file, "..") || index (file, '/'))
20137 errmsg ("illegal characters in filename '%s'", file);
20141 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20145 errmsg ("Saving %wd of %wd events to %s",
20146 elog_n_events_in_buffer (em),
20147 elog_buffer_capacity (em), chroot_file);
20149 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20150 vec_free (chroot_file);
20153 clib_error_report (error);
20155 errmsg ("Use the vpp event loger...");
20162 elog_setup (vat_main_t * vam)
20164 #if VPP_API_TEST_BUILTIN == 0
20165 elog_main_t *em = &vam->elog_main;
20166 unformat_input_t *i = vam->input;
20167 u32 nevents = 128 << 10;
20169 (void) unformat (i, "nevents %d", &nevents);
20171 elog_init (em, nevents);
20172 vl_api_set_elog_main (em);
20173 vl_api_set_elog_trace_api_messages (1);
20174 errmsg ("Event logger initialized with %u events", nevents);
20176 errmsg ("Use the vpp event loger...");
20182 elog_enable (vat_main_t * vam)
20184 #if VPP_API_TEST_BUILTIN == 0
20185 elog_main_t *em = &vam->elog_main;
20187 elog_enable_disable (em, 1 /* enable */ );
20188 vl_api_set_elog_trace_api_messages (1);
20189 errmsg ("Event logger enabled...");
20191 errmsg ("Use the vpp event loger...");
20197 elog_disable (vat_main_t * vam)
20199 #if VPP_API_TEST_BUILTIN == 0
20200 elog_main_t *em = &vam->elog_main;
20202 elog_enable_disable (em, 0 /* enable */ );
20203 vl_api_set_elog_trace_api_messages (1);
20204 errmsg ("Event logger disabled...");
20206 errmsg ("Use the vpp event loger...");
20212 statseg (vat_main_t * vam)
20214 ssvm_private_t *ssvmp = &vam->stat_segment;
20215 ssvm_shared_header_t *shared_header = ssvmp->sh;
20216 vlib_counter_t **counters;
20217 u64 thread0_index1_packets;
20218 u64 thread0_index1_bytes;
20219 f64 vector_rate, input_rate;
20222 uword *counter_vector_by_name;
20223 if (vam->stat_segment_lockp == 0)
20225 errmsg ("Stat segment not mapped...");
20229 /* look up "/if/rx for sw_if_index 1 as a test */
20231 clib_spinlock_lock (vam->stat_segment_lockp);
20233 counter_vector_by_name = (uword *) shared_header->opaque[1];
20235 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20238 clib_spinlock_unlock (vam->stat_segment_lockp);
20239 errmsg ("/if/tx not found?");
20243 /* Fish per-thread vector of combined counters from shared memory */
20244 counters = (vlib_counter_t **) p[0];
20246 if (vec_len (counters[0]) < 2)
20248 clib_spinlock_unlock (vam->stat_segment_lockp);
20249 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20253 /* Read thread 0 sw_if_index 1 counter */
20254 thread0_index1_packets = counters[0][1].packets;
20255 thread0_index1_bytes = counters[0][1].bytes;
20257 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20260 clib_spinlock_unlock (vam->stat_segment_lockp);
20261 errmsg ("vector_rate not found?");
20265 vector_rate = *(f64 *) (p[0]);
20266 p = hash_get_mem (counter_vector_by_name, "input_rate");
20269 clib_spinlock_unlock (vam->stat_segment_lockp);
20270 errmsg ("input_rate not found?");
20273 input_rate = *(f64 *) (p[0]);
20275 clib_spinlock_unlock (vam->stat_segment_lockp);
20277 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20278 vector_rate, input_rate);
20279 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20280 thread0_index1_packets, thread0_index1_bytes);
20286 cmd_cmp (void *a1, void *a2)
20291 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20295 help (vat_main_t * vam)
20300 unformat_input_t *i = vam->input;
20303 if (unformat (i, "%s", &name))
20307 vec_add1 (name, 0);
20309 hs = hash_get_mem (vam->help_by_name, name);
20311 print (vam->ofp, "usage: %s %s", name, hs[0]);
20313 print (vam->ofp, "No such msg / command '%s'", name);
20318 print (vam->ofp, "Help is available for the following:");
20321 hash_foreach_pair (p, vam->function_by_name,
20323 vec_add1 (cmds, (u8 *)(p->key));
20327 vec_sort_with_function (cmds, cmd_cmp);
20329 for (j = 0; j < vec_len (cmds); j++)
20330 print (vam->ofp, "%s", cmds[j]);
20337 set (vat_main_t * vam)
20339 u8 *name = 0, *value = 0;
20340 unformat_input_t *i = vam->input;
20342 if (unformat (i, "%s", &name))
20344 /* The input buffer is a vector, not a string. */
20345 value = vec_dup (i->buffer);
20346 vec_delete (value, i->index, 0);
20347 /* Almost certainly has a trailing newline */
20348 if (value[vec_len (value) - 1] == '\n')
20349 value[vec_len (value) - 1] = 0;
20350 /* Make sure it's a proper string, one way or the other */
20351 vec_add1 (value, 0);
20352 (void) clib_macro_set_value (&vam->macro_main,
20353 (char *) name, (char *) value);
20356 errmsg ("usage: set <name> <value>");
20364 unset (vat_main_t * vam)
20368 if (unformat (vam->input, "%s", &name))
20369 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20370 errmsg ("unset: %s wasn't set", name);
20383 macro_sort_cmp (void *a1, void *a2)
20385 macro_sort_t *s1 = a1;
20386 macro_sort_t *s2 = a2;
20388 return strcmp ((char *) (s1->name), (char *) (s2->name));
20392 dump_macro_table (vat_main_t * vam)
20394 macro_sort_t *sort_me = 0, *sm;
20399 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20401 vec_add2 (sort_me, sm, 1);
20402 sm->name = (u8 *)(p->key);
20403 sm->value = (u8 *) (p->value[0]);
20407 vec_sort_with_function (sort_me, macro_sort_cmp);
20409 if (vec_len (sort_me))
20410 print (vam->ofp, "%-15s%s", "Name", "Value");
20412 print (vam->ofp, "The macro table is empty...");
20414 for (i = 0; i < vec_len (sort_me); i++)
20415 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20420 dump_node_table (vat_main_t * vam)
20423 vlib_node_t *node, *next_node;
20425 if (vec_len (vam->graph_nodes) == 0)
20427 print (vam->ofp, "Node table empty, issue get_node_graph...");
20431 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20433 node = vam->graph_nodes[0][i];
20434 print (vam->ofp, "[%d] %s", i, node->name);
20435 for (j = 0; j < vec_len (node->next_nodes); j++)
20437 if (node->next_nodes[j] != ~0)
20439 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20440 print (vam->ofp, " [%d] %s", j, next_node->name);
20448 value_sort_cmp (void *a1, void *a2)
20450 name_sort_t *n1 = a1;
20451 name_sort_t *n2 = a2;
20453 if (n1->value < n2->value)
20455 if (n1->value > n2->value)
20462 dump_msg_api_table (vat_main_t * vam)
20464 api_main_t *am = vlibapi_get_main ();
20465 name_sort_t *nses = 0, *ns;
20470 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20472 vec_add2 (nses, ns, 1);
20473 ns->name = (u8 *)(hp->key);
20474 ns->value = (u32) hp->value[0];
20478 vec_sort_with_function (nses, value_sort_cmp);
20480 for (i = 0; i < vec_len (nses); i++)
20481 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20487 get_msg_id (vat_main_t * vam)
20492 if (unformat (vam->input, "%s", &name_and_crc))
20494 message_index = vl_msg_api_get_msg_index (name_and_crc);
20495 if (message_index == ~0)
20497 print (vam->ofp, " '%s' not found", name_and_crc);
20500 print (vam->ofp, " '%s' has message index %d",
20501 name_and_crc, message_index);
20504 errmsg ("name_and_crc required...");
20509 search_node_table (vat_main_t * vam)
20511 unformat_input_t *line_input = vam->input;
20514 vlib_node_t *node, *next_node;
20517 if (vam->graph_node_index_by_name == 0)
20519 print (vam->ofp, "Node table empty, issue get_node_graph...");
20523 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20525 if (unformat (line_input, "%s", &node_to_find))
20527 vec_add1 (node_to_find, 0);
20528 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20531 print (vam->ofp, "%s not found...", node_to_find);
20534 node = vam->graph_nodes[0][p[0]];
20535 print (vam->ofp, "[%d] %s", p[0], node->name);
20536 for (j = 0; j < vec_len (node->next_nodes); j++)
20538 if (node->next_nodes[j] != ~0)
20540 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20541 print (vam->ofp, " [%d] %s", j, next_node->name);
20548 clib_warning ("parse error '%U'", format_unformat_error,
20554 vec_free (node_to_find);
20563 script (vat_main_t * vam)
20565 #if (VPP_API_TEST_BUILTIN==0)
20567 char *save_current_file;
20568 unformat_input_t save_input;
20569 jmp_buf save_jump_buf;
20570 u32 save_line_number;
20572 FILE *new_fp, *save_ifp;
20574 if (unformat (vam->input, "%s", &s))
20576 new_fp = fopen ((char *) s, "r");
20579 errmsg ("Couldn't open script file %s", s);
20586 errmsg ("Missing script name");
20590 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20591 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20592 save_ifp = vam->ifp;
20593 save_line_number = vam->input_line_number;
20594 save_current_file = (char *) vam->current_file;
20596 vam->input_line_number = 0;
20598 vam->current_file = s;
20601 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20602 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20603 vam->ifp = save_ifp;
20604 vam->input_line_number = save_line_number;
20605 vam->current_file = (u8 *) save_current_file;
20610 clib_warning ("use the exec command...");
20616 echo (vat_main_t * vam)
20618 print (vam->ofp, "%v", vam->input->buffer);
20622 /* List of API message constructors, CLI names map to api_xxx */
20623 #define foreach_vpe_api_msg \
20624 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20625 _(sw_interface_dump,"") \
20626 _(sw_interface_set_flags, \
20627 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20628 _(sw_interface_add_del_address, \
20629 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20630 _(sw_interface_set_rx_mode, \
20631 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20632 _(sw_interface_set_rx_placement, \
20633 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20634 _(sw_interface_rx_placement_dump, \
20635 "[<intfc> | sw_if_index <id>]") \
20636 _(sw_interface_set_table, \
20637 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20638 _(sw_interface_set_mpls_enable, \
20639 "<intfc> | sw_if_index [disable | dis]") \
20640 _(sw_interface_set_vpath, \
20641 "<intfc> | sw_if_index <id> enable | disable") \
20642 _(sw_interface_set_vxlan_bypass, \
20643 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20644 _(sw_interface_set_geneve_bypass, \
20645 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20646 _(sw_interface_set_l2_xconnect, \
20647 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20648 "enable | disable") \
20649 _(sw_interface_set_l2_bridge, \
20650 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20651 "[shg <split-horizon-group>] [bvi]\n" \
20652 "enable | disable") \
20653 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20654 _(bridge_domain_add_del, \
20655 "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") \
20656 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20658 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20659 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20660 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20662 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20664 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20666 "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload]") \
20668 "<vpp-if-name> | sw_if_index <id>") \
20669 _(sw_interface_tap_v2_dump, "") \
20670 _(virtio_pci_create, \
20671 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20672 _(virtio_pci_delete, \
20673 "<vpp-if-name> | sw_if_index <id>") \
20674 _(sw_interface_virtio_pci_dump, "") \
20676 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20677 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20680 "<vpp-if-name> | sw_if_index <id>") \
20682 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20683 _(bond_detach_slave, \
20684 "sw_if_index <n>") \
20685 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20686 _(sw_interface_bond_dump, "") \
20687 _(sw_interface_slave_dump, \
20688 "<vpp-if-name> | sw_if_index <id>") \
20689 _(ip_table_add_del, \
20690 "table <n> [ipv6] [add | del]\n") \
20691 _(ip_route_add_del, \
20692 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20693 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20694 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20695 "[multipath] [count <n>] [del]") \
20696 _(ip_mroute_add_del, \
20697 "<src> <grp>/<mask> [table-id <n>]\n" \
20698 "[<intfc> | sw_if_index <id>] [local] [del]") \
20699 _(mpls_table_add_del, \
20700 "table <n> [add | del]\n") \
20701 _(mpls_route_add_del, \
20702 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20703 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20704 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20705 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20706 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20707 "[count <n>] [del]") \
20708 _(mpls_ip_bind_unbind, \
20709 "<label> <addr/len>") \
20710 _(mpls_tunnel_add_del, \
20711 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20712 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20713 "[l2-only] [out-label <n>]") \
20714 _(sr_mpls_policy_add, \
20715 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20716 _(sr_mpls_policy_del, \
20718 _(bier_table_add_del, \
20719 "<label> <sub-domain> <set> <bsl> [del]") \
20720 _(bier_route_add_del, \
20721 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20722 "[<intfc> | sw_if_index <id>]" \
20723 "[weight <n>] [del] [multipath]") \
20724 _(sw_interface_set_unnumbered, \
20725 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20726 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20727 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20728 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20729 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20730 "[outer_vlan_id_any][inner_vlan_id_any]") \
20731 _(ip_table_replace_begin, "table <n> [ipv6]") \
20732 _(ip_table_flush, "table <n> [ipv6]") \
20733 _(ip_table_replace_end, "table <n> [ipv6]") \
20734 _(set_ip_flow_hash, \
20735 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20736 _(sw_interface_ip6_enable_disable, \
20737 "<intfc> | sw_if_index <id> enable | disable") \
20738 _(l2_patch_add_del, \
20739 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20740 "enable | disable") \
20741 _(sr_localsid_add_del, \
20742 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20743 "fib-table <num> (end.psp) sw_if_index <num>") \
20744 _(classify_add_del_table, \
20745 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20746 " [del] [del-chain] mask <mask-value>\n" \
20747 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20748 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20749 _(classify_add_del_session, \
20750 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20751 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20752 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20753 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20754 _(classify_set_interface_ip_table, \
20755 "<intfc> | sw_if_index <nn> table <nn>") \
20756 _(classify_set_interface_l2_tables, \
20757 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20758 " [other-table <nn>]") \
20759 _(get_node_index, "node <node-name") \
20760 _(add_node_next, "node <node-name> next <next-node-name>") \
20761 _(l2tpv3_create_tunnel, \
20762 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20763 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20764 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20765 _(l2tpv3_set_tunnel_cookies, \
20766 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20767 "[new_remote_cookie <nn>]\n") \
20768 _(l2tpv3_interface_enable_disable, \
20769 "<intfc> | sw_if_index <nn> enable | disable") \
20770 _(l2tpv3_set_lookup_key, \
20771 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20772 _(sw_if_l2tpv3_tunnel_dump, "") \
20773 _(vxlan_offload_rx, \
20774 "hw { <interface name> | hw_if_index <nn>} " \
20775 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20776 _(vxlan_add_del_tunnel, \
20777 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20778 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20779 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20780 _(geneve_add_del_tunnel, \
20781 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20782 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20783 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20784 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20785 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20786 _(gre_tunnel_add_del, \
20787 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20788 "[teb | erspan <session-id>] [del]") \
20789 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20790 _(l2_fib_clear_table, "") \
20791 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20792 _(l2_interface_vlan_tag_rewrite, \
20793 "<intfc> | sw_if_index <nn> \n" \
20794 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20795 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20796 _(create_vhost_user_if, \
20797 "socket <filename> [server] [renumber <dev_instance>] " \
20798 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20799 "[mac <mac_address>]") \
20800 _(modify_vhost_user_if, \
20801 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20802 "[server] [renumber <dev_instance>] [gso]") \
20803 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20804 _(sw_interface_vhost_user_dump, "") \
20805 _(show_version, "") \
20806 _(show_threads, "") \
20807 _(vxlan_gpe_add_del_tunnel, \
20808 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20809 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20810 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20811 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20812 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20813 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20814 _(interface_name_renumber, \
20815 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20816 _(input_acl_set_interface, \
20817 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20818 " [l2-table <nn>] [del]") \
20819 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20820 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20821 _(ip_dump, "ipv4 | ipv6") \
20822 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20823 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20825 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20826 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20827 " integ_alg <alg> integ_key <hex>") \
20828 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20829 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20830 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20831 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20832 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20833 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20834 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20835 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20836 " [instance <n>]") \
20837 _(ipsec_sa_dump, "[sa_id <n>]") \
20838 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20839 _(delete_loopback,"sw_if_index <nn>") \
20840 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20841 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20842 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20843 _(want_interface_events, "enable|disable") \
20844 _(get_first_msg_id, "client <name>") \
20845 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20846 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20847 "fib-id <nn> [ip4][ip6][default]") \
20848 _(get_node_graph, " ") \
20849 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20850 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20851 _(ioam_disable, "") \
20852 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20853 " sw_if_index <sw_if_index> p <priority> " \
20854 "w <weight>] [del]") \
20855 _(one_add_del_locator, "locator-set <locator_name> " \
20856 "iface <intf> | sw_if_index <sw_if_index> " \
20857 "p <priority> w <weight> [del]") \
20858 _(one_add_del_local_eid,"vni <vni> eid " \
20859 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20860 "locator-set <locator_name> [del]" \
20861 "[key-id sha1|sha256 secret-key <secret-key>]")\
20862 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20863 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20864 _(one_enable_disable, "enable|disable") \
20865 _(one_map_register_enable_disable, "enable|disable") \
20866 _(one_map_register_fallback_threshold, "<value>") \
20867 _(one_rloc_probe_enable_disable, "enable|disable") \
20868 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20870 "rloc <locator> p <prio> " \
20871 "w <weight> [rloc <loc> ... ] " \
20872 "action <action> [del-all]") \
20873 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20875 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20876 _(one_use_petr, "ip-address> | disable") \
20877 _(one_map_request_mode, "src-dst|dst-only") \
20878 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20879 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20880 _(one_locator_set_dump, "[local | remote]") \
20881 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20882 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20883 "[local] | [remote]") \
20884 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20885 _(one_ndp_bd_get, "") \
20886 _(one_ndp_entries_get, "bd <bridge-domain>") \
20887 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20888 _(one_l2_arp_bd_get, "") \
20889 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20890 _(one_stats_enable_disable, "enable|disable") \
20891 _(show_one_stats_enable_disable, "") \
20892 _(one_eid_table_vni_dump, "") \
20893 _(one_eid_table_map_dump, "l2|l3") \
20894 _(one_map_resolver_dump, "") \
20895 _(one_map_server_dump, "") \
20896 _(one_adjacencies_get, "vni <vni>") \
20897 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20898 _(show_one_rloc_probe_state, "") \
20899 _(show_one_map_register_state, "") \
20900 _(show_one_status, "") \
20901 _(one_stats_dump, "") \
20902 _(one_stats_flush, "") \
20903 _(one_get_map_request_itr_rlocs, "") \
20904 _(one_map_register_set_ttl, "<ttl>") \
20905 _(one_set_transport_protocol, "udp|api") \
20906 _(one_get_transport_protocol, "") \
20907 _(one_enable_disable_xtr_mode, "enable|disable") \
20908 _(one_show_xtr_mode, "") \
20909 _(one_enable_disable_pitr_mode, "enable|disable") \
20910 _(one_show_pitr_mode, "") \
20911 _(one_enable_disable_petr_mode, "enable|disable") \
20912 _(one_show_petr_mode, "") \
20913 _(show_one_nsh_mapping, "") \
20914 _(show_one_pitr, "") \
20915 _(show_one_use_petr, "") \
20916 _(show_one_map_request_mode, "") \
20917 _(show_one_map_register_ttl, "") \
20918 _(show_one_map_register_fallback_threshold, "") \
20919 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20920 " sw_if_index <sw_if_index> p <priority> " \
20921 "w <weight>] [del]") \
20922 _(lisp_add_del_locator, "locator-set <locator_name> " \
20923 "iface <intf> | sw_if_index <sw_if_index> " \
20924 "p <priority> w <weight> [del]") \
20925 _(lisp_add_del_local_eid,"vni <vni> eid " \
20926 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20927 "locator-set <locator_name> [del]" \
20928 "[key-id sha1|sha256 secret-key <secret-key>]") \
20929 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20930 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20931 _(lisp_enable_disable, "enable|disable") \
20932 _(lisp_map_register_enable_disable, "enable|disable") \
20933 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20934 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20936 "rloc <locator> p <prio> " \
20937 "w <weight> [rloc <loc> ... ] " \
20938 "action <action> [del-all]") \
20939 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20941 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20942 _(lisp_use_petr, "<ip-address> | disable") \
20943 _(lisp_map_request_mode, "src-dst|dst-only") \
20944 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20945 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20946 _(lisp_locator_set_dump, "[local | remote]") \
20947 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20948 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20949 "[local] | [remote]") \
20950 _(lisp_eid_table_vni_dump, "") \
20951 _(lisp_eid_table_map_dump, "l2|l3") \
20952 _(lisp_map_resolver_dump, "") \
20953 _(lisp_map_server_dump, "") \
20954 _(lisp_adjacencies_get, "vni <vni>") \
20955 _(gpe_fwd_entry_vnis_get, "") \
20956 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20957 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20958 "[table <table-id>]") \
20959 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20960 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20961 _(gpe_set_encap_mode, "lisp|vxlan") \
20962 _(gpe_get_encap_mode, "") \
20963 _(lisp_gpe_add_del_iface, "up|down") \
20964 _(lisp_gpe_enable_disable, "enable|disable") \
20965 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20966 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20967 _(show_lisp_rloc_probe_state, "") \
20968 _(show_lisp_map_register_state, "") \
20969 _(show_lisp_status, "") \
20970 _(lisp_get_map_request_itr_rlocs, "") \
20971 _(show_lisp_pitr, "") \
20972 _(show_lisp_use_petr, "") \
20973 _(show_lisp_map_request_mode, "") \
20974 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20975 _(af_packet_delete, "name <host interface name>") \
20976 _(af_packet_dump, "") \
20977 _(policer_add_del, "name <policer name> <params> [del]") \
20978 _(policer_dump, "[name <policer name>]") \
20979 _(policer_classify_set_interface, \
20980 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20981 " [l2-table <nn>] [del]") \
20982 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20983 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20984 _(mpls_table_dump, "") \
20985 _(mpls_route_dump, "table-id <ID>") \
20986 _(classify_table_ids, "") \
20987 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20988 _(classify_table_info, "table_id <nn>") \
20989 _(classify_session_dump, "table_id <nn>") \
20990 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20991 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20992 "[template_interval <nn>] [udp_checksum]") \
20993 _(ipfix_exporter_dump, "") \
20994 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20995 _(ipfix_classify_stream_dump, "") \
20996 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20997 _(ipfix_classify_table_dump, "") \
20998 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20999 _(sw_interface_span_dump, "[l2]") \
21000 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
21001 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
21002 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
21003 _(pg_enable_disable, "[stream <id>] disable") \
21004 _(ip_source_and_port_range_check_add_del, \
21005 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
21006 _(ip_source_and_port_range_check_interface_add_del, \
21007 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
21008 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
21009 _(delete_subif,"<intfc> | sw_if_index <nn>") \
21010 _(l2_interface_pbb_tag_rewrite, \
21011 "<intfc> | sw_if_index <nn> \n" \
21012 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21013 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21014 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21015 _(flow_classify_set_interface, \
21016 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21017 _(flow_classify_dump, "type [ip4|ip6]") \
21018 _(ip_table_dump, "") \
21019 _(ip_route_dump, "table-id [ip4|ip6]") \
21020 _(ip_mtable_dump, "") \
21021 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21022 _(feature_enable_disable, "arc_name <arc_name> " \
21023 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21024 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21025 "[enable | disable] ") \
21026 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21028 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21029 "mac <mac-address> [del]") \
21030 _(l2_xconnect_dump, "") \
21031 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21032 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21033 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21034 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21035 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21036 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21037 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21038 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21039 _(sock_init_shm, "size <nnn>") \
21040 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21041 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21042 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21043 _(session_rules_dump, "") \
21044 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21045 _(output_acl_set_interface, \
21046 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21047 " [l2-table <nn>] [del]") \
21048 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21050 /* List of command functions, CLI names map directly to functions */
21051 #define foreach_cli_function \
21052 _(comment, "usage: comment <ignore-rest-of-line>") \
21053 _(dump_interface_table, "usage: dump_interface_table") \
21054 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21055 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21056 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21057 _(dump_macro_table, "usage: dump_macro_table ") \
21058 _(dump_node_table, "usage: dump_node_table") \
21059 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21060 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21061 _(elog_disable, "usage: elog_disable") \
21062 _(elog_enable, "usage: elog_enable") \
21063 _(elog_save, "usage: elog_save <filename>") \
21064 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21065 _(echo, "usage: echo <message>") \
21066 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21067 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21068 _(help, "usage: help") \
21069 _(q, "usage: quit") \
21070 _(quit, "usage: quit") \
21071 _(search_node_table, "usage: search_node_table <name>...") \
21072 _(set, "usage: set <variable-name> <value>") \
21073 _(script, "usage: script <file-name>") \
21074 _(statseg, "usage: statseg") \
21075 _(unset, "usage: unset <variable-name>")
21078 static void vl_api_##n##_t_handler_uni \
21079 (vl_api_##n##_t * mp) \
21081 vat_main_t * vam = &vat_main; \
21082 if (vam->json_output) { \
21083 vl_api_##n##_t_handler_json(mp); \
21085 vl_api_##n##_t_handler(mp); \
21088 foreach_vpe_api_reply_msg;
21089 #if VPP_API_TEST_BUILTIN == 0
21090 foreach_standalone_reply_msg;
21095 vat_api_hookup (vat_main_t * vam)
21098 vl_msg_api_set_handlers(VL_API_##N, #n, \
21099 vl_api_##n##_t_handler_uni, \
21101 vl_api_##n##_t_endian, \
21102 vl_api_##n##_t_print, \
21103 sizeof(vl_api_##n##_t), 1);
21104 foreach_vpe_api_reply_msg;
21105 #if VPP_API_TEST_BUILTIN == 0
21106 foreach_standalone_reply_msg;
21110 #if (VPP_API_TEST_BUILTIN==0)
21111 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21113 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21115 vam->function_by_name = hash_create_string (0, sizeof (uword));
21117 vam->help_by_name = hash_create_string (0, sizeof (uword));
21120 /* API messages we can send */
21121 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21122 foreach_vpe_api_msg;
21126 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21127 foreach_vpe_api_msg;
21130 /* CLI functions */
21131 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21132 foreach_cli_function;
21136 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21137 foreach_cli_function;
21141 #if VPP_API_TEST_BUILTIN
21142 static clib_error_t *
21143 vat_api_hookup_shim (vlib_main_t * vm)
21145 vat_api_hookup (&vat_main);
21149 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21153 * fd.io coding-style-patch-verification: ON
21156 * eval: (c-set-style "gnu")