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_API_MARK_AND_TRANSMIT)
4559 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
4561 conform_dscp_str = format (0, "");
4563 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4564 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
4566 exceed_dscp_str = format (0, "");
4568 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4569 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.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_API_MARK_AND_TRANSMIT)
4663 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.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_API_MARK_AND_TRANSMIT)
4670 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.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_API_MARK_AND_TRANSMIT)
4678 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.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;
7374 else if (unformat (i, "persist"))
7375 tap_flags |= TAP_FLAG_PERSIST;
7376 else if (unformat (i, "attach"))
7377 tap_flags |= TAP_FLAG_ATTACH;
7382 if (vec_len (host_if_name) > 63)
7384 errmsg ("tap name too long. ");
7387 if (vec_len (host_ns) > 63)
7389 errmsg ("host name space too long. ");
7392 if (vec_len (host_bridge) > 63)
7394 errmsg ("host bridge name too long. ");
7397 if (host_ip4_prefix_len > 32)
7399 errmsg ("host ip4 prefix length not valid. ");
7402 if (host_ip6_prefix_len > 128)
7404 errmsg ("host ip6 prefix length not valid. ");
7407 if (!is_pow2 (rx_ring_sz))
7409 errmsg ("rx ring size must be power of 2. ");
7412 if (rx_ring_sz > 32768)
7414 errmsg ("rx ring size must be 32768 or lower. ");
7417 if (!is_pow2 (tx_ring_sz))
7419 errmsg ("tx ring size must be power of 2. ");
7422 if (tx_ring_sz > 32768)
7424 errmsg ("tx ring size must be 32768 or lower. ");
7427 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7429 errmsg ("host MTU size must be in between 64 and 65355. ");
7433 /* Construct the API message */
7434 M (TAP_CREATE_V2, mp);
7436 mp->id = ntohl (id);
7437 mp->use_random_mac = random_mac;
7438 mp->num_rx_queues = (u8) num_rx_queues;
7439 mp->tx_ring_sz = ntohs (tx_ring_sz);
7440 mp->rx_ring_sz = ntohs (rx_ring_sz);
7441 mp->host_mtu_set = host_mtu_set;
7442 mp->host_mtu_size = ntohl (host_mtu_size);
7443 mp->host_mac_addr_set = host_mac_addr_set;
7444 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7445 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7446 mp->host_ip4_gw_set = host_ip4_gw_set;
7447 mp->host_ip6_gw_set = host_ip6_gw_set;
7448 mp->tap_flags = ntohl (tap_flags);
7449 mp->host_namespace_set = host_ns_set;
7450 mp->host_if_name_set = host_if_name_set;
7451 mp->host_bridge_set = host_bridge_set;
7453 if (random_mac == 0)
7454 clib_memcpy (mp->mac_address, mac_address, 6);
7455 if (host_mac_addr_set)
7456 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7457 if (host_if_name_set)
7458 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7460 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7461 if (host_bridge_set)
7462 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7463 if (host_ip4_prefix_set)
7465 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7466 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7468 if (host_ip6_prefix_set)
7470 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7471 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7473 if (host_ip4_gw_set)
7474 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7475 if (host_ip6_gw_set)
7476 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7479 vec_free (host_if_name);
7480 vec_free (host_bridge);
7485 /* Wait for a reply... */
7491 api_tap_delete_v2 (vat_main_t * vam)
7493 unformat_input_t *i = vam->input;
7494 vl_api_tap_delete_v2_t *mp;
7495 u32 sw_if_index = ~0;
7496 u8 sw_if_index_set = 0;
7499 /* Parse args required to build the message */
7500 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7502 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7503 sw_if_index_set = 1;
7504 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7505 sw_if_index_set = 1;
7510 if (sw_if_index_set == 0)
7512 errmsg ("missing vpp interface name. ");
7516 /* Construct the API message */
7517 M (TAP_DELETE_V2, mp);
7519 mp->sw_if_index = ntohl (sw_if_index);
7524 /* Wait for a reply... */
7530 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7532 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7535 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7538 addr->domain = x[0];
7541 addr->function = x[3];
7547 api_virtio_pci_create (vat_main_t * vam)
7549 unformat_input_t *i = vam->input;
7550 vl_api_virtio_pci_create_t *mp;
7554 u8 checksum_offload_enabled = 0;
7556 u64 features = (u64) ~ (0ULL);
7559 clib_memset (mac_address, 0, sizeof (mac_address));
7561 /* Parse args required to build the message */
7562 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7564 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7568 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7570 else if (unformat (i, "features 0x%llx", &features))
7572 else if (unformat (i, "gso-enabled"))
7574 else if (unformat (i, "csum-offload-enabled"))
7575 checksum_offload_enabled = 1;
7582 errmsg ("pci address must be non zero. ");
7586 /* Construct the API message */
7587 M (VIRTIO_PCI_CREATE, mp);
7589 mp->use_random_mac = random_mac;
7591 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7592 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7593 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7594 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7596 mp->features = clib_host_to_net_u64 (features);
7597 mp->gso_enabled = gso_enabled;
7598 mp->checksum_offload_enabled = checksum_offload_enabled;
7600 if (random_mac == 0)
7601 clib_memcpy (mp->mac_address, mac_address, 6);
7606 /* Wait for a reply... */
7612 api_virtio_pci_delete (vat_main_t * vam)
7614 unformat_input_t *i = vam->input;
7615 vl_api_virtio_pci_delete_t *mp;
7616 u32 sw_if_index = ~0;
7617 u8 sw_if_index_set = 0;
7620 /* Parse args required to build the message */
7621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7623 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7624 sw_if_index_set = 1;
7625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7626 sw_if_index_set = 1;
7631 if (sw_if_index_set == 0)
7633 errmsg ("missing vpp interface name. ");
7637 /* Construct the API message */
7638 M (VIRTIO_PCI_DELETE, mp);
7640 mp->sw_if_index = htonl (sw_if_index);
7645 /* Wait for a reply... */
7651 api_bond_create (vat_main_t * vam)
7653 unformat_input_t *i = vam->input;
7654 vl_api_bond_create_t *mp;
7664 clib_memset (mac_address, 0, sizeof (mac_address));
7667 /* Parse args required to build the message */
7668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7670 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7672 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7673 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7675 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7678 else if (unformat (i, "numa-only"))
7680 else if (unformat (i, "id %u", &id))
7686 if (mode_is_set == 0)
7688 errmsg ("Missing bond mode. ");
7692 /* Construct the API message */
7693 M (BOND_CREATE, mp);
7695 mp->use_custom_mac = custom_mac;
7697 mp->mode = htonl (mode);
7698 mp->lb = htonl (lb);
7699 mp->id = htonl (id);
7700 mp->numa_only = numa_only;
7703 clib_memcpy (mp->mac_address, mac_address, 6);
7708 /* Wait for a reply... */
7714 api_bond_delete (vat_main_t * vam)
7716 unformat_input_t *i = vam->input;
7717 vl_api_bond_delete_t *mp;
7718 u32 sw_if_index = ~0;
7719 u8 sw_if_index_set = 0;
7722 /* Parse args required to build the message */
7723 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7725 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7726 sw_if_index_set = 1;
7727 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7728 sw_if_index_set = 1;
7733 if (sw_if_index_set == 0)
7735 errmsg ("missing vpp interface name. ");
7739 /* Construct the API message */
7740 M (BOND_DELETE, mp);
7742 mp->sw_if_index = ntohl (sw_if_index);
7747 /* Wait for a reply... */
7753 api_bond_enslave (vat_main_t * vam)
7755 unformat_input_t *i = vam->input;
7756 vl_api_bond_enslave_t *mp;
7757 u32 bond_sw_if_index;
7761 u32 bond_sw_if_index_is_set = 0;
7763 u8 sw_if_index_is_set = 0;
7765 /* Parse args required to build the message */
7766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7768 if (unformat (i, "sw_if_index %d", &sw_if_index))
7769 sw_if_index_is_set = 1;
7770 else if (unformat (i, "bond %u", &bond_sw_if_index))
7771 bond_sw_if_index_is_set = 1;
7772 else if (unformat (i, "passive %d", &is_passive))
7774 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7780 if (bond_sw_if_index_is_set == 0)
7782 errmsg ("Missing bond sw_if_index. ");
7785 if (sw_if_index_is_set == 0)
7787 errmsg ("Missing slave sw_if_index. ");
7791 /* Construct the API message */
7792 M (BOND_ENSLAVE, mp);
7794 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7795 mp->sw_if_index = ntohl (sw_if_index);
7796 mp->is_long_timeout = is_long_timeout;
7797 mp->is_passive = is_passive;
7802 /* Wait for a reply... */
7808 api_bond_detach_slave (vat_main_t * vam)
7810 unformat_input_t *i = vam->input;
7811 vl_api_bond_detach_slave_t *mp;
7812 u32 sw_if_index = ~0;
7813 u8 sw_if_index_set = 0;
7816 /* Parse args required to build the message */
7817 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7819 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7820 sw_if_index_set = 1;
7821 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7822 sw_if_index_set = 1;
7827 if (sw_if_index_set == 0)
7829 errmsg ("missing vpp interface name. ");
7833 /* Construct the API message */
7834 M (BOND_DETACH_SLAVE, mp);
7836 mp->sw_if_index = ntohl (sw_if_index);
7841 /* Wait for a reply... */
7847 api_ip_table_add_del (vat_main_t * vam)
7849 unformat_input_t *i = vam->input;
7850 vl_api_ip_table_add_del_t *mp;
7856 /* Parse args required to build the message */
7857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7859 if (unformat (i, "ipv6"))
7861 else if (unformat (i, "del"))
7863 else if (unformat (i, "add"))
7865 else if (unformat (i, "table %d", &table_id))
7869 clib_warning ("parse error '%U'", format_unformat_error, i);
7876 errmsg ("missing table-ID");
7880 /* Construct the API message */
7881 M (IP_TABLE_ADD_DEL, mp);
7883 mp->table.table_id = ntohl (table_id);
7884 mp->table.is_ip6 = is_ipv6;
7885 mp->is_add = is_add;
7890 /* Wait for a reply... */
7897 unformat_fib_path (unformat_input_t * input, va_list * args)
7899 vat_main_t *vam = va_arg (*args, vat_main_t *);
7900 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7901 u32 weight, preference;
7902 mpls_label_t out_label;
7904 clib_memset (path, 0, sizeof (*path));
7906 path->sw_if_index = ~0;
7910 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7912 if (unformat (input, "%U %U",
7913 unformat_vl_api_ip4_address,
7914 &path->nh.address.ip4,
7915 api_unformat_sw_if_index, vam, &path->sw_if_index))
7917 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7919 else if (unformat (input, "%U %U",
7920 unformat_vl_api_ip6_address,
7921 &path->nh.address.ip6,
7922 api_unformat_sw_if_index, vam, &path->sw_if_index))
7924 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7926 else if (unformat (input, "weight %u", &weight))
7928 path->weight = weight;
7930 else if (unformat (input, "preference %u", &preference))
7932 path->preference = preference;
7934 else if (unformat (input, "%U next-hop-table %d",
7935 unformat_vl_api_ip4_address,
7936 &path->nh.address.ip4, &path->table_id))
7938 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7940 else if (unformat (input, "%U next-hop-table %d",
7941 unformat_vl_api_ip6_address,
7942 &path->nh.address.ip6, &path->table_id))
7944 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7946 else if (unformat (input, "%U",
7947 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7950 * the recursive next-hops are by default in the default table
7953 path->sw_if_index = ~0;
7954 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7956 else if (unformat (input, "%U",
7957 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7960 * the recursive next-hops are by default in the default table
7963 path->sw_if_index = ~0;
7964 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7966 else if (unformat (input, "resolve-via-host"))
7968 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7970 else if (unformat (input, "resolve-via-attached"))
7972 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7974 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7976 path->type = FIB_API_PATH_TYPE_LOCAL;
7977 path->sw_if_index = ~0;
7978 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7980 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7982 path->type = FIB_API_PATH_TYPE_LOCAL;
7983 path->sw_if_index = ~0;
7984 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7986 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7988 else if (unformat (input, "via-label %d", &path->nh.via_label))
7990 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7991 path->sw_if_index = ~0;
7993 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7995 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7996 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7998 else if (unformat (input, "local"))
8000 path->type = FIB_API_PATH_TYPE_LOCAL;
8002 else if (unformat (input, "out-labels"))
8004 while (unformat (input, "%d", &out_label))
8006 path->label_stack[path->n_labels].label = out_label;
8007 path->label_stack[path->n_labels].is_uniform = 0;
8008 path->label_stack[path->n_labels].ttl = 64;
8012 else if (unformat (input, "via"))
8014 /* new path, back up and return */
8015 unformat_put_input (input);
8016 unformat_put_input (input);
8017 unformat_put_input (input);
8018 unformat_put_input (input);
8027 path->proto = ntohl (path->proto);
8028 path->type = ntohl (path->type);
8029 path->flags = ntohl (path->flags);
8030 path->table_id = ntohl (path->table_id);
8031 path->sw_if_index = ntohl (path->sw_if_index);
8037 api_ip_route_add_del (vat_main_t * vam)
8039 unformat_input_t *i = vam->input;
8040 vl_api_ip_route_add_del_t *mp;
8043 u8 is_multipath = 0;
8046 vl_api_prefix_t pfx = { };
8047 vl_api_fib_path_t paths[8];
8051 u32 random_add_del = 0;
8052 u32 *random_vector = 0;
8053 u32 random_seed = 0xdeaddabe;
8055 /* Parse args required to build the message */
8056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8058 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8060 else if (unformat (i, "del"))
8062 else if (unformat (i, "add"))
8064 else if (unformat (i, "vrf %d", &vrf_id))
8066 else if (unformat (i, "count %d", &count))
8068 else if (unformat (i, "random"))
8070 else if (unformat (i, "multipath"))
8072 else if (unformat (i, "seed %d", &random_seed))
8076 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8079 if (8 == path_count)
8081 errmsg ("max 8 paths");
8087 clib_warning ("parse error '%U'", format_unformat_error, i);
8094 errmsg ("specify a path; via ...");
8097 if (prefix_set == 0)
8099 errmsg ("missing prefix");
8103 /* Generate a pile of unique, random routes */
8106 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8107 u32 this_random_address;
8110 random_hash = hash_create (count, sizeof (uword));
8112 hash_set (random_hash, i->as_u32, 1);
8113 for (j = 0; j <= count; j++)
8117 this_random_address = random_u32 (&random_seed);
8118 this_random_address =
8119 clib_host_to_net_u32 (this_random_address);
8121 while (hash_get (random_hash, this_random_address));
8122 vec_add1 (random_vector, this_random_address);
8123 hash_set (random_hash, this_random_address, 1);
8125 hash_free (random_hash);
8126 set_ip4_address (&pfx.address, random_vector[0]);
8131 /* Turn on async mode */
8132 vam->async_mode = 1;
8133 vam->async_errors = 0;
8134 before = vat_time_now (vam);
8137 for (j = 0; j < count; j++)
8139 /* Construct the API message */
8140 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8142 mp->is_add = is_add;
8143 mp->is_multipath = is_multipath;
8145 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8146 mp->route.table_id = ntohl (vrf_id);
8147 mp->route.n_paths = path_count;
8149 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8152 set_ip4_address (&pfx.address, random_vector[j + 1]);
8154 increment_address (&pfx.address);
8157 /* If we receive SIGTERM, stop now... */
8162 /* When testing multiple add/del ops, use a control-ping to sync */
8165 vl_api_control_ping_t *mp_ping;
8169 /* Shut off async mode */
8170 vam->async_mode = 0;
8172 MPING (CONTROL_PING, mp_ping);
8175 timeout = vat_time_now (vam) + 1.0;
8176 while (vat_time_now (vam) < timeout)
8177 if (vam->result_ready == 1)
8182 if (vam->retval == -99)
8185 if (vam->async_errors > 0)
8187 errmsg ("%d asynchronous errors", vam->async_errors);
8190 vam->async_errors = 0;
8191 after = vat_time_now (vam);
8193 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8197 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8198 count, after - before, count / (after - before));
8204 /* Wait for a reply... */
8209 /* Return the good/bad news */
8210 return (vam->retval);
8214 api_ip_mroute_add_del (vat_main_t * vam)
8216 unformat_input_t *i = vam->input;
8217 u8 path_set = 0, prefix_set = 0, is_add = 1;
8218 vl_api_ip_mroute_add_del_t *mp;
8219 mfib_entry_flags_t eflags = 0;
8220 vl_api_mfib_path_t path;
8221 vl_api_mprefix_t pfx = { };
8225 /* Parse args required to build the message */
8226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8228 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8231 pfx.grp_address_length = htons (pfx.grp_address_length);
8233 else if (unformat (i, "del"))
8235 else if (unformat (i, "add"))
8237 else if (unformat (i, "vrf %d", &vrf_id))
8239 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8240 path.itf_flags = htonl (path.itf_flags);
8241 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8243 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8247 clib_warning ("parse error '%U'", format_unformat_error, i);
8252 if (prefix_set == 0)
8254 errmsg ("missing addresses\n");
8259 errmsg ("missing path\n");
8263 /* Construct the API message */
8264 M (IP_MROUTE_ADD_DEL, mp);
8266 mp->is_add = is_add;
8267 mp->is_multipath = 1;
8269 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8270 mp->route.table_id = htonl (vrf_id);
8271 mp->route.n_paths = 1;
8272 mp->route.entry_flags = htonl (eflags);
8274 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8278 /* Wait for a reply... */
8284 api_mpls_table_add_del (vat_main_t * vam)
8286 unformat_input_t *i = vam->input;
8287 vl_api_mpls_table_add_del_t *mp;
8292 /* Parse args required to build the message */
8293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8295 if (unformat (i, "table %d", &table_id))
8297 else if (unformat (i, "del"))
8299 else if (unformat (i, "add"))
8303 clib_warning ("parse error '%U'", format_unformat_error, i);
8310 errmsg ("missing table-ID");
8314 /* Construct the API message */
8315 M (MPLS_TABLE_ADD_DEL, mp);
8317 mp->mt_table.mt_table_id = ntohl (table_id);
8318 mp->mt_is_add = is_add;
8323 /* Wait for a reply... */
8330 api_mpls_route_add_del (vat_main_t * vam)
8332 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8333 mpls_label_t local_label = MPLS_LABEL_INVALID;
8334 unformat_input_t *i = vam->input;
8335 vl_api_mpls_route_add_del_t *mp;
8336 vl_api_fib_path_t paths[8];
8340 /* Parse args required to build the message */
8341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8343 if (unformat (i, "%d", &local_label))
8345 else if (unformat (i, "eos"))
8347 else if (unformat (i, "non-eos"))
8349 else if (unformat (i, "del"))
8351 else if (unformat (i, "add"))
8353 else if (unformat (i, "multipath"))
8355 else if (unformat (i, "count %d", &count))
8359 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8362 if (8 == path_count)
8364 errmsg ("max 8 paths");
8370 clib_warning ("parse error '%U'", format_unformat_error, i);
8377 errmsg ("specify a path; via ...");
8381 if (MPLS_LABEL_INVALID == local_label)
8383 errmsg ("missing label");
8389 /* Turn on async mode */
8390 vam->async_mode = 1;
8391 vam->async_errors = 0;
8392 before = vat_time_now (vam);
8395 for (j = 0; j < count; j++)
8397 /* Construct the API message */
8398 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8400 mp->mr_is_add = is_add;
8401 mp->mr_is_multipath = is_multipath;
8403 mp->mr_route.mr_label = local_label;
8404 mp->mr_route.mr_eos = is_eos;
8405 mp->mr_route.mr_table_id = 0;
8406 mp->mr_route.mr_n_paths = path_count;
8408 clib_memcpy (&mp->mr_route.mr_paths, paths,
8409 sizeof (paths[0]) * path_count);
8415 /* If we receive SIGTERM, stop now... */
8420 /* When testing multiple add/del ops, use a control-ping to sync */
8423 vl_api_control_ping_t *mp_ping;
8427 /* Shut off async mode */
8428 vam->async_mode = 0;
8430 MPING (CONTROL_PING, mp_ping);
8433 timeout = vat_time_now (vam) + 1.0;
8434 while (vat_time_now (vam) < timeout)
8435 if (vam->result_ready == 1)
8440 if (vam->retval == -99)
8443 if (vam->async_errors > 0)
8445 errmsg ("%d asynchronous errors", vam->async_errors);
8448 vam->async_errors = 0;
8449 after = vat_time_now (vam);
8451 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8455 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8456 count, after - before, count / (after - before));
8462 /* Wait for a reply... */
8467 /* Return the good/bad news */
8468 return (vam->retval);
8473 api_mpls_ip_bind_unbind (vat_main_t * vam)
8475 unformat_input_t *i = vam->input;
8476 vl_api_mpls_ip_bind_unbind_t *mp;
8477 u32 ip_table_id = 0;
8479 vl_api_prefix_t pfx;
8481 mpls_label_t local_label = MPLS_LABEL_INVALID;
8484 /* Parse args required to build the message */
8485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8487 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8489 else if (unformat (i, "%d", &local_label))
8491 else if (unformat (i, "table-id %d", &ip_table_id))
8493 else if (unformat (i, "unbind"))
8495 else if (unformat (i, "bind"))
8499 clib_warning ("parse error '%U'", format_unformat_error, i);
8506 errmsg ("IP prefix not set");
8510 if (MPLS_LABEL_INVALID == local_label)
8512 errmsg ("missing label");
8516 /* Construct the API message */
8517 M (MPLS_IP_BIND_UNBIND, mp);
8519 mp->mb_is_bind = is_bind;
8520 mp->mb_ip_table_id = ntohl (ip_table_id);
8521 mp->mb_mpls_table_id = 0;
8522 mp->mb_label = ntohl (local_label);
8523 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8528 /* Wait for a reply... */
8535 api_sr_mpls_policy_add (vat_main_t * vam)
8537 unformat_input_t *i = vam->input;
8538 vl_api_sr_mpls_policy_add_t *mp;
8544 u32 *segments = NULL;
8547 /* Parse args required to build the message */
8548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8550 if (unformat (i, "bsid %d", &bsid))
8552 else if (unformat (i, "weight %d", &weight))
8554 else if (unformat (i, "spray"))
8556 else if (unformat (i, "next %d", &sid))
8559 vec_add1 (segments, htonl (sid));
8563 clib_warning ("parse error '%U'", format_unformat_error, i);
8570 errmsg ("bsid not set");
8574 if (n_segments == 0)
8576 errmsg ("no sid in segment stack");
8580 /* Construct the API message */
8581 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8583 mp->bsid = htonl (bsid);
8584 mp->weight = htonl (weight);
8585 mp->is_spray = type;
8586 mp->n_segments = n_segments;
8587 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8588 vec_free (segments);
8593 /* Wait for a reply... */
8599 api_sr_mpls_policy_del (vat_main_t * vam)
8601 unformat_input_t *i = vam->input;
8602 vl_api_sr_mpls_policy_del_t *mp;
8606 /* Parse args required to build the message */
8607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8609 if (unformat (i, "bsid %d", &bsid))
8613 clib_warning ("parse error '%U'", format_unformat_error, i);
8620 errmsg ("bsid not set");
8624 /* Construct the API message */
8625 M (SR_MPLS_POLICY_DEL, mp);
8627 mp->bsid = htonl (bsid);
8632 /* Wait for a reply... */
8638 api_bier_table_add_del (vat_main_t * vam)
8640 unformat_input_t *i = vam->input;
8641 vl_api_bier_table_add_del_t *mp;
8643 u32 set = 0, sub_domain = 0, hdr_len = 3;
8644 mpls_label_t local_label = MPLS_LABEL_INVALID;
8647 /* Parse args required to build the message */
8648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8650 if (unformat (i, "sub-domain %d", &sub_domain))
8652 else if (unformat (i, "set %d", &set))
8654 else if (unformat (i, "label %d", &local_label))
8656 else if (unformat (i, "hdr-len %d", &hdr_len))
8658 else if (unformat (i, "add"))
8660 else if (unformat (i, "del"))
8664 clib_warning ("parse error '%U'", format_unformat_error, i);
8669 if (MPLS_LABEL_INVALID == local_label)
8671 errmsg ("missing label\n");
8675 /* Construct the API message */
8676 M (BIER_TABLE_ADD_DEL, mp);
8678 mp->bt_is_add = is_add;
8679 mp->bt_label = ntohl (local_label);
8680 mp->bt_tbl_id.bt_set = set;
8681 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8682 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8687 /* Wait for a reply... */
8694 api_bier_route_add_del (vat_main_t * vam)
8696 unformat_input_t *i = vam->input;
8697 vl_api_bier_route_add_del_t *mp;
8699 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8700 ip4_address_t v4_next_hop_address;
8701 ip6_address_t v6_next_hop_address;
8702 u8 next_hop_set = 0;
8703 u8 next_hop_proto_is_ip4 = 1;
8704 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8707 /* Parse args required to build the message */
8708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8710 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8712 next_hop_proto_is_ip4 = 1;
8715 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8717 next_hop_proto_is_ip4 = 0;
8720 if (unformat (i, "sub-domain %d", &sub_domain))
8722 else if (unformat (i, "set %d", &set))
8724 else if (unformat (i, "hdr-len %d", &hdr_len))
8726 else if (unformat (i, "bp %d", &bp))
8728 else if (unformat (i, "add"))
8730 else if (unformat (i, "del"))
8732 else if (unformat (i, "out-label %d", &next_hop_out_label))
8736 clib_warning ("parse error '%U'", format_unformat_error, i);
8741 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8743 errmsg ("next hop / label set\n");
8748 errmsg ("bit=position not set\n");
8752 /* Construct the API message */
8753 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8755 mp->br_is_add = is_add;
8756 mp->br_route.br_tbl_id.bt_set = set;
8757 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8758 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8759 mp->br_route.br_bp = ntohs (bp);
8760 mp->br_route.br_n_paths = 1;
8761 mp->br_route.br_paths[0].n_labels = 1;
8762 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8763 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8764 FIB_API_PATH_NH_PROTO_IP4 :
8765 FIB_API_PATH_NH_PROTO_IP6);
8767 if (next_hop_proto_is_ip4)
8769 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8770 &v4_next_hop_address, sizeof (v4_next_hop_address));
8774 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8775 &v6_next_hop_address, sizeof (v6_next_hop_address));
8781 /* Wait for a reply... */
8788 api_mpls_tunnel_add_del (vat_main_t * vam)
8790 unformat_input_t *i = vam->input;
8791 vl_api_mpls_tunnel_add_del_t *mp;
8793 vl_api_fib_path_t paths[8];
8794 u32 sw_if_index = ~0;
8800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8802 if (unformat (i, "add"))
8806 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8808 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8810 else if (unformat (i, "l2-only"))
8814 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8817 if (8 == path_count)
8819 errmsg ("max 8 paths");
8825 clib_warning ("parse error '%U'", format_unformat_error, i);
8830 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8832 mp->mt_is_add = is_add;
8833 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8834 mp->mt_tunnel.mt_l2_only = l2_only;
8835 mp->mt_tunnel.mt_is_multicast = 0;
8836 mp->mt_tunnel.mt_n_paths = path_count;
8838 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8839 sizeof (paths[0]) * path_count);
8847 api_sw_interface_set_unnumbered (vat_main_t * vam)
8849 unformat_input_t *i = vam->input;
8850 vl_api_sw_interface_set_unnumbered_t *mp;
8852 u32 unnum_sw_index = ~0;
8854 u8 sw_if_index_set = 0;
8857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8859 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8860 sw_if_index_set = 1;
8861 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8862 sw_if_index_set = 1;
8863 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8865 else if (unformat (i, "del"))
8869 clib_warning ("parse error '%U'", format_unformat_error, i);
8874 if (sw_if_index_set == 0)
8876 errmsg ("missing interface name or sw_if_index");
8880 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8882 mp->sw_if_index = ntohl (sw_if_index);
8883 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8884 mp->is_add = is_add;
8893 api_create_vlan_subif (vat_main_t * vam)
8895 unformat_input_t *i = vam->input;
8896 vl_api_create_vlan_subif_t *mp;
8898 u8 sw_if_index_set = 0;
8903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8905 if (unformat (i, "sw_if_index %d", &sw_if_index))
8906 sw_if_index_set = 1;
8908 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8909 sw_if_index_set = 1;
8910 else if (unformat (i, "vlan %d", &vlan_id))
8914 clib_warning ("parse error '%U'", format_unformat_error, i);
8919 if (sw_if_index_set == 0)
8921 errmsg ("missing interface name or sw_if_index");
8925 if (vlan_id_set == 0)
8927 errmsg ("missing vlan_id");
8930 M (CREATE_VLAN_SUBIF, mp);
8932 mp->sw_if_index = ntohl (sw_if_index);
8933 mp->vlan_id = ntohl (vlan_id);
8940 #define foreach_create_subif_bit \
8947 _(outer_vlan_id_any) \
8948 _(inner_vlan_id_any)
8950 #define foreach_create_subif_flag \
8955 _(4, "exact_match") \
8956 _(5, "default_sub") \
8957 _(6, "outer_vlan_id_any") \
8958 _(7, "inner_vlan_id_any")
8961 api_create_subif (vat_main_t * vam)
8963 unformat_input_t *i = vam->input;
8964 vl_api_create_subif_t *mp;
8966 u8 sw_if_index_set = 0;
8969 u32 __attribute__ ((unused)) no_tags = 0;
8970 u32 __attribute__ ((unused)) one_tag = 0;
8971 u32 __attribute__ ((unused)) two_tags = 0;
8972 u32 __attribute__ ((unused)) dot1ad = 0;
8973 u32 __attribute__ ((unused)) exact_match = 0;
8974 u32 __attribute__ ((unused)) default_sub = 0;
8975 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8976 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8978 u16 outer_vlan_id = 0;
8979 u16 inner_vlan_id = 0;
8982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8984 if (unformat (i, "sw_if_index %d", &sw_if_index))
8985 sw_if_index_set = 1;
8987 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8988 sw_if_index_set = 1;
8989 else if (unformat (i, "sub_id %d", &sub_id))
8991 else if (unformat (i, "outer_vlan_id %d", &tmp))
8992 outer_vlan_id = tmp;
8993 else if (unformat (i, "inner_vlan_id %d", &tmp))
8994 inner_vlan_id = tmp;
8996 #define _(a) else if (unformat (i, #a)) a = 1 ;
8997 foreach_create_subif_bit
9001 clib_warning ("parse error '%U'", format_unformat_error, i);
9006 if (sw_if_index_set == 0)
9008 errmsg ("missing interface name or sw_if_index");
9012 if (sub_id_set == 0)
9014 errmsg ("missing sub_id");
9017 M (CREATE_SUBIF, mp);
9019 mp->sw_if_index = ntohl (sw_if_index);
9020 mp->sub_id = ntohl (sub_id);
9022 #define _(a,b) mp->sub_if_flags |= (1 << a);
9023 foreach_create_subif_flag;
9026 mp->outer_vlan_id = ntohs (outer_vlan_id);
9027 mp->inner_vlan_id = ntohs (inner_vlan_id);
9035 api_ip_table_replace_begin (vat_main_t * vam)
9037 unformat_input_t *i = vam->input;
9038 vl_api_ip_table_replace_begin_t *mp;
9043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9045 if (unformat (i, "table %d", &table_id))
9047 else if (unformat (i, "ipv6"))
9051 clib_warning ("parse error '%U'", format_unformat_error, i);
9056 M (IP_TABLE_REPLACE_BEGIN, mp);
9058 mp->table.table_id = ntohl (table_id);
9059 mp->table.is_ip6 = is_ipv6;
9067 api_ip_table_flush (vat_main_t * vam)
9069 unformat_input_t *i = vam->input;
9070 vl_api_ip_table_flush_t *mp;
9075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9077 if (unformat (i, "table %d", &table_id))
9079 else if (unformat (i, "ipv6"))
9083 clib_warning ("parse error '%U'", format_unformat_error, i);
9088 M (IP_TABLE_FLUSH, mp);
9090 mp->table.table_id = ntohl (table_id);
9091 mp->table.is_ip6 = is_ipv6;
9099 api_ip_table_replace_end (vat_main_t * vam)
9101 unformat_input_t *i = vam->input;
9102 vl_api_ip_table_replace_end_t *mp;
9107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9109 if (unformat (i, "table %d", &table_id))
9111 else if (unformat (i, "ipv6"))
9115 clib_warning ("parse error '%U'", format_unformat_error, i);
9120 M (IP_TABLE_REPLACE_END, mp);
9122 mp->table.table_id = ntohl (table_id);
9123 mp->table.is_ip6 = is_ipv6;
9131 api_set_ip_flow_hash (vat_main_t * vam)
9133 unformat_input_t *i = vam->input;
9134 vl_api_set_ip_flow_hash_t *mp;
9146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9148 if (unformat (i, "vrf %d", &vrf_id))
9150 else if (unformat (i, "ipv6"))
9152 else if (unformat (i, "src"))
9154 else if (unformat (i, "dst"))
9156 else if (unformat (i, "sport"))
9158 else if (unformat (i, "dport"))
9160 else if (unformat (i, "proto"))
9162 else if (unformat (i, "reverse"))
9167 clib_warning ("parse error '%U'", format_unformat_error, i);
9172 if (vrf_id_set == 0)
9174 errmsg ("missing vrf id");
9178 M (SET_IP_FLOW_HASH, mp);
9184 mp->reverse = reverse;
9185 mp->vrf_id = ntohl (vrf_id);
9186 mp->is_ipv6 = is_ipv6;
9194 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9196 unformat_input_t *i = vam->input;
9197 vl_api_sw_interface_ip6_enable_disable_t *mp;
9199 u8 sw_if_index_set = 0;
9203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9205 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9206 sw_if_index_set = 1;
9207 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9208 sw_if_index_set = 1;
9209 else if (unformat (i, "enable"))
9211 else if (unformat (i, "disable"))
9215 clib_warning ("parse error '%U'", format_unformat_error, i);
9220 if (sw_if_index_set == 0)
9222 errmsg ("missing interface name or sw_if_index");
9226 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9228 mp->sw_if_index = ntohl (sw_if_index);
9229 mp->enable = enable;
9238 api_l2_patch_add_del (vat_main_t * vam)
9240 unformat_input_t *i = vam->input;
9241 vl_api_l2_patch_add_del_t *mp;
9243 u8 rx_sw_if_index_set = 0;
9245 u8 tx_sw_if_index_set = 0;
9249 /* Parse args required to build the message */
9250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9252 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9253 rx_sw_if_index_set = 1;
9254 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9255 tx_sw_if_index_set = 1;
9256 else if (unformat (i, "rx"))
9258 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9260 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9262 rx_sw_if_index_set = 1;
9267 else if (unformat (i, "tx"))
9269 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9271 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9273 tx_sw_if_index_set = 1;
9278 else if (unformat (i, "del"))
9284 if (rx_sw_if_index_set == 0)
9286 errmsg ("missing rx interface name or rx_sw_if_index");
9290 if (tx_sw_if_index_set == 0)
9292 errmsg ("missing tx interface name or tx_sw_if_index");
9296 M (L2_PATCH_ADD_DEL, mp);
9298 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9299 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9300 mp->is_add = is_add;
9308 u8 localsid_addr[16];
9317 api_sr_localsid_add_del (vat_main_t * vam)
9319 unformat_input_t *i = vam->input;
9320 vl_api_sr_localsid_add_del_t *mp;
9323 ip6_address_t localsid;
9327 u32 fib_table = ~(u32) 0;
9328 ip6_address_t nh_addr6;
9329 ip4_address_t nh_addr4;
9330 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
9331 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
9333 bool nexthop_set = 0;
9337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9339 if (unformat (i, "del"))
9341 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9342 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
9344 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
9346 else if (unformat (i, "behavior %u", &behavior));
9347 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9348 else if (unformat (i, "fib-table %u", &fib_table));
9349 else if (unformat (i, "end.psp %u", &behavior));
9354 M (SR_LOCALSID_ADD_DEL, mp);
9356 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
9360 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
9361 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
9363 mp->behavior = behavior;
9364 mp->sw_if_index = ntohl (sw_if_index);
9365 mp->fib_table = ntohl (fib_table);
9366 mp->end_psp = end_psp;
9367 mp->is_del = is_del;
9375 api_ioam_enable (vat_main_t * vam)
9377 unformat_input_t *input = vam->input;
9378 vl_api_ioam_enable_t *mp;
9380 int has_trace_option = 0;
9381 int has_pot_option = 0;
9382 int has_seqno_option = 0;
9383 int has_analyse_option = 0;
9386 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9388 if (unformat (input, "trace"))
9389 has_trace_option = 1;
9390 else if (unformat (input, "pot"))
9392 else if (unformat (input, "seqno"))
9393 has_seqno_option = 1;
9394 else if (unformat (input, "analyse"))
9395 has_analyse_option = 1;
9399 M (IOAM_ENABLE, mp);
9400 mp->id = htons (id);
9401 mp->seqno = has_seqno_option;
9402 mp->analyse = has_analyse_option;
9403 mp->pot_enable = has_pot_option;
9404 mp->trace_enable = has_trace_option;
9413 api_ioam_disable (vat_main_t * vam)
9415 vl_api_ioam_disable_t *mp;
9418 M (IOAM_DISABLE, mp);
9424 #define foreach_tcp_proto_field \
9428 #define foreach_udp_proto_field \
9432 #define foreach_ip4_proto_field \
9444 u16 src_port, dst_port;
9447 #if VPP_API_TEST_BUILTIN == 0
9449 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9451 u8 **maskp = va_arg (*args, u8 **);
9453 u8 found_something = 0;
9456 #define _(a) u8 a=0;
9457 foreach_tcp_proto_field;
9460 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9463 #define _(a) else if (unformat (input, #a)) a=1;
9464 foreach_tcp_proto_field
9470 #define _(a) found_something += a;
9471 foreach_tcp_proto_field;
9474 if (found_something == 0)
9477 vec_validate (mask, sizeof (*tcp) - 1);
9479 tcp = (tcp_header_t *) mask;
9481 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9482 foreach_tcp_proto_field;
9490 unformat_udp_mask (unformat_input_t * input, va_list * args)
9492 u8 **maskp = va_arg (*args, u8 **);
9494 u8 found_something = 0;
9497 #define _(a) u8 a=0;
9498 foreach_udp_proto_field;
9501 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9504 #define _(a) else if (unformat (input, #a)) a=1;
9505 foreach_udp_proto_field
9511 #define _(a) found_something += a;
9512 foreach_udp_proto_field;
9515 if (found_something == 0)
9518 vec_validate (mask, sizeof (*udp) - 1);
9520 udp = (udp_header_t *) mask;
9522 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9523 foreach_udp_proto_field;
9531 unformat_l4_mask (unformat_input_t * input, va_list * args)
9533 u8 **maskp = va_arg (*args, u8 **);
9534 u16 src_port = 0, dst_port = 0;
9535 tcpudp_header_t *tcpudp;
9537 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9539 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9541 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9543 else if (unformat (input, "src_port"))
9545 else if (unformat (input, "dst_port"))
9551 if (!src_port && !dst_port)
9555 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9557 tcpudp = (tcpudp_header_t *) mask;
9558 tcpudp->src_port = src_port;
9559 tcpudp->dst_port = dst_port;
9567 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9569 u8 **maskp = va_arg (*args, u8 **);
9571 u8 found_something = 0;
9574 #define _(a) u8 a=0;
9575 foreach_ip4_proto_field;
9581 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9583 if (unformat (input, "version"))
9585 else if (unformat (input, "hdr_length"))
9587 else if (unformat (input, "src"))
9589 else if (unformat (input, "dst"))
9591 else if (unformat (input, "proto"))
9594 #define _(a) else if (unformat (input, #a)) a=1;
9595 foreach_ip4_proto_field
9601 #define _(a) found_something += a;
9602 foreach_ip4_proto_field;
9605 if (found_something == 0)
9608 vec_validate (mask, sizeof (*ip) - 1);
9610 ip = (ip4_header_t *) mask;
9612 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9613 foreach_ip4_proto_field;
9616 ip->ip_version_and_header_length = 0;
9619 ip->ip_version_and_header_length |= 0xF0;
9622 ip->ip_version_and_header_length |= 0x0F;
9628 #define foreach_ip6_proto_field \
9636 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9638 u8 **maskp = va_arg (*args, u8 **);
9640 u8 found_something = 0;
9642 u32 ip_version_traffic_class_and_flow_label;
9644 #define _(a) u8 a=0;
9645 foreach_ip6_proto_field;
9648 u8 traffic_class = 0;
9651 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9653 if (unformat (input, "version"))
9655 else if (unformat (input, "traffic-class"))
9657 else if (unformat (input, "flow-label"))
9659 else if (unformat (input, "src"))
9661 else if (unformat (input, "dst"))
9663 else if (unformat (input, "proto"))
9666 #define _(a) else if (unformat (input, #a)) a=1;
9667 foreach_ip6_proto_field
9673 #define _(a) found_something += a;
9674 foreach_ip6_proto_field;
9677 if (found_something == 0)
9680 vec_validate (mask, sizeof (*ip) - 1);
9682 ip = (ip6_header_t *) mask;
9684 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9685 foreach_ip6_proto_field;
9688 ip_version_traffic_class_and_flow_label = 0;
9691 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9694 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9697 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9699 ip->ip_version_traffic_class_and_flow_label =
9700 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9707 unformat_l3_mask (unformat_input_t * input, va_list * args)
9709 u8 **maskp = va_arg (*args, u8 **);
9711 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9713 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9715 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9724 unformat_l2_mask (unformat_input_t * input, va_list * args)
9726 u8 **maskp = va_arg (*args, u8 **);
9741 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9743 if (unformat (input, "src"))
9745 else if (unformat (input, "dst"))
9747 else if (unformat (input, "proto"))
9749 else if (unformat (input, "tag1"))
9751 else if (unformat (input, "tag2"))
9753 else if (unformat (input, "ignore-tag1"))
9755 else if (unformat (input, "ignore-tag2"))
9757 else if (unformat (input, "cos1"))
9759 else if (unformat (input, "cos2"))
9761 else if (unformat (input, "dot1q"))
9763 else if (unformat (input, "dot1ad"))
9768 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9769 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9772 if (tag1 || ignore_tag1 || cos1 || dot1q)
9774 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9777 vec_validate (mask, len - 1);
9780 clib_memset (mask, 0xff, 6);
9783 clib_memset (mask + 6, 0xff, 6);
9787 /* inner vlan tag */
9796 mask[21] = mask[20] = 0xff;
9817 mask[16] = mask[17] = 0xff;
9827 mask[12] = mask[13] = 0xff;
9834 unformat_classify_mask (unformat_input_t * input, va_list * args)
9836 u8 **maskp = va_arg (*args, u8 **);
9837 u32 *skipp = va_arg (*args, u32 *);
9838 u32 *matchp = va_arg (*args, u32 *);
9846 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9848 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9850 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9852 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9854 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9868 if (mask || l2 || l3 || l4)
9872 /* "With a free Ethernet header in every package" */
9874 vec_validate (l2, 13);
9878 vec_append (mask, l3);
9883 vec_append (mask, l4);
9888 /* Scan forward looking for the first significant mask octet */
9889 for (i = 0; i < vec_len (mask); i++)
9893 /* compute (skip, match) params */
9894 *skipp = i / sizeof (u32x4);
9895 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9897 /* Pad mask to an even multiple of the vector size */
9898 while (vec_len (mask) % sizeof (u32x4))
9901 match = vec_len (mask) / sizeof (u32x4);
9903 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9905 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9906 if (*tmp || *(tmp + 1))
9911 clib_warning ("BUG: match 0");
9913 _vec_len (mask) = match * sizeof (u32x4);
9923 #endif /* VPP_API_TEST_BUILTIN */
9925 #define foreach_l2_next \
9927 _(ethernet, ETHERNET_INPUT) \
9932 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9934 u32 *miss_next_indexp = va_arg (*args, u32 *);
9939 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9943 if (unformat (input, "%d", &tmp))
9952 *miss_next_indexp = next_index;
9956 #define foreach_ip_next \
9962 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9964 u32 *miss_next_indexp = va_arg (*args, u32 *);
9969 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9973 if (unformat (input, "%d", &tmp))
9982 *miss_next_indexp = next_index;
9986 #define foreach_acl_next \
9990 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9992 u32 *miss_next_indexp = va_arg (*args, u32 *);
9997 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10001 if (unformat (input, "permit"))
10006 else if (unformat (input, "%d", &tmp))
10015 *miss_next_indexp = next_index;
10020 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10022 u32 *r = va_arg (*args, u32 *);
10024 if (unformat (input, "conform-color"))
10025 *r = POLICE_CONFORM;
10026 else if (unformat (input, "exceed-color"))
10027 *r = POLICE_EXCEED;
10035 api_classify_add_del_table (vat_main_t * vam)
10037 unformat_input_t *i = vam->input;
10038 vl_api_classify_add_del_table_t *mp;
10045 u32 table_index = ~0;
10046 u32 next_table_index = ~0;
10047 u32 miss_next_index = ~0;
10048 u32 memory_size = 32 << 20;
10050 u32 current_data_flag = 0;
10051 int current_data_offset = 0;
10054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10056 if (unformat (i, "del"))
10058 else if (unformat (i, "del-chain"))
10063 else if (unformat (i, "buckets %d", &nbuckets))
10065 else if (unformat (i, "memory_size %d", &memory_size))
10067 else if (unformat (i, "skip %d", &skip))
10069 else if (unformat (i, "match %d", &match))
10071 else if (unformat (i, "table %d", &table_index))
10073 else if (unformat (i, "mask %U", unformat_classify_mask,
10074 &mask, &skip, &match))
10076 else if (unformat (i, "next-table %d", &next_table_index))
10078 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10081 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10084 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10087 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10089 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10095 if (is_add && mask == 0)
10097 errmsg ("Mask required");
10101 if (is_add && skip == ~0)
10103 errmsg ("skip count required");
10107 if (is_add && match == ~0)
10109 errmsg ("match count required");
10113 if (!is_add && table_index == ~0)
10115 errmsg ("table index required for delete");
10119 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10121 mp->is_add = is_add;
10122 mp->del_chain = del_chain;
10123 mp->table_index = ntohl (table_index);
10124 mp->nbuckets = ntohl (nbuckets);
10125 mp->memory_size = ntohl (memory_size);
10126 mp->skip_n_vectors = ntohl (skip);
10127 mp->match_n_vectors = ntohl (match);
10128 mp->next_table_index = ntohl (next_table_index);
10129 mp->miss_next_index = ntohl (miss_next_index);
10130 mp->current_data_flag = ntohl (current_data_flag);
10131 mp->current_data_offset = ntohl (current_data_offset);
10132 mp->mask_len = ntohl (vec_len (mask));
10133 clib_memcpy (mp->mask, mask, vec_len (mask));
10142 #if VPP_API_TEST_BUILTIN == 0
10144 unformat_l4_match (unformat_input_t * input, va_list * args)
10146 u8 **matchp = va_arg (*args, u8 **);
10148 u8 *proto_header = 0;
10154 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10156 if (unformat (input, "src_port %d", &src_port))
10158 else if (unformat (input, "dst_port %d", &dst_port))
10164 h.src_port = clib_host_to_net_u16 (src_port);
10165 h.dst_port = clib_host_to_net_u16 (dst_port);
10166 vec_validate (proto_header, sizeof (h) - 1);
10167 memcpy (proto_header, &h, sizeof (h));
10169 *matchp = proto_header;
10175 unformat_ip4_match (unformat_input_t * input, va_list * args)
10177 u8 **matchp = va_arg (*args, u8 **);
10182 int hdr_length = 0;
10183 u32 hdr_length_val;
10184 int src = 0, dst = 0;
10185 ip4_address_t src_val, dst_val;
10192 int fragment_id = 0;
10193 u32 fragment_id_val;
10199 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10201 if (unformat (input, "version %d", &version_val))
10203 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10205 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10207 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10209 else if (unformat (input, "proto %d", &proto_val))
10211 else if (unformat (input, "tos %d", &tos_val))
10213 else if (unformat (input, "length %d", &length_val))
10215 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10217 else if (unformat (input, "ttl %d", &ttl_val))
10219 else if (unformat (input, "checksum %d", &checksum_val))
10225 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10226 + ttl + checksum == 0)
10230 * Aligned because we use the real comparison functions
10232 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10234 ip = (ip4_header_t *) match;
10236 /* These are realistically matched in practice */
10238 ip->src_address.as_u32 = src_val.as_u32;
10241 ip->dst_address.as_u32 = dst_val.as_u32;
10244 ip->protocol = proto_val;
10247 /* These are not, but they're included for completeness */
10249 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10252 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10258 ip->length = clib_host_to_net_u16 (length_val);
10264 ip->checksum = clib_host_to_net_u16 (checksum_val);
10271 unformat_ip6_match (unformat_input_t * input, va_list * args)
10273 u8 **matchp = va_arg (*args, u8 **);
10278 u8 traffic_class = 0;
10279 u32 traffic_class_val = 0;
10282 int src = 0, dst = 0;
10283 ip6_address_t src_val, dst_val;
10286 int payload_length = 0;
10287 u32 payload_length_val;
10290 u32 ip_version_traffic_class_and_flow_label;
10292 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10294 if (unformat (input, "version %d", &version_val))
10296 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10298 else if (unformat (input, "flow_label %d", &flow_label_val))
10300 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10302 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10304 else if (unformat (input, "proto %d", &proto_val))
10306 else if (unformat (input, "payload_length %d", &payload_length_val))
10307 payload_length = 1;
10308 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10314 if (version + traffic_class + flow_label + src + dst + proto +
10315 payload_length + hop_limit == 0)
10319 * Aligned because we use the real comparison functions
10321 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10323 ip = (ip6_header_t *) match;
10326 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10329 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10332 ip->protocol = proto_val;
10334 ip_version_traffic_class_and_flow_label = 0;
10337 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10340 ip_version_traffic_class_and_flow_label |=
10341 (traffic_class_val & 0xFF) << 20;
10344 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10346 ip->ip_version_traffic_class_and_flow_label =
10347 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10349 if (payload_length)
10350 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10353 ip->hop_limit = hop_limit_val;
10360 unformat_l3_match (unformat_input_t * input, va_list * args)
10362 u8 **matchp = va_arg (*args, u8 **);
10364 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10366 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10368 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10377 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10379 u8 *tagp = va_arg (*args, u8 *);
10382 if (unformat (input, "%d", &tag))
10384 tagp[0] = (tag >> 8) & 0x0F;
10385 tagp[1] = tag & 0xFF;
10393 unformat_l2_match (unformat_input_t * input, va_list * args)
10395 u8 **matchp = va_arg (*args, u8 **);
10408 u8 ignore_tag1 = 0;
10409 u8 ignore_tag2 = 0;
10415 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10417 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10420 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10422 else if (unformat (input, "proto %U",
10423 unformat_ethernet_type_host_byte_order, &proto_val))
10425 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10427 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10429 else if (unformat (input, "ignore-tag1"))
10431 else if (unformat (input, "ignore-tag2"))
10433 else if (unformat (input, "cos1 %d", &cos1_val))
10435 else if (unformat (input, "cos2 %d", &cos2_val))
10440 if ((src + dst + proto + tag1 + tag2 +
10441 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10444 if (tag1 || ignore_tag1 || cos1)
10446 if (tag2 || ignore_tag2 || cos2)
10449 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10452 clib_memcpy (match, dst_val, 6);
10455 clib_memcpy (match + 6, src_val, 6);
10459 /* inner vlan tag */
10460 match[19] = tag2_val[1];
10461 match[18] = tag2_val[0];
10463 match[18] |= (cos2_val & 0x7) << 5;
10466 match[21] = proto_val & 0xff;
10467 match[20] = proto_val >> 8;
10471 match[15] = tag1_val[1];
10472 match[14] = tag1_val[0];
10475 match[14] |= (cos1_val & 0x7) << 5;
10481 match[15] = tag1_val[1];
10482 match[14] = tag1_val[0];
10485 match[17] = proto_val & 0xff;
10486 match[16] = proto_val >> 8;
10489 match[14] |= (cos1_val & 0x7) << 5;
10495 match[18] |= (cos2_val & 0x7) << 5;
10497 match[14] |= (cos1_val & 0x7) << 5;
10500 match[13] = proto_val & 0xff;
10501 match[12] = proto_val >> 8;
10509 unformat_qos_source (unformat_input_t * input, va_list * args)
10511 int *qs = va_arg (*args, int *);
10513 if (unformat (input, "ip"))
10514 *qs = QOS_SOURCE_IP;
10515 else if (unformat (input, "mpls"))
10516 *qs = QOS_SOURCE_MPLS;
10517 else if (unformat (input, "ext"))
10518 *qs = QOS_SOURCE_EXT;
10519 else if (unformat (input, "vlan"))
10520 *qs = QOS_SOURCE_VLAN;
10529 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10531 u8 **matchp = va_arg (*args, u8 **);
10532 u32 skip_n_vectors = va_arg (*args, u32);
10533 u32 match_n_vectors = va_arg (*args, u32);
10540 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10542 if (unformat (input, "hex %U", unformat_hex_string, &match))
10544 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10546 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10548 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10562 if (match || l2 || l3 || l4)
10564 if (l2 || l3 || l4)
10566 /* "Win a free Ethernet header in every packet" */
10568 vec_validate_aligned (l2, 13, sizeof (u32x4));
10572 vec_append_aligned (match, l3, sizeof (u32x4));
10577 vec_append_aligned (match, l4, sizeof (u32x4));
10582 /* Make sure the vector is big enough even if key is all 0's */
10583 vec_validate_aligned
10584 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10587 /* Set size, include skipped vectors */
10588 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10599 api_classify_add_del_session (vat_main_t * vam)
10601 unformat_input_t *i = vam->input;
10602 vl_api_classify_add_del_session_t *mp;
10604 u32 table_index = ~0;
10605 u32 hit_next_index = ~0;
10606 u32 opaque_index = ~0;
10609 u32 skip_n_vectors = 0;
10610 u32 match_n_vectors = 0;
10616 * Warning: you have to supply skip_n and match_n
10617 * because the API client cant simply look at the classify
10621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10623 if (unformat (i, "del"))
10625 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10628 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10631 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10634 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10636 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10638 else if (unformat (i, "opaque-index %d", &opaque_index))
10640 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10642 else if (unformat (i, "match_n %d", &match_n_vectors))
10644 else if (unformat (i, "match %U", api_unformat_classify_match,
10645 &match, skip_n_vectors, match_n_vectors))
10647 else if (unformat (i, "advance %d", &advance))
10649 else if (unformat (i, "table-index %d", &table_index))
10651 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10653 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10655 else if (unformat (i, "action %d", &action))
10657 else if (unformat (i, "metadata %d", &metadata))
10663 if (table_index == ~0)
10665 errmsg ("Table index required");
10669 if (is_add && match == 0)
10671 errmsg ("Match value required");
10675 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10677 mp->is_add = is_add;
10678 mp->table_index = ntohl (table_index);
10679 mp->hit_next_index = ntohl (hit_next_index);
10680 mp->opaque_index = ntohl (opaque_index);
10681 mp->advance = ntohl (advance);
10682 mp->action = action;
10683 mp->metadata = ntohl (metadata);
10684 mp->match_len = ntohl (vec_len (match));
10685 clib_memcpy (mp->match, match, vec_len (match));
10694 api_classify_set_interface_ip_table (vat_main_t * vam)
10696 unformat_input_t *i = vam->input;
10697 vl_api_classify_set_interface_ip_table_t *mp;
10699 int sw_if_index_set;
10700 u32 table_index = ~0;
10704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10706 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10707 sw_if_index_set = 1;
10708 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10709 sw_if_index_set = 1;
10710 else if (unformat (i, "table %d", &table_index))
10714 clib_warning ("parse error '%U'", format_unformat_error, i);
10719 if (sw_if_index_set == 0)
10721 errmsg ("missing interface name or sw_if_index");
10726 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10728 mp->sw_if_index = ntohl (sw_if_index);
10729 mp->table_index = ntohl (table_index);
10730 mp->is_ipv6 = is_ipv6;
10738 api_classify_set_interface_l2_tables (vat_main_t * vam)
10740 unformat_input_t *i = vam->input;
10741 vl_api_classify_set_interface_l2_tables_t *mp;
10743 int sw_if_index_set;
10744 u32 ip4_table_index = ~0;
10745 u32 ip6_table_index = ~0;
10746 u32 other_table_index = ~0;
10750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10752 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10753 sw_if_index_set = 1;
10754 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10755 sw_if_index_set = 1;
10756 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10758 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10760 else if (unformat (i, "other-table %d", &other_table_index))
10762 else if (unformat (i, "is-input %d", &is_input))
10766 clib_warning ("parse error '%U'", format_unformat_error, i);
10771 if (sw_if_index_set == 0)
10773 errmsg ("missing interface name or sw_if_index");
10778 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10780 mp->sw_if_index = ntohl (sw_if_index);
10781 mp->ip4_table_index = ntohl (ip4_table_index);
10782 mp->ip6_table_index = ntohl (ip6_table_index);
10783 mp->other_table_index = ntohl (other_table_index);
10784 mp->is_input = (u8) is_input;
10792 api_set_ipfix_exporter (vat_main_t * vam)
10794 unformat_input_t *i = vam->input;
10795 vl_api_set_ipfix_exporter_t *mp;
10796 ip4_address_t collector_address;
10797 u8 collector_address_set = 0;
10798 u32 collector_port = ~0;
10799 ip4_address_t src_address;
10800 u8 src_address_set = 0;
10803 u32 template_interval = ~0;
10804 u8 udp_checksum = 0;
10807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10809 if (unformat (i, "collector_address %U", unformat_ip4_address,
10810 &collector_address))
10811 collector_address_set = 1;
10812 else if (unformat (i, "collector_port %d", &collector_port))
10814 else if (unformat (i, "src_address %U", unformat_ip4_address,
10816 src_address_set = 1;
10817 else if (unformat (i, "vrf_id %d", &vrf_id))
10819 else if (unformat (i, "path_mtu %d", &path_mtu))
10821 else if (unformat (i, "template_interval %d", &template_interval))
10823 else if (unformat (i, "udp_checksum"))
10829 if (collector_address_set == 0)
10831 errmsg ("collector_address required");
10835 if (src_address_set == 0)
10837 errmsg ("src_address required");
10841 M (SET_IPFIX_EXPORTER, mp);
10843 memcpy (mp->collector_address.un.ip4, collector_address.data,
10844 sizeof (collector_address.data));
10845 mp->collector_port = htons ((u16) collector_port);
10846 memcpy (mp->src_address.un.ip4, src_address.data,
10847 sizeof (src_address.data));
10848 mp->vrf_id = htonl (vrf_id);
10849 mp->path_mtu = htonl (path_mtu);
10850 mp->template_interval = htonl (template_interval);
10851 mp->udp_checksum = udp_checksum;
10859 api_set_ipfix_classify_stream (vat_main_t * vam)
10861 unformat_input_t *i = vam->input;
10862 vl_api_set_ipfix_classify_stream_t *mp;
10864 u32 src_port = UDP_DST_PORT_ipfix;
10867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10869 if (unformat (i, "domain %d", &domain_id))
10871 else if (unformat (i, "src_port %d", &src_port))
10875 errmsg ("unknown input `%U'", format_unformat_error, i);
10880 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10882 mp->domain_id = htonl (domain_id);
10883 mp->src_port = htons ((u16) src_port);
10891 api_ipfix_classify_table_add_del (vat_main_t * vam)
10893 unformat_input_t *i = vam->input;
10894 vl_api_ipfix_classify_table_add_del_t *mp;
10896 u32 classify_table_index = ~0;
10898 u8 transport_protocol = 255;
10901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10903 if (unformat (i, "add"))
10905 else if (unformat (i, "del"))
10907 else if (unformat (i, "table %d", &classify_table_index))
10909 else if (unformat (i, "ip4"))
10911 else if (unformat (i, "ip6"))
10913 else if (unformat (i, "tcp"))
10914 transport_protocol = 6;
10915 else if (unformat (i, "udp"))
10916 transport_protocol = 17;
10919 errmsg ("unknown input `%U'", format_unformat_error, i);
10926 errmsg ("expecting: add|del");
10929 if (classify_table_index == ~0)
10931 errmsg ("classifier table not specified");
10934 if (ip_version == 0)
10936 errmsg ("IP version not specified");
10940 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10942 mp->is_add = is_add;
10943 mp->table_id = htonl (classify_table_index);
10944 mp->ip_version = ip_version;
10945 mp->transport_protocol = transport_protocol;
10953 api_get_node_index (vat_main_t * vam)
10955 unformat_input_t *i = vam->input;
10956 vl_api_get_node_index_t *mp;
10960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10962 if (unformat (i, "node %s", &name))
10969 errmsg ("node name required");
10972 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10974 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10978 M (GET_NODE_INDEX, mp);
10979 clib_memcpy (mp->node_name, name, vec_len (name));
10988 api_get_next_index (vat_main_t * vam)
10990 unformat_input_t *i = vam->input;
10991 vl_api_get_next_index_t *mp;
10992 u8 *node_name = 0, *next_node_name = 0;
10995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10997 if (unformat (i, "node-name %s", &node_name))
10999 else if (unformat (i, "next-node-name %s", &next_node_name))
11003 if (node_name == 0)
11005 errmsg ("node name required");
11008 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11010 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11014 if (next_node_name == 0)
11016 errmsg ("next node name required");
11019 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11021 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11025 M (GET_NEXT_INDEX, mp);
11026 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11027 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11028 vec_free (node_name);
11029 vec_free (next_node_name);
11037 api_add_node_next (vat_main_t * vam)
11039 unformat_input_t *i = vam->input;
11040 vl_api_add_node_next_t *mp;
11045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11047 if (unformat (i, "node %s", &name))
11049 else if (unformat (i, "next %s", &next))
11056 errmsg ("node name required");
11059 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11061 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11066 errmsg ("next node required");
11069 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11071 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11075 M (ADD_NODE_NEXT, mp);
11076 clib_memcpy (mp->node_name, name, vec_len (name));
11077 clib_memcpy (mp->next_name, next, vec_len (next));
11087 api_l2tpv3_create_tunnel (vat_main_t * vam)
11089 unformat_input_t *i = vam->input;
11090 ip6_address_t client_address, our_address;
11091 int client_address_set = 0;
11092 int our_address_set = 0;
11093 u32 local_session_id = 0;
11094 u32 remote_session_id = 0;
11095 u64 local_cookie = 0;
11096 u64 remote_cookie = 0;
11097 u8 l2_sublayer_present = 0;
11098 vl_api_l2tpv3_create_tunnel_t *mp;
11101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11103 if (unformat (i, "client_address %U", unformat_ip6_address,
11105 client_address_set = 1;
11106 else if (unformat (i, "our_address %U", unformat_ip6_address,
11108 our_address_set = 1;
11109 else if (unformat (i, "local_session_id %d", &local_session_id))
11111 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11113 else if (unformat (i, "local_cookie %lld", &local_cookie))
11115 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11117 else if (unformat (i, "l2-sublayer-present"))
11118 l2_sublayer_present = 1;
11123 if (client_address_set == 0)
11125 errmsg ("client_address required");
11129 if (our_address_set == 0)
11131 errmsg ("our_address required");
11135 M (L2TPV3_CREATE_TUNNEL, mp);
11137 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11138 sizeof (ip6_address_t));
11140 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11141 sizeof (ip6_address_t));
11143 mp->local_session_id = ntohl (local_session_id);
11144 mp->remote_session_id = ntohl (remote_session_id);
11145 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11146 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11147 mp->l2_sublayer_present = l2_sublayer_present;
11155 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11157 unformat_input_t *i = vam->input;
11159 u8 sw_if_index_set = 0;
11160 u64 new_local_cookie = 0;
11161 u64 new_remote_cookie = 0;
11162 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11167 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11168 sw_if_index_set = 1;
11169 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11170 sw_if_index_set = 1;
11171 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11173 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11179 if (sw_if_index_set == 0)
11181 errmsg ("missing interface name or sw_if_index");
11185 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11187 mp->sw_if_index = ntohl (sw_if_index);
11188 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11189 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11197 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11199 unformat_input_t *i = vam->input;
11200 vl_api_l2tpv3_interface_enable_disable_t *mp;
11202 u8 sw_if_index_set = 0;
11203 u8 enable_disable = 1;
11206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11208 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11209 sw_if_index_set = 1;
11210 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11211 sw_if_index_set = 1;
11212 else if (unformat (i, "enable"))
11213 enable_disable = 1;
11214 else if (unformat (i, "disable"))
11215 enable_disable = 0;
11220 if (sw_if_index_set == 0)
11222 errmsg ("missing interface name or sw_if_index");
11226 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11228 mp->sw_if_index = ntohl (sw_if_index);
11229 mp->enable_disable = enable_disable;
11237 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11239 unformat_input_t *i = vam->input;
11240 vl_api_l2tpv3_set_lookup_key_t *mp;
11244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11246 if (unformat (i, "lookup_v6_src"))
11247 key = L2T_LOOKUP_SRC_ADDRESS;
11248 else if (unformat (i, "lookup_v6_dst"))
11249 key = L2T_LOOKUP_DST_ADDRESS;
11250 else if (unformat (i, "lookup_session_id"))
11251 key = L2T_LOOKUP_SESSION_ID;
11256 if (key == (u8) ~ 0)
11258 errmsg ("l2tp session lookup key unset");
11262 M (L2TPV3_SET_LOOKUP_KEY, mp);
11271 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11272 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11274 vat_main_t *vam = &vat_main;
11276 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11277 format_ip6_address, mp->our_address,
11278 format_ip6_address, mp->client_address,
11279 clib_net_to_host_u32 (mp->sw_if_index));
11282 " local cookies %016llx %016llx remote cookie %016llx",
11283 clib_net_to_host_u64 (mp->local_cookie[0]),
11284 clib_net_to_host_u64 (mp->local_cookie[1]),
11285 clib_net_to_host_u64 (mp->remote_cookie));
11287 print (vam->ofp, " local session-id %d remote session-id %d",
11288 clib_net_to_host_u32 (mp->local_session_id),
11289 clib_net_to_host_u32 (mp->remote_session_id));
11291 print (vam->ofp, " l2 specific sublayer %s\n",
11292 mp->l2_sublayer_present ? "preset" : "absent");
11296 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11297 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11299 vat_main_t *vam = &vat_main;
11300 vat_json_node_t *node = NULL;
11301 struct in6_addr addr;
11303 if (VAT_JSON_ARRAY != vam->json_tree.type)
11305 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11306 vat_json_init_array (&vam->json_tree);
11308 node = vat_json_array_add (&vam->json_tree);
11310 vat_json_init_object (node);
11312 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11313 vat_json_object_add_ip6 (node, "our_address", addr);
11314 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11315 vat_json_object_add_ip6 (node, "client_address", addr);
11317 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11318 vat_json_init_array (lc);
11319 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11320 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11321 vat_json_object_add_uint (node, "remote_cookie",
11322 clib_net_to_host_u64 (mp->remote_cookie));
11324 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11325 vat_json_object_add_uint (node, "local_session_id",
11326 clib_net_to_host_u32 (mp->local_session_id));
11327 vat_json_object_add_uint (node, "remote_session_id",
11328 clib_net_to_host_u32 (mp->remote_session_id));
11329 vat_json_object_add_string_copy (node, "l2_sublayer",
11330 mp->l2_sublayer_present ? (u8 *) "present"
11331 : (u8 *) "absent");
11335 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11337 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11338 vl_api_control_ping_t *mp_ping;
11341 /* Get list of l2tpv3-tunnel interfaces */
11342 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11345 /* Use a control ping for synchronization */
11346 MPING (CONTROL_PING, mp_ping);
11354 static void vl_api_sw_interface_tap_v2_details_t_handler
11355 (vl_api_sw_interface_tap_v2_details_t * mp)
11357 vat_main_t *vam = &vat_main;
11360 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11361 mp->host_ip4_prefix.len);
11363 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11364 mp->host_ip6_prefix.len);
11367 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11368 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11369 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11370 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11371 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11377 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11378 (vl_api_sw_interface_tap_v2_details_t * mp)
11380 vat_main_t *vam = &vat_main;
11381 vat_json_node_t *node = NULL;
11383 if (VAT_JSON_ARRAY != vam->json_tree.type)
11385 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11386 vat_json_init_array (&vam->json_tree);
11388 node = vat_json_array_add (&vam->json_tree);
11390 vat_json_init_object (node);
11391 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11392 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11393 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11394 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11395 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11396 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11397 vat_json_object_add_string_copy (node, "host_mac_addr",
11398 format (0, "%U", format_ethernet_address,
11399 &mp->host_mac_addr));
11400 vat_json_object_add_string_copy (node, "host_namespace",
11401 mp->host_namespace);
11402 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11403 vat_json_object_add_string_copy (node, "host_ip4_addr",
11404 format (0, "%U/%d", format_ip4_address,
11405 mp->host_ip4_prefix.address,
11406 mp->host_ip4_prefix.len));
11407 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11408 format (0, "%U/%d", format_ip6_address,
11409 mp->host_ip6_prefix.address,
11410 mp->host_ip6_prefix.len));
11415 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11417 vl_api_sw_interface_tap_v2_dump_t *mp;
11418 vl_api_control_ping_t *mp_ping;
11422 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11423 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11424 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11427 /* Get list of tap interfaces */
11428 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11431 /* Use a control ping for synchronization */
11432 MPING (CONTROL_PING, mp_ping);
11439 static void vl_api_sw_interface_virtio_pci_details_t_handler
11440 (vl_api_sw_interface_virtio_pci_details_t * mp)
11442 vat_main_t *vam = &vat_main;
11457 addr.domain = ntohs (mp->pci_addr.domain);
11458 addr.bus = mp->pci_addr.bus;
11459 addr.slot = mp->pci_addr.slot;
11460 addr.function = mp->pci_addr.function;
11462 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11463 addr.slot, addr.function);
11466 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11467 pci_addr, ntohl (mp->sw_if_index),
11468 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11469 format_ethernet_address, mp->mac_addr,
11470 clib_net_to_host_u64 (mp->features));
11471 vec_free (pci_addr);
11474 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11475 (vl_api_sw_interface_virtio_pci_details_t * mp)
11477 vat_main_t *vam = &vat_main;
11478 vat_json_node_t *node = NULL;
11479 vlib_pci_addr_t pci_addr;
11481 if (VAT_JSON_ARRAY != vam->json_tree.type)
11483 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11484 vat_json_init_array (&vam->json_tree);
11486 node = vat_json_array_add (&vam->json_tree);
11488 pci_addr.domain = ntohs (mp->pci_addr.domain);
11489 pci_addr.bus = mp->pci_addr.bus;
11490 pci_addr.slot = mp->pci_addr.slot;
11491 pci_addr.function = mp->pci_addr.function;
11493 vat_json_init_object (node);
11494 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11495 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11496 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11497 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11498 vat_json_object_add_uint (node, "features",
11499 clib_net_to_host_u64 (mp->features));
11500 vat_json_object_add_string_copy (node, "mac_addr",
11501 format (0, "%U", format_ethernet_address,
11506 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11508 vl_api_sw_interface_virtio_pci_dump_t *mp;
11509 vl_api_control_ping_t *mp_ping;
11513 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11514 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11515 "mac_addr", "features");
11517 /* Get list of tap interfaces */
11518 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11521 /* Use a control ping for synchronization */
11522 MPING (CONTROL_PING, mp_ping);
11530 api_vxlan_offload_rx (vat_main_t * vam)
11532 unformat_input_t *line_input = vam->input;
11533 vl_api_vxlan_offload_rx_t *mp;
11534 u32 hw_if_index = ~0, rx_if_index = ~0;
11538 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11540 if (unformat (line_input, "del"))
11542 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11545 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11547 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11550 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11554 errmsg ("parse error '%U'", format_unformat_error, line_input);
11559 if (hw_if_index == ~0)
11561 errmsg ("no hw interface");
11565 if (rx_if_index == ~0)
11567 errmsg ("no rx tunnel");
11571 M (VXLAN_OFFLOAD_RX, mp);
11573 mp->hw_if_index = ntohl (hw_if_index);
11574 mp->sw_if_index = ntohl (rx_if_index);
11575 mp->enable = is_add;
11582 static uword unformat_vxlan_decap_next
11583 (unformat_input_t * input, va_list * args)
11585 u32 *result = va_arg (*args, u32 *);
11588 if (unformat (input, "l2"))
11589 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11590 else if (unformat (input, "%d", &tmp))
11598 api_vxlan_add_del_tunnel (vat_main_t * vam)
11600 unformat_input_t *line_input = vam->input;
11601 vl_api_vxlan_add_del_tunnel_t *mp;
11602 ip46_address_t src, dst;
11604 u8 ipv4_set = 0, ipv6_set = 0;
11609 u32 mcast_sw_if_index = ~0;
11610 u32 encap_vrf_id = 0;
11611 u32 decap_next_index = ~0;
11615 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11616 clib_memset (&src, 0, sizeof src);
11617 clib_memset (&dst, 0, sizeof dst);
11619 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11621 if (unformat (line_input, "del"))
11623 else if (unformat (line_input, "instance %d", &instance))
11626 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11632 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11638 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11644 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11649 else if (unformat (line_input, "group %U %U",
11650 unformat_ip4_address, &dst.ip4,
11651 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11653 grp_set = dst_set = 1;
11656 else if (unformat (line_input, "group %U",
11657 unformat_ip4_address, &dst.ip4))
11659 grp_set = dst_set = 1;
11662 else if (unformat (line_input, "group %U %U",
11663 unformat_ip6_address, &dst.ip6,
11664 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11666 grp_set = dst_set = 1;
11669 else if (unformat (line_input, "group %U",
11670 unformat_ip6_address, &dst.ip6))
11672 grp_set = dst_set = 1;
11676 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11678 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11680 else if (unformat (line_input, "decap-next %U",
11681 unformat_vxlan_decap_next, &decap_next_index))
11683 else if (unformat (line_input, "vni %d", &vni))
11687 errmsg ("parse error '%U'", format_unformat_error, line_input);
11694 errmsg ("tunnel src address not specified");
11699 errmsg ("tunnel dst address not specified");
11703 if (grp_set && !ip46_address_is_multicast (&dst))
11705 errmsg ("tunnel group address not multicast");
11708 if (grp_set && mcast_sw_if_index == ~0)
11710 errmsg ("tunnel nonexistent multicast device");
11713 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11715 errmsg ("tunnel dst address must be unicast");
11720 if (ipv4_set && ipv6_set)
11722 errmsg ("both IPv4 and IPv6 addresses specified");
11726 if ((vni == 0) || (vni >> 24))
11728 errmsg ("vni not specified or out of range");
11732 M (VXLAN_ADD_DEL_TUNNEL, mp);
11736 clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
11737 clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11741 clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
11742 clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11744 mp->src_address.af = ipv6_set;
11745 mp->dst_address.af = ipv6_set;
11747 mp->instance = htonl (instance);
11748 mp->encap_vrf_id = ntohl (encap_vrf_id);
11749 mp->decap_next_index = ntohl (decap_next_index);
11750 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11751 mp->vni = ntohl (vni);
11752 mp->is_add = is_add;
11759 static void vl_api_vxlan_tunnel_details_t_handler
11760 (vl_api_vxlan_tunnel_details_t * mp)
11762 vat_main_t *vam = &vat_main;
11763 ip46_address_t src =
11764 to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
11765 ip46_address_t dst =
11766 to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
11768 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11769 ntohl (mp->sw_if_index),
11770 ntohl (mp->instance),
11771 format_ip46_address, &src, IP46_TYPE_ANY,
11772 format_ip46_address, &dst, IP46_TYPE_ANY,
11773 ntohl (mp->encap_vrf_id),
11774 ntohl (mp->decap_next_index), ntohl (mp->vni),
11775 ntohl (mp->mcast_sw_if_index));
11778 static void vl_api_vxlan_tunnel_details_t_handler_json
11779 (vl_api_vxlan_tunnel_details_t * mp)
11781 vat_main_t *vam = &vat_main;
11782 vat_json_node_t *node = NULL;
11784 if (VAT_JSON_ARRAY != vam->json_tree.type)
11786 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11787 vat_json_init_array (&vam->json_tree);
11789 node = vat_json_array_add (&vam->json_tree);
11791 vat_json_init_object (node);
11792 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11794 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11796 if (mp->src_address.af)
11798 struct in6_addr ip6;
11800 clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
11801 vat_json_object_add_ip6 (node, "src_address", ip6);
11802 clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
11803 vat_json_object_add_ip6 (node, "dst_address", ip6);
11807 struct in_addr ip4;
11809 clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
11810 vat_json_object_add_ip4 (node, "src_address", ip4);
11811 clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
11812 vat_json_object_add_ip4 (node, "dst_address", ip4);
11814 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11815 vat_json_object_add_uint (node, "decap_next_index",
11816 ntohl (mp->decap_next_index));
11817 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11818 vat_json_object_add_uint (node, "mcast_sw_if_index",
11819 ntohl (mp->mcast_sw_if_index));
11823 api_vxlan_tunnel_dump (vat_main_t * vam)
11825 unformat_input_t *i = vam->input;
11826 vl_api_vxlan_tunnel_dump_t *mp;
11827 vl_api_control_ping_t *mp_ping;
11829 u8 sw_if_index_set = 0;
11832 /* Parse args required to build the message */
11833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11835 if (unformat (i, "sw_if_index %d", &sw_if_index))
11836 sw_if_index_set = 1;
11841 if (sw_if_index_set == 0)
11846 if (!vam->json_output)
11848 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11849 "sw_if_index", "instance", "src_address", "dst_address",
11850 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11853 /* Get list of vxlan-tunnel interfaces */
11854 M (VXLAN_TUNNEL_DUMP, mp);
11856 mp->sw_if_index = htonl (sw_if_index);
11860 /* Use a control ping for synchronization */
11861 MPING (CONTROL_PING, mp_ping);
11868 static uword unformat_geneve_decap_next
11869 (unformat_input_t * input, va_list * args)
11871 u32 *result = va_arg (*args, u32 *);
11874 if (unformat (input, "l2"))
11875 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11876 else if (unformat (input, "%d", &tmp))
11884 api_geneve_add_del_tunnel (vat_main_t * vam)
11886 unformat_input_t *line_input = vam->input;
11887 vl_api_geneve_add_del_tunnel_t *mp;
11888 ip46_address_t src, dst;
11890 u8 ipv4_set = 0, ipv6_set = 0;
11894 u32 mcast_sw_if_index = ~0;
11895 u32 encap_vrf_id = 0;
11896 u32 decap_next_index = ~0;
11900 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11901 clib_memset (&src, 0, sizeof src);
11902 clib_memset (&dst, 0, sizeof dst);
11904 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11906 if (unformat (line_input, "del"))
11909 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11915 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11921 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11927 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11932 else if (unformat (line_input, "group %U %U",
11933 unformat_ip4_address, &dst.ip4,
11934 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11936 grp_set = dst_set = 1;
11939 else if (unformat (line_input, "group %U",
11940 unformat_ip4_address, &dst.ip4))
11942 grp_set = dst_set = 1;
11945 else if (unformat (line_input, "group %U %U",
11946 unformat_ip6_address, &dst.ip6,
11947 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11949 grp_set = dst_set = 1;
11952 else if (unformat (line_input, "group %U",
11953 unformat_ip6_address, &dst.ip6))
11955 grp_set = dst_set = 1;
11959 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11961 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11963 else if (unformat (line_input, "decap-next %U",
11964 unformat_geneve_decap_next, &decap_next_index))
11966 else if (unformat (line_input, "vni %d", &vni))
11970 errmsg ("parse error '%U'", format_unformat_error, line_input);
11977 errmsg ("tunnel src address not specified");
11982 errmsg ("tunnel dst address not specified");
11986 if (grp_set && !ip46_address_is_multicast (&dst))
11988 errmsg ("tunnel group address not multicast");
11991 if (grp_set && mcast_sw_if_index == ~0)
11993 errmsg ("tunnel nonexistent multicast device");
11996 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11998 errmsg ("tunnel dst address must be unicast");
12003 if (ipv4_set && ipv6_set)
12005 errmsg ("both IPv4 and IPv6 addresses specified");
12009 if ((vni == 0) || (vni >> 24))
12011 errmsg ("vni not specified or out of range");
12015 M (GENEVE_ADD_DEL_TUNNEL, mp);
12019 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12020 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12024 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12025 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12027 mp->encap_vrf_id = ntohl (encap_vrf_id);
12028 mp->decap_next_index = ntohl (decap_next_index);
12029 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12030 mp->vni = ntohl (vni);
12031 mp->is_add = is_add;
12038 static void vl_api_geneve_tunnel_details_t_handler
12039 (vl_api_geneve_tunnel_details_t * mp)
12041 vat_main_t *vam = &vat_main;
12042 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12043 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12045 if (mp->src_address.af == ADDRESS_IP6)
12047 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12048 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12052 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12053 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12056 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12057 ntohl (mp->sw_if_index),
12058 format_ip46_address, &src, IP46_TYPE_ANY,
12059 format_ip46_address, &dst, IP46_TYPE_ANY,
12060 ntohl (mp->encap_vrf_id),
12061 ntohl (mp->decap_next_index), ntohl (mp->vni),
12062 ntohl (mp->mcast_sw_if_index));
12065 static void vl_api_geneve_tunnel_details_t_handler_json
12066 (vl_api_geneve_tunnel_details_t * mp)
12068 vat_main_t *vam = &vat_main;
12069 vat_json_node_t *node = NULL;
12072 if (VAT_JSON_ARRAY != vam->json_tree.type)
12074 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12075 vat_json_init_array (&vam->json_tree);
12077 node = vat_json_array_add (&vam->json_tree);
12079 vat_json_init_object (node);
12080 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12081 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12084 struct in6_addr ip6;
12086 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12087 vat_json_object_add_ip6 (node, "src_address", ip6);
12088 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12089 vat_json_object_add_ip6 (node, "dst_address", ip6);
12093 struct in_addr ip4;
12095 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12096 vat_json_object_add_ip4 (node, "src_address", ip4);
12097 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12098 vat_json_object_add_ip4 (node, "dst_address", ip4);
12100 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12101 vat_json_object_add_uint (node, "decap_next_index",
12102 ntohl (mp->decap_next_index));
12103 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12104 vat_json_object_add_uint (node, "mcast_sw_if_index",
12105 ntohl (mp->mcast_sw_if_index));
12109 api_geneve_tunnel_dump (vat_main_t * vam)
12111 unformat_input_t *i = vam->input;
12112 vl_api_geneve_tunnel_dump_t *mp;
12113 vl_api_control_ping_t *mp_ping;
12115 u8 sw_if_index_set = 0;
12118 /* Parse args required to build the message */
12119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12121 if (unformat (i, "sw_if_index %d", &sw_if_index))
12122 sw_if_index_set = 1;
12127 if (sw_if_index_set == 0)
12132 if (!vam->json_output)
12134 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12135 "sw_if_index", "local_address", "remote_address",
12136 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12139 /* Get list of geneve-tunnel interfaces */
12140 M (GENEVE_TUNNEL_DUMP, mp);
12142 mp->sw_if_index = htonl (sw_if_index);
12146 /* Use a control ping for synchronization */
12147 M (CONTROL_PING, mp_ping);
12155 api_gre_tunnel_add_del (vat_main_t * vam)
12157 unformat_input_t *line_input = vam->input;
12158 vl_api_address_t src = { }, dst =
12161 vl_api_gre_tunnel_add_del_t *mp;
12162 vl_api_gre_tunnel_type_t t_type;
12166 u32 outer_table_id = 0;
12167 u32 session_id = 0;
12171 t_type = GRE_API_TUNNEL_TYPE_L3;
12173 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12175 if (unformat (line_input, "del"))
12177 else if (unformat (line_input, "instance %d", &instance))
12179 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12183 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12187 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12189 else if (unformat (line_input, "teb"))
12190 t_type = GRE_API_TUNNEL_TYPE_TEB;
12191 else if (unformat (line_input, "erspan %d", &session_id))
12192 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12195 errmsg ("parse error '%U'", format_unformat_error, line_input);
12202 errmsg ("tunnel src address not specified");
12207 errmsg ("tunnel dst address not specified");
12211 M (GRE_TUNNEL_ADD_DEL, mp);
12213 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12214 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12216 mp->tunnel.instance = htonl (instance);
12217 mp->tunnel.outer_table_id = htonl (outer_table_id);
12218 mp->is_add = is_add;
12219 mp->tunnel.session_id = htons ((u16) session_id);
12220 mp->tunnel.type = htonl (t_type);
12227 static void vl_api_gre_tunnel_details_t_handler
12228 (vl_api_gre_tunnel_details_t * mp)
12230 vat_main_t *vam = &vat_main;
12232 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12233 ntohl (mp->tunnel.sw_if_index),
12234 ntohl (mp->tunnel.instance),
12235 format_vl_api_address, &mp->tunnel.src,
12236 format_vl_api_address, &mp->tunnel.dst,
12237 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12238 ntohl (mp->tunnel.session_id));
12241 static void vl_api_gre_tunnel_details_t_handler_json
12242 (vl_api_gre_tunnel_details_t * mp)
12244 vat_main_t *vam = &vat_main;
12245 vat_json_node_t *node = NULL;
12247 if (VAT_JSON_ARRAY != vam->json_tree.type)
12249 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12250 vat_json_init_array (&vam->json_tree);
12252 node = vat_json_array_add (&vam->json_tree);
12254 vat_json_init_object (node);
12255 vat_json_object_add_uint (node, "sw_if_index",
12256 ntohl (mp->tunnel.sw_if_index));
12257 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12259 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12260 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12261 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12262 vat_json_object_add_uint (node, "outer_table_id",
12263 ntohl (mp->tunnel.outer_table_id));
12264 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12268 api_gre_tunnel_dump (vat_main_t * vam)
12270 unformat_input_t *i = vam->input;
12271 vl_api_gre_tunnel_dump_t *mp;
12272 vl_api_control_ping_t *mp_ping;
12274 u8 sw_if_index_set = 0;
12277 /* Parse args required to build the message */
12278 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12280 if (unformat (i, "sw_if_index %d", &sw_if_index))
12281 sw_if_index_set = 1;
12286 if (sw_if_index_set == 0)
12291 if (!vam->json_output)
12293 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12294 "sw_if_index", "instance", "src_address", "dst_address",
12295 "tunnel_type", "outer_fib_id", "session_id");
12298 /* Get list of gre-tunnel interfaces */
12299 M (GRE_TUNNEL_DUMP, mp);
12301 mp->sw_if_index = htonl (sw_if_index);
12305 /* Use a control ping for synchronization */
12306 MPING (CONTROL_PING, mp_ping);
12314 api_l2_fib_clear_table (vat_main_t * vam)
12316 // unformat_input_t * i = vam->input;
12317 vl_api_l2_fib_clear_table_t *mp;
12320 M (L2_FIB_CLEAR_TABLE, mp);
12328 api_l2_interface_efp_filter (vat_main_t * vam)
12330 unformat_input_t *i = vam->input;
12331 vl_api_l2_interface_efp_filter_t *mp;
12334 u8 sw_if_index_set = 0;
12337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12340 sw_if_index_set = 1;
12341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12342 sw_if_index_set = 1;
12343 else if (unformat (i, "enable"))
12345 else if (unformat (i, "disable"))
12349 clib_warning ("parse error '%U'", format_unformat_error, i);
12354 if (sw_if_index_set == 0)
12356 errmsg ("missing sw_if_index");
12360 M (L2_INTERFACE_EFP_FILTER, mp);
12362 mp->sw_if_index = ntohl (sw_if_index);
12363 mp->enable_disable = enable;
12370 #define foreach_vtr_op \
12371 _("disable", L2_VTR_DISABLED) \
12372 _("push-1", L2_VTR_PUSH_1) \
12373 _("push-2", L2_VTR_PUSH_2) \
12374 _("pop-1", L2_VTR_POP_1) \
12375 _("pop-2", L2_VTR_POP_2) \
12376 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12377 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12378 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12379 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12382 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12384 unformat_input_t *i = vam->input;
12385 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12387 u8 sw_if_index_set = 0;
12390 u32 push_dot1q = 1;
12395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12397 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12398 sw_if_index_set = 1;
12399 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12400 sw_if_index_set = 1;
12401 else if (unformat (i, "vtr_op %d", &vtr_op))
12403 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12406 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12408 else if (unformat (i, "tag1 %d", &tag1))
12410 else if (unformat (i, "tag2 %d", &tag2))
12414 clib_warning ("parse error '%U'", format_unformat_error, i);
12419 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12421 errmsg ("missing vtr operation or sw_if_index");
12425 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12426 mp->sw_if_index = ntohl (sw_if_index);
12427 mp->vtr_op = ntohl (vtr_op);
12428 mp->push_dot1q = ntohl (push_dot1q);
12429 mp->tag1 = ntohl (tag1);
12430 mp->tag2 = ntohl (tag2);
12438 api_create_vhost_user_if (vat_main_t * vam)
12440 unformat_input_t *i = vam->input;
12441 vl_api_create_vhost_user_if_t *mp;
12444 u8 file_name_set = 0;
12445 u32 custom_dev_instance = ~0;
12447 u8 use_custom_mac = 0;
12448 u8 disable_mrg_rxbuf = 0;
12449 u8 disable_indirect_desc = 0;
12454 /* Shut up coverity */
12455 clib_memset (hwaddr, 0, sizeof (hwaddr));
12457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12459 if (unformat (i, "socket %s", &file_name))
12463 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12465 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12466 use_custom_mac = 1;
12467 else if (unformat (i, "server"))
12469 else if (unformat (i, "disable_mrg_rxbuf"))
12470 disable_mrg_rxbuf = 1;
12471 else if (unformat (i, "disable_indirect_desc"))
12472 disable_indirect_desc = 1;
12473 else if (unformat (i, "gso"))
12475 else if (unformat (i, "tag %s", &tag))
12481 if (file_name_set == 0)
12483 errmsg ("missing socket file name");
12487 if (vec_len (file_name) > 255)
12489 errmsg ("socket file name too long");
12492 vec_add1 (file_name, 0);
12494 M (CREATE_VHOST_USER_IF, mp);
12496 mp->is_server = is_server;
12497 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12498 mp->disable_indirect_desc = disable_indirect_desc;
12499 mp->enable_gso = enable_gso;
12500 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12501 vec_free (file_name);
12502 if (custom_dev_instance != ~0)
12505 mp->custom_dev_instance = ntohl (custom_dev_instance);
12508 mp->use_custom_mac = use_custom_mac;
12509 clib_memcpy (mp->mac_address, hwaddr, 6);
12511 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12520 api_modify_vhost_user_if (vat_main_t * vam)
12522 unformat_input_t *i = vam->input;
12523 vl_api_modify_vhost_user_if_t *mp;
12526 u8 file_name_set = 0;
12527 u32 custom_dev_instance = ~0;
12528 u8 sw_if_index_set = 0;
12529 u32 sw_if_index = (u32) ~ 0;
12533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12535 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12536 sw_if_index_set = 1;
12537 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12538 sw_if_index_set = 1;
12539 else if (unformat (i, "socket %s", &file_name))
12543 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12545 else if (unformat (i, "server"))
12547 else if (unformat (i, "gso"))
12553 if (sw_if_index_set == 0)
12555 errmsg ("missing sw_if_index or interface name");
12559 if (file_name_set == 0)
12561 errmsg ("missing socket file name");
12565 if (vec_len (file_name) > 255)
12567 errmsg ("socket file name too long");
12570 vec_add1 (file_name, 0);
12572 M (MODIFY_VHOST_USER_IF, mp);
12574 mp->sw_if_index = ntohl (sw_if_index);
12575 mp->is_server = is_server;
12576 mp->enable_gso = enable_gso;
12577 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12578 vec_free (file_name);
12579 if (custom_dev_instance != ~0)
12582 mp->custom_dev_instance = ntohl (custom_dev_instance);
12591 api_delete_vhost_user_if (vat_main_t * vam)
12593 unformat_input_t *i = vam->input;
12594 vl_api_delete_vhost_user_if_t *mp;
12595 u32 sw_if_index = ~0;
12596 u8 sw_if_index_set = 0;
12599 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12601 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12602 sw_if_index_set = 1;
12603 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12604 sw_if_index_set = 1;
12609 if (sw_if_index_set == 0)
12611 errmsg ("missing sw_if_index or interface name");
12616 M (DELETE_VHOST_USER_IF, mp);
12618 mp->sw_if_index = ntohl (sw_if_index);
12625 static void vl_api_sw_interface_vhost_user_details_t_handler
12626 (vl_api_sw_interface_vhost_user_details_t * mp)
12628 vat_main_t *vam = &vat_main;
12632 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12633 clib_net_to_host_u32
12634 (mp->features_last_32) <<
12637 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12638 (char *) mp->interface_name,
12639 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12640 features, mp->is_server,
12641 ntohl (mp->num_regions), (char *) mp->sock_filename);
12642 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12645 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12646 (vl_api_sw_interface_vhost_user_details_t * mp)
12648 vat_main_t *vam = &vat_main;
12649 vat_json_node_t *node = NULL;
12651 if (VAT_JSON_ARRAY != vam->json_tree.type)
12653 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12654 vat_json_init_array (&vam->json_tree);
12656 node = vat_json_array_add (&vam->json_tree);
12658 vat_json_init_object (node);
12659 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12660 vat_json_object_add_string_copy (node, "interface_name",
12661 mp->interface_name);
12662 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12663 ntohl (mp->virtio_net_hdr_sz));
12664 vat_json_object_add_uint (node, "features_first_32",
12665 clib_net_to_host_u32 (mp->features_first_32));
12666 vat_json_object_add_uint (node, "features_last_32",
12667 clib_net_to_host_u32 (mp->features_last_32));
12668 vat_json_object_add_uint (node, "is_server", mp->is_server);
12669 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12670 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12671 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12675 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12677 vl_api_sw_interface_vhost_user_dump_t *mp;
12678 vl_api_control_ping_t *mp_ping;
12681 "Interface name idx hdr_sz features server regions filename");
12683 /* Get list of vhost-user interfaces */
12684 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12685 mp->sw_if_index = ntohl (~0);
12688 /* Use a control ping for synchronization */
12689 MPING (CONTROL_PING, mp_ping);
12697 api_show_version (vat_main_t * vam)
12699 vl_api_show_version_t *mp;
12702 M (SHOW_VERSION, mp);
12711 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12713 unformat_input_t *line_input = vam->input;
12714 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12715 ip46_address_t local, remote;
12720 u32 mcast_sw_if_index = ~0;
12721 u32 encap_vrf_id = 0;
12722 u32 decap_vrf_id = 0;
12728 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12730 if (unformat (line_input, "del"))
12732 else if (unformat (line_input, "local %U",
12733 unformat_ip46_address, &local))
12737 else if (unformat (line_input, "remote %U",
12738 unformat_ip46_address, &remote))
12742 else if (unformat (line_input, "group %U %U",
12743 unformat_ip46_address, &remote,
12744 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12746 grp_set = remote_set = 1;
12748 else if (unformat (line_input, "group %U",
12749 unformat_ip46_address, &remote))
12751 grp_set = remote_set = 1;
12754 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12756 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12758 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12760 else if (unformat (line_input, "vni %d", &vni))
12762 else if (unformat (line_input, "next-ip4"))
12764 else if (unformat (line_input, "next-ip6"))
12766 else if (unformat (line_input, "next-ethernet"))
12768 else if (unformat (line_input, "next-nsh"))
12772 errmsg ("parse error '%U'", format_unformat_error, line_input);
12777 if (local_set == 0)
12779 errmsg ("tunnel local address not specified");
12782 if (remote_set == 0)
12784 errmsg ("tunnel remote address not specified");
12787 if (grp_set && mcast_sw_if_index == ~0)
12789 errmsg ("tunnel nonexistent multicast device");
12792 if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
12794 errmsg ("both IPv4 and IPv6 addresses specified");
12800 errmsg ("vni not specified");
12804 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12806 ip_address_encode (&local,
12807 ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
12808 IP46_TYPE_IP6, &mp->local);
12809 ip_address_encode (&remote,
12810 ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
12811 IP46_TYPE_IP6, &mp->remote);
12813 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12814 mp->encap_vrf_id = ntohl (encap_vrf_id);
12815 mp->decap_vrf_id = ntohl (decap_vrf_id);
12816 mp->protocol = protocol;
12817 mp->vni = ntohl (vni);
12818 mp->is_add = is_add;
12825 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12826 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12828 vat_main_t *vam = &vat_main;
12829 ip46_address_t local, remote;
12831 ip_address_decode (&mp->local, &local);
12832 ip_address_decode (&mp->remote, &remote);
12834 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12835 ntohl (mp->sw_if_index),
12836 format_ip46_address, &local, IP46_TYPE_ANY,
12837 format_ip46_address, &remote, IP46_TYPE_ANY,
12838 ntohl (mp->vni), mp->protocol,
12839 ntohl (mp->mcast_sw_if_index),
12840 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12844 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12845 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12847 vat_main_t *vam = &vat_main;
12848 vat_json_node_t *node = NULL;
12849 struct in_addr ip4;
12850 struct in6_addr ip6;
12851 ip46_address_t local, remote;
12853 ip_address_decode (&mp->local, &local);
12854 ip_address_decode (&mp->remote, &remote);
12856 if (VAT_JSON_ARRAY != vam->json_tree.type)
12858 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12859 vat_json_init_array (&vam->json_tree);
12861 node = vat_json_array_add (&vam->json_tree);
12863 vat_json_init_object (node);
12864 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12865 if (ip46_address_is_ip4 (&local))
12867 clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
12868 vat_json_object_add_ip4 (node, "local", ip4);
12869 clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
12870 vat_json_object_add_ip4 (node, "remote", ip4);
12874 clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
12875 vat_json_object_add_ip6 (node, "local", ip6);
12876 clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
12877 vat_json_object_add_ip6 (node, "remote", ip6);
12879 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12880 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12881 vat_json_object_add_uint (node, "mcast_sw_if_index",
12882 ntohl (mp->mcast_sw_if_index));
12883 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12884 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12885 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12889 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12891 unformat_input_t *i = vam->input;
12892 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12893 vl_api_control_ping_t *mp_ping;
12895 u8 sw_if_index_set = 0;
12898 /* Parse args required to build the message */
12899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12901 if (unformat (i, "sw_if_index %d", &sw_if_index))
12902 sw_if_index_set = 1;
12907 if (sw_if_index_set == 0)
12912 if (!vam->json_output)
12914 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12915 "sw_if_index", "local", "remote", "vni",
12916 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12919 /* Get list of vxlan-tunnel interfaces */
12920 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12922 mp->sw_if_index = htonl (sw_if_index);
12926 /* Use a control ping for synchronization */
12927 MPING (CONTROL_PING, mp_ping);
12934 static void vl_api_l2_fib_table_details_t_handler
12935 (vl_api_l2_fib_table_details_t * mp)
12937 vat_main_t *vam = &vat_main;
12939 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12941 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12942 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12946 static void vl_api_l2_fib_table_details_t_handler_json
12947 (vl_api_l2_fib_table_details_t * mp)
12949 vat_main_t *vam = &vat_main;
12950 vat_json_node_t *node = NULL;
12952 if (VAT_JSON_ARRAY != vam->json_tree.type)
12954 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12955 vat_json_init_array (&vam->json_tree);
12957 node = vat_json_array_add (&vam->json_tree);
12959 vat_json_init_object (node);
12960 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12961 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12962 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12963 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12964 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12965 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12969 api_l2_fib_table_dump (vat_main_t * vam)
12971 unformat_input_t *i = vam->input;
12972 vl_api_l2_fib_table_dump_t *mp;
12973 vl_api_control_ping_t *mp_ping;
12978 /* Parse args required to build the message */
12979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12981 if (unformat (i, "bd_id %d", &bd_id))
12987 if (bd_id_set == 0)
12989 errmsg ("missing bridge domain");
12993 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12995 /* Get list of l2 fib entries */
12996 M (L2_FIB_TABLE_DUMP, mp);
12998 mp->bd_id = ntohl (bd_id);
13001 /* Use a control ping for synchronization */
13002 MPING (CONTROL_PING, mp_ping);
13011 api_interface_name_renumber (vat_main_t * vam)
13013 unformat_input_t *line_input = vam->input;
13014 vl_api_interface_name_renumber_t *mp;
13015 u32 sw_if_index = ~0;
13016 u32 new_show_dev_instance = ~0;
13019 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13021 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13024 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13026 else if (unformat (line_input, "new_show_dev_instance %d",
13027 &new_show_dev_instance))
13033 if (sw_if_index == ~0)
13035 errmsg ("missing interface name or sw_if_index");
13039 if (new_show_dev_instance == ~0)
13041 errmsg ("missing new_show_dev_instance");
13045 M (INTERFACE_NAME_RENUMBER, mp);
13047 mp->sw_if_index = ntohl (sw_if_index);
13048 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13056 api_want_l2_macs_events (vat_main_t * vam)
13058 unformat_input_t *line_input = vam->input;
13059 vl_api_want_l2_macs_events_t *mp;
13060 u8 enable_disable = 1;
13061 u32 scan_delay = 0;
13062 u32 max_macs_in_event = 0;
13063 u32 learn_limit = 0;
13066 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13068 if (unformat (line_input, "learn-limit %d", &learn_limit))
13070 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13072 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13074 else if (unformat (line_input, "disable"))
13075 enable_disable = 0;
13080 M (WANT_L2_MACS_EVENTS, mp);
13081 mp->enable_disable = enable_disable;
13082 mp->pid = htonl (getpid ());
13083 mp->learn_limit = htonl (learn_limit);
13084 mp->scan_delay = (u8) scan_delay;
13085 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13092 api_input_acl_set_interface (vat_main_t * vam)
13094 unformat_input_t *i = vam->input;
13095 vl_api_input_acl_set_interface_t *mp;
13097 int sw_if_index_set;
13098 u32 ip4_table_index = ~0;
13099 u32 ip6_table_index = ~0;
13100 u32 l2_table_index = ~0;
13104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13106 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13107 sw_if_index_set = 1;
13108 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13109 sw_if_index_set = 1;
13110 else if (unformat (i, "del"))
13112 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13114 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13116 else if (unformat (i, "l2-table %d", &l2_table_index))
13120 clib_warning ("parse error '%U'", format_unformat_error, i);
13125 if (sw_if_index_set == 0)
13127 errmsg ("missing interface name or sw_if_index");
13131 M (INPUT_ACL_SET_INTERFACE, mp);
13133 mp->sw_if_index = ntohl (sw_if_index);
13134 mp->ip4_table_index = ntohl (ip4_table_index);
13135 mp->ip6_table_index = ntohl (ip6_table_index);
13136 mp->l2_table_index = ntohl (l2_table_index);
13137 mp->is_add = is_add;
13145 api_output_acl_set_interface (vat_main_t * vam)
13147 unformat_input_t *i = vam->input;
13148 vl_api_output_acl_set_interface_t *mp;
13150 int sw_if_index_set;
13151 u32 ip4_table_index = ~0;
13152 u32 ip6_table_index = ~0;
13153 u32 l2_table_index = ~0;
13157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13159 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13160 sw_if_index_set = 1;
13161 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13162 sw_if_index_set = 1;
13163 else if (unformat (i, "del"))
13165 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13167 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13169 else if (unformat (i, "l2-table %d", &l2_table_index))
13173 clib_warning ("parse error '%U'", format_unformat_error, i);
13178 if (sw_if_index_set == 0)
13180 errmsg ("missing interface name or sw_if_index");
13184 M (OUTPUT_ACL_SET_INTERFACE, mp);
13186 mp->sw_if_index = ntohl (sw_if_index);
13187 mp->ip4_table_index = ntohl (ip4_table_index);
13188 mp->ip6_table_index = ntohl (ip6_table_index);
13189 mp->l2_table_index = ntohl (l2_table_index);
13190 mp->is_add = is_add;
13198 api_ip_address_dump (vat_main_t * vam)
13200 unformat_input_t *i = vam->input;
13201 vl_api_ip_address_dump_t *mp;
13202 vl_api_control_ping_t *mp_ping;
13203 u32 sw_if_index = ~0;
13204 u8 sw_if_index_set = 0;
13209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13211 if (unformat (i, "sw_if_index %d", &sw_if_index))
13212 sw_if_index_set = 1;
13214 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13215 sw_if_index_set = 1;
13216 else if (unformat (i, "ipv4"))
13218 else if (unformat (i, "ipv6"))
13224 if (ipv4_set && ipv6_set)
13226 errmsg ("ipv4 and ipv6 flags cannot be both set");
13230 if ((!ipv4_set) && (!ipv6_set))
13232 errmsg ("no ipv4 nor ipv6 flag set");
13236 if (sw_if_index_set == 0)
13238 errmsg ("missing interface name or sw_if_index");
13242 vam->current_sw_if_index = sw_if_index;
13243 vam->is_ipv6 = ipv6_set;
13245 M (IP_ADDRESS_DUMP, mp);
13246 mp->sw_if_index = ntohl (sw_if_index);
13247 mp->is_ipv6 = ipv6_set;
13250 /* Use a control ping for synchronization */
13251 MPING (CONTROL_PING, mp_ping);
13259 api_ip_dump (vat_main_t * vam)
13261 vl_api_ip_dump_t *mp;
13262 vl_api_control_ping_t *mp_ping;
13263 unformat_input_t *in = vam->input;
13270 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13272 if (unformat (in, "ipv4"))
13274 else if (unformat (in, "ipv6"))
13280 if (ipv4_set && ipv6_set)
13282 errmsg ("ipv4 and ipv6 flags cannot be both set");
13286 if ((!ipv4_set) && (!ipv6_set))
13288 errmsg ("no ipv4 nor ipv6 flag set");
13292 is_ipv6 = ipv6_set;
13293 vam->is_ipv6 = is_ipv6;
13295 /* free old data */
13296 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13298 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13300 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13303 mp->is_ipv6 = ipv6_set;
13306 /* Use a control ping for synchronization */
13307 MPING (CONTROL_PING, mp_ping);
13315 api_ipsec_spd_add_del (vat_main_t * vam)
13317 unformat_input_t *i = vam->input;
13318 vl_api_ipsec_spd_add_del_t *mp;
13323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13325 if (unformat (i, "spd_id %d", &spd_id))
13327 else if (unformat (i, "del"))
13331 clib_warning ("parse error '%U'", format_unformat_error, i);
13337 errmsg ("spd_id must be set");
13341 M (IPSEC_SPD_ADD_DEL, mp);
13343 mp->spd_id = ntohl (spd_id);
13344 mp->is_add = is_add;
13352 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13354 unformat_input_t *i = vam->input;
13355 vl_api_ipsec_interface_add_del_spd_t *mp;
13357 u8 sw_if_index_set = 0;
13358 u32 spd_id = (u32) ~ 0;
13362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13364 if (unformat (i, "del"))
13366 else if (unformat (i, "spd_id %d", &spd_id))
13369 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13370 sw_if_index_set = 1;
13371 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13372 sw_if_index_set = 1;
13375 clib_warning ("parse error '%U'", format_unformat_error, i);
13381 if (spd_id == (u32) ~ 0)
13383 errmsg ("spd_id must be set");
13387 if (sw_if_index_set == 0)
13389 errmsg ("missing interface name or sw_if_index");
13393 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13395 mp->spd_id = ntohl (spd_id);
13396 mp->sw_if_index = ntohl (sw_if_index);
13397 mp->is_add = is_add;
13405 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13407 unformat_input_t *i = vam->input;
13408 vl_api_ipsec_spd_entry_add_del_t *mp;
13409 u8 is_add = 1, is_outbound = 0;
13410 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13412 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13413 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13414 vl_api_address_t laddr_start = { }, laddr_stop =
13423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13425 if (unformat (i, "del"))
13427 if (unformat (i, "outbound"))
13429 if (unformat (i, "inbound"))
13431 else if (unformat (i, "spd_id %d", &spd_id))
13433 else if (unformat (i, "sa_id %d", &sa_id))
13435 else if (unformat (i, "priority %d", &priority))
13437 else if (unformat (i, "protocol %d", &protocol))
13439 else if (unformat (i, "lport_start %d", &lport_start))
13441 else if (unformat (i, "lport_stop %d", &lport_stop))
13443 else if (unformat (i, "rport_start %d", &rport_start))
13445 else if (unformat (i, "rport_stop %d", &rport_stop))
13447 else if (unformat (i, "laddr_start %U",
13448 unformat_vl_api_address, &laddr_start))
13450 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13453 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13456 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13460 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13462 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13464 clib_warning ("unsupported action: 'resolve'");
13470 clib_warning ("parse error '%U'", format_unformat_error, i);
13476 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13478 mp->is_add = is_add;
13480 mp->entry.spd_id = ntohl (spd_id);
13481 mp->entry.priority = ntohl (priority);
13482 mp->entry.is_outbound = is_outbound;
13484 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13485 sizeof (vl_api_address_t));
13486 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13487 sizeof (vl_api_address_t));
13488 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13489 sizeof (vl_api_address_t));
13490 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13491 sizeof (vl_api_address_t));
13493 mp->entry.protocol = (u8) protocol;
13494 mp->entry.local_port_start = ntohs ((u16) lport_start);
13495 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13496 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13497 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13498 mp->entry.policy = (u8) policy;
13499 mp->entry.sa_id = ntohl (sa_id);
13507 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13509 unformat_input_t *i = vam->input;
13510 vl_api_ipsec_sad_entry_add_del_t *mp;
13511 u32 sad_id = 0, spi = 0;
13512 u8 *ck = 0, *ik = 0;
13515 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13516 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13517 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13518 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13519 vl_api_address_t tun_src, tun_dst;
13522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13524 if (unformat (i, "del"))
13526 else if (unformat (i, "sad_id %d", &sad_id))
13528 else if (unformat (i, "spi %d", &spi))
13530 else if (unformat (i, "esp"))
13531 protocol = IPSEC_API_PROTO_ESP;
13533 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13535 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13536 if (ADDRESS_IP6 == tun_src.af)
13537 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13540 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13542 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13543 if (ADDRESS_IP6 == tun_src.af)
13544 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13547 if (unformat (i, "crypto_alg %U",
13548 unformat_ipsec_api_crypto_alg, &crypto_alg))
13550 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13552 else if (unformat (i, "integ_alg %U",
13553 unformat_ipsec_api_integ_alg, &integ_alg))
13555 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13559 clib_warning ("parse error '%U'", format_unformat_error, i);
13565 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13567 mp->is_add = is_add;
13568 mp->entry.sad_id = ntohl (sad_id);
13569 mp->entry.protocol = protocol;
13570 mp->entry.spi = ntohl (spi);
13571 mp->entry.flags = flags;
13573 mp->entry.crypto_algorithm = crypto_alg;
13574 mp->entry.integrity_algorithm = integ_alg;
13575 mp->entry.crypto_key.length = vec_len (ck);
13576 mp->entry.integrity_key.length = vec_len (ik);
13578 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13579 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13581 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13582 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13585 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13587 clib_memcpy (mp->entry.integrity_key.data, ik,
13588 mp->entry.integrity_key.length);
13590 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13592 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13593 sizeof (mp->entry.tunnel_src));
13594 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13595 sizeof (mp->entry.tunnel_dst));
13604 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13606 unformat_input_t *i = vam->input;
13607 vl_api_ipsec_tunnel_if_add_del_t *mp;
13608 u32 local_spi = 0, remote_spi = 0;
13609 u32 crypto_alg = 0, integ_alg = 0;
13610 u8 *lck = NULL, *rck = NULL;
13611 u8 *lik = NULL, *rik = NULL;
13612 vl_api_address_t local_ip = { 0 };
13613 vl_api_address_t remote_ip = { 0 };
13617 u8 anti_replay = 0;
13623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13625 if (unformat (i, "del"))
13627 else if (unformat (i, "esn"))
13629 else if (unformat (i, "anti-replay"))
13631 else if (unformat (i, "count %d", &count))
13633 else if (unformat (i, "local_spi %d", &local_spi))
13635 else if (unformat (i, "remote_spi %d", &remote_spi))
13638 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13641 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13643 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13646 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13648 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13650 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13654 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13656 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13658 errmsg ("unsupported crypto-alg: '%U'\n",
13659 format_ipsec_crypto_alg, crypto_alg);
13665 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13667 if (integ_alg >= IPSEC_INTEG_N_ALG)
13669 errmsg ("unsupported integ-alg: '%U'\n",
13670 format_ipsec_integ_alg, integ_alg);
13674 else if (unformat (i, "instance %u", &instance))
13678 errmsg ("parse error '%U'\n", format_unformat_error, i);
13685 /* Turn on async mode */
13686 vam->async_mode = 1;
13687 vam->async_errors = 0;
13688 before = vat_time_now (vam);
13691 for (jj = 0; jj < count; jj++)
13693 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13695 mp->is_add = is_add;
13697 mp->anti_replay = anti_replay;
13700 increment_address (&remote_ip);
13702 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13703 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13705 mp->local_spi = htonl (local_spi + jj);
13706 mp->remote_spi = htonl (remote_spi + jj);
13707 mp->crypto_alg = (u8) crypto_alg;
13709 mp->local_crypto_key_len = 0;
13712 mp->local_crypto_key_len = vec_len (lck);
13713 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13714 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13715 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13718 mp->remote_crypto_key_len = 0;
13721 mp->remote_crypto_key_len = vec_len (rck);
13722 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13723 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13724 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13727 mp->integ_alg = (u8) integ_alg;
13729 mp->local_integ_key_len = 0;
13732 mp->local_integ_key_len = vec_len (lik);
13733 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13734 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13735 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13738 mp->remote_integ_key_len = 0;
13741 mp->remote_integ_key_len = vec_len (rik);
13742 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13743 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13744 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13749 mp->renumber = renumber;
13750 mp->show_instance = ntohl (instance);
13755 /* When testing multiple add/del ops, use a control-ping to sync */
13758 vl_api_control_ping_t *mp_ping;
13762 /* Shut off async mode */
13763 vam->async_mode = 0;
13765 MPING (CONTROL_PING, mp_ping);
13768 timeout = vat_time_now (vam) + 1.0;
13769 while (vat_time_now (vam) < timeout)
13770 if (vam->result_ready == 1)
13775 if (vam->retval == -99)
13776 errmsg ("timeout");
13778 if (vam->async_errors > 0)
13780 errmsg ("%d asynchronous errors", vam->async_errors);
13783 vam->async_errors = 0;
13784 after = vat_time_now (vam);
13786 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13790 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13791 count, after - before, count / (after - before));
13795 /* Wait for a reply... */
13804 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13806 vat_main_t *vam = &vat_main;
13808 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13809 "crypto_key %U integ_alg %u integ_key %U flags %x "
13810 "tunnel_src_addr %U tunnel_dst_addr %U "
13811 "salt %u seq_outbound %lu last_seq_inbound %lu "
13812 "replay_window %lu\n",
13813 ntohl (mp->entry.sad_id),
13814 ntohl (mp->sw_if_index),
13815 ntohl (mp->entry.spi),
13816 ntohl (mp->entry.protocol),
13817 ntohl (mp->entry.crypto_algorithm),
13818 format_hex_bytes, mp->entry.crypto_key.data,
13819 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13820 format_hex_bytes, mp->entry.integrity_key.data,
13821 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13822 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13823 &mp->entry.tunnel_dst, ntohl (mp->salt),
13824 clib_net_to_host_u64 (mp->seq_outbound),
13825 clib_net_to_host_u64 (mp->last_seq_inbound),
13826 clib_net_to_host_u64 (mp->replay_window));
13829 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13830 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13832 static void vl_api_ipsec_sa_details_t_handler_json
13833 (vl_api_ipsec_sa_details_t * mp)
13835 vat_main_t *vam = &vat_main;
13836 vat_json_node_t *node = NULL;
13837 vl_api_ipsec_sad_flags_t flags;
13839 if (VAT_JSON_ARRAY != vam->json_tree.type)
13841 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13842 vat_json_init_array (&vam->json_tree);
13844 node = vat_json_array_add (&vam->json_tree);
13846 vat_json_init_object (node);
13847 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13848 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13849 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13850 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13851 vat_json_object_add_uint (node, "crypto_alg",
13852 ntohl (mp->entry.crypto_algorithm));
13853 vat_json_object_add_uint (node, "integ_alg",
13854 ntohl (mp->entry.integrity_algorithm));
13855 flags = ntohl (mp->entry.flags);
13856 vat_json_object_add_uint (node, "use_esn",
13857 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13858 vat_json_object_add_uint (node, "use_anti_replay",
13859 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13860 vat_json_object_add_uint (node, "is_tunnel",
13861 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13862 vat_json_object_add_uint (node, "is_tunnel_ip6",
13863 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13864 vat_json_object_add_uint (node, "udp_encap",
13865 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13866 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13867 mp->entry.crypto_key.length);
13868 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13869 mp->entry.integrity_key.length);
13870 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13871 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13872 vat_json_object_add_uint (node, "replay_window",
13873 clib_net_to_host_u64 (mp->replay_window));
13877 api_ipsec_sa_dump (vat_main_t * vam)
13879 unformat_input_t *i = vam->input;
13880 vl_api_ipsec_sa_dump_t *mp;
13881 vl_api_control_ping_t *mp_ping;
13885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13887 if (unformat (i, "sa_id %d", &sa_id))
13891 clib_warning ("parse error '%U'", format_unformat_error, i);
13896 M (IPSEC_SA_DUMP, mp);
13898 mp->sa_id = ntohl (sa_id);
13902 /* Use a control ping for synchronization */
13903 M (CONTROL_PING, mp_ping);
13911 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13913 unformat_input_t *i = vam->input;
13914 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13915 u32 sw_if_index = ~0;
13917 u8 is_outbound = (u8) ~ 0;
13920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13922 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13924 else if (unformat (i, "sa_id %d", &sa_id))
13926 else if (unformat (i, "outbound"))
13928 else if (unformat (i, "inbound"))
13932 clib_warning ("parse error '%U'", format_unformat_error, i);
13937 if (sw_if_index == ~0)
13939 errmsg ("interface must be specified");
13945 errmsg ("SA ID must be specified");
13949 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13951 mp->sw_if_index = htonl (sw_if_index);
13952 mp->sa_id = htonl (sa_id);
13953 mp->is_outbound = is_outbound;
13962 api_get_first_msg_id (vat_main_t * vam)
13964 vl_api_get_first_msg_id_t *mp;
13965 unformat_input_t *i = vam->input;
13970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13972 if (unformat (i, "client %s", &name))
13980 errmsg ("missing client name");
13983 vec_add1 (name, 0);
13985 if (vec_len (name) > 63)
13987 errmsg ("client name too long");
13991 M (GET_FIRST_MSG_ID, mp);
13992 clib_memcpy (mp->name, name, vec_len (name));
13999 api_cop_interface_enable_disable (vat_main_t * vam)
14001 unformat_input_t *line_input = vam->input;
14002 vl_api_cop_interface_enable_disable_t *mp;
14003 u32 sw_if_index = ~0;
14004 u8 enable_disable = 1;
14007 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14009 if (unformat (line_input, "disable"))
14010 enable_disable = 0;
14011 if (unformat (line_input, "enable"))
14012 enable_disable = 1;
14013 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14014 vam, &sw_if_index))
14016 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14022 if (sw_if_index == ~0)
14024 errmsg ("missing interface name or sw_if_index");
14028 /* Construct the API message */
14029 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14030 mp->sw_if_index = ntohl (sw_if_index);
14031 mp->enable_disable = enable_disable;
14035 /* Wait for the reply */
14041 api_cop_whitelist_enable_disable (vat_main_t * vam)
14043 unformat_input_t *line_input = vam->input;
14044 vl_api_cop_whitelist_enable_disable_t *mp;
14045 u32 sw_if_index = ~0;
14046 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14052 if (unformat (line_input, "ip4"))
14054 else if (unformat (line_input, "ip6"))
14056 else if (unformat (line_input, "default"))
14058 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14059 vam, &sw_if_index))
14061 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14063 else if (unformat (line_input, "fib-id %d", &fib_id))
14069 if (sw_if_index == ~0)
14071 errmsg ("missing interface name or sw_if_index");
14075 /* Construct the API message */
14076 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14077 mp->sw_if_index = ntohl (sw_if_index);
14078 mp->fib_id = ntohl (fib_id);
14081 mp->default_cop = default_cop;
14085 /* Wait for the reply */
14091 api_get_node_graph (vat_main_t * vam)
14093 vl_api_get_node_graph_t *mp;
14096 M (GET_NODE_GRAPH, mp);
14100 /* Wait for the reply */
14106 /** Used for parsing LISP eids */
14107 typedef CLIB_PACKED(struct{
14108 u8 addr[16]; /**< eid address */
14109 u32 len; /**< prefix length if IP */
14110 u8 type; /**< type of eid */
14115 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14117 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14119 clib_memset (a, 0, sizeof (a[0]));
14121 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
14123 a->type = 0; /* ipv4 type */
14125 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
14127 a->type = 1; /* ipv6 type */
14129 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
14131 a->type = 2; /* mac type */
14133 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
14135 a->type = 3; /* NSH type */
14136 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
14137 nsh->spi = clib_host_to_net_u32 (nsh->spi);
14144 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
14153 lisp_eid_size_vat (u8 type)
14170 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
14172 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
14176 api_one_add_del_locator_set (vat_main_t * vam)
14178 unformat_input_t *input = vam->input;
14179 vl_api_one_add_del_locator_set_t *mp;
14181 u8 *locator_set_name = NULL;
14182 u8 locator_set_name_set = 0;
14183 vl_api_local_locator_t locator, *locators = 0;
14184 u32 sw_if_index, priority, weight;
14188 /* Parse args required to build the message */
14189 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14191 if (unformat (input, "del"))
14195 else if (unformat (input, "locator-set %s", &locator_set_name))
14197 locator_set_name_set = 1;
14199 else if (unformat (input, "sw_if_index %u p %u w %u",
14200 &sw_if_index, &priority, &weight))
14202 locator.sw_if_index = htonl (sw_if_index);
14203 locator.priority = priority;
14204 locator.weight = weight;
14205 vec_add1 (locators, locator);
14209 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14210 &sw_if_index, &priority, &weight))
14212 locator.sw_if_index = htonl (sw_if_index);
14213 locator.priority = priority;
14214 locator.weight = weight;
14215 vec_add1 (locators, locator);
14221 if (locator_set_name_set == 0)
14223 errmsg ("missing locator-set name");
14224 vec_free (locators);
14228 if (vec_len (locator_set_name) > 64)
14230 errmsg ("locator-set name too long");
14231 vec_free (locator_set_name);
14232 vec_free (locators);
14235 vec_add1 (locator_set_name, 0);
14237 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14239 /* Construct the API message */
14240 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14242 mp->is_add = is_add;
14243 clib_memcpy (mp->locator_set_name, locator_set_name,
14244 vec_len (locator_set_name));
14245 vec_free (locator_set_name);
14247 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14249 clib_memcpy (mp->locators, locators, data_len);
14250 vec_free (locators);
14255 /* Wait for a reply... */
14260 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14263 api_one_add_del_locator (vat_main_t * vam)
14265 unformat_input_t *input = vam->input;
14266 vl_api_one_add_del_locator_t *mp;
14267 u32 tmp_if_index = ~0;
14268 u32 sw_if_index = ~0;
14269 u8 sw_if_index_set = 0;
14270 u8 sw_if_index_if_name_set = 0;
14272 u8 priority_set = 0;
14276 u8 *locator_set_name = NULL;
14277 u8 locator_set_name_set = 0;
14280 /* Parse args required to build the message */
14281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14283 if (unformat (input, "del"))
14287 else if (unformat (input, "locator-set %s", &locator_set_name))
14289 locator_set_name_set = 1;
14291 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14294 sw_if_index_if_name_set = 1;
14295 sw_if_index = tmp_if_index;
14297 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14299 sw_if_index_set = 1;
14300 sw_if_index = tmp_if_index;
14302 else if (unformat (input, "p %d", &priority))
14306 else if (unformat (input, "w %d", &weight))
14314 if (locator_set_name_set == 0)
14316 errmsg ("missing locator-set name");
14320 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14322 errmsg ("missing sw_if_index");
14323 vec_free (locator_set_name);
14327 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14329 errmsg ("cannot use both params interface name and sw_if_index");
14330 vec_free (locator_set_name);
14334 if (priority_set == 0)
14336 errmsg ("missing locator-set priority");
14337 vec_free (locator_set_name);
14341 if (weight_set == 0)
14343 errmsg ("missing locator-set weight");
14344 vec_free (locator_set_name);
14348 if (vec_len (locator_set_name) > 64)
14350 errmsg ("locator-set name too long");
14351 vec_free (locator_set_name);
14354 vec_add1 (locator_set_name, 0);
14356 /* Construct the API message */
14357 M (ONE_ADD_DEL_LOCATOR, mp);
14359 mp->is_add = is_add;
14360 mp->sw_if_index = ntohl (sw_if_index);
14361 mp->priority = priority;
14362 mp->weight = weight;
14363 clib_memcpy (mp->locator_set_name, locator_set_name,
14364 vec_len (locator_set_name));
14365 vec_free (locator_set_name);
14370 /* Wait for a reply... */
14375 #define api_lisp_add_del_locator api_one_add_del_locator
14378 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14380 u32 *key_id = va_arg (*args, u32 *);
14383 if (unformat (input, "%s", &s))
14385 if (!strcmp ((char *) s, "sha1"))
14386 key_id[0] = HMAC_SHA_1_96;
14387 else if (!strcmp ((char *) s, "sha256"))
14388 key_id[0] = HMAC_SHA_256_128;
14391 clib_warning ("invalid key_id: '%s'", s);
14392 key_id[0] = HMAC_NO_KEY;
14403 api_one_add_del_local_eid (vat_main_t * vam)
14405 unformat_input_t *input = vam->input;
14406 vl_api_one_add_del_local_eid_t *mp;
14409 lisp_eid_vat_t _eid, *eid = &_eid;
14410 u8 *locator_set_name = 0;
14411 u8 locator_set_name_set = 0;
14417 /* Parse args required to build the message */
14418 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14420 if (unformat (input, "del"))
14424 else if (unformat (input, "vni %d", &vni))
14428 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14432 else if (unformat (input, "locator-set %s", &locator_set_name))
14434 locator_set_name_set = 1;
14436 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14438 else if (unformat (input, "secret-key %_%v%_", &key))
14444 if (locator_set_name_set == 0)
14446 errmsg ("missing locator-set name");
14452 errmsg ("EID address not set!");
14453 vec_free (locator_set_name);
14457 if (key && (0 == key_id))
14459 errmsg ("invalid key_id!");
14463 if (vec_len (key) > 64)
14465 errmsg ("key too long");
14470 if (vec_len (locator_set_name) > 64)
14472 errmsg ("locator-set name too long");
14473 vec_free (locator_set_name);
14476 vec_add1 (locator_set_name, 0);
14478 /* Construct the API message */
14479 M (ONE_ADD_DEL_LOCAL_EID, mp);
14481 mp->is_add = is_add;
14482 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14483 mp->eid_type = eid->type;
14484 mp->prefix_len = eid->len;
14485 mp->vni = clib_host_to_net_u32 (vni);
14486 mp->key_id = clib_host_to_net_u16 (key_id);
14487 clib_memcpy (mp->locator_set_name, locator_set_name,
14488 vec_len (locator_set_name));
14489 clib_memcpy (mp->key, key, vec_len (key));
14491 vec_free (locator_set_name);
14497 /* Wait for a reply... */
14502 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14505 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14507 u32 dp_table = 0, vni = 0;;
14508 unformat_input_t *input = vam->input;
14509 vl_api_gpe_add_del_fwd_entry_t *mp;
14511 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14512 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14513 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14514 u32 action = ~0, w;
14515 ip4_address_t rmt_rloc4, lcl_rloc4;
14516 ip6_address_t rmt_rloc6, lcl_rloc6;
14517 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14520 clib_memset (&rloc, 0, sizeof (rloc));
14522 /* Parse args required to build the message */
14523 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14525 if (unformat (input, "del"))
14527 else if (unformat (input, "add"))
14529 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14533 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14537 else if (unformat (input, "vrf %d", &dp_table))
14539 else if (unformat (input, "bd %d", &dp_table))
14541 else if (unformat (input, "vni %d", &vni))
14543 else if (unformat (input, "w %d", &w))
14547 errmsg ("No RLOC configured for setting priority/weight!");
14550 curr_rloc->weight = w;
14552 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14553 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14557 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
14559 vec_add1 (lcl_locs, rloc);
14561 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
14562 vec_add1 (rmt_locs, rloc);
14563 /* weight saved in rmt loc */
14564 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14566 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14567 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14570 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
14572 vec_add1 (lcl_locs, rloc);
14574 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
14575 vec_add1 (rmt_locs, rloc);
14576 /* weight saved in rmt loc */
14577 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14579 else if (unformat (input, "action %d", &action))
14585 clib_warning ("parse error '%U'", format_unformat_error, input);
14592 errmsg ("remote eid addresses not set");
14596 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14598 errmsg ("eid types don't match");
14602 if (0 == rmt_locs && (u32) ~ 0 == action)
14604 errmsg ("action not set for negative mapping");
14608 /* Construct the API message */
14609 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14610 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14612 mp->is_add = is_add;
14613 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14614 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14615 mp->eid_type = rmt_eid->type;
14616 mp->dp_table = clib_host_to_net_u32 (dp_table);
14617 mp->vni = clib_host_to_net_u32 (vni);
14618 mp->rmt_len = rmt_eid->len;
14619 mp->lcl_len = lcl_eid->len;
14620 mp->action = action;
14622 if (0 != rmt_locs && 0 != lcl_locs)
14624 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14625 clib_memcpy (mp->locs, lcl_locs,
14626 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14628 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14629 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14630 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14632 vec_free (lcl_locs);
14633 vec_free (rmt_locs);
14638 /* Wait for a reply... */
14644 api_one_add_del_map_server (vat_main_t * vam)
14646 unformat_input_t *input = vam->input;
14647 vl_api_one_add_del_map_server_t *mp;
14651 ip4_address_t ipv4;
14652 ip6_address_t ipv6;
14655 /* Parse args required to build the message */
14656 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14658 if (unformat (input, "del"))
14662 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14666 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14674 if (ipv4_set && ipv6_set)
14676 errmsg ("both eid v4 and v6 addresses set");
14680 if (!ipv4_set && !ipv6_set)
14682 errmsg ("eid addresses not set");
14686 /* Construct the API message */
14687 M (ONE_ADD_DEL_MAP_SERVER, mp);
14689 mp->is_add = is_add;
14693 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14698 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14704 /* Wait for a reply... */
14709 #define api_lisp_add_del_map_server api_one_add_del_map_server
14712 api_one_add_del_map_resolver (vat_main_t * vam)
14714 unformat_input_t *input = vam->input;
14715 vl_api_one_add_del_map_resolver_t *mp;
14719 ip4_address_t ipv4;
14720 ip6_address_t ipv6;
14723 /* Parse args required to build the message */
14724 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14726 if (unformat (input, "del"))
14730 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14734 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14742 if (ipv4_set && ipv6_set)
14744 errmsg ("both eid v4 and v6 addresses set");
14748 if (!ipv4_set && !ipv6_set)
14750 errmsg ("eid addresses not set");
14754 /* Construct the API message */
14755 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14757 mp->is_add = is_add;
14761 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14766 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14772 /* Wait for a reply... */
14777 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14780 api_lisp_gpe_enable_disable (vat_main_t * vam)
14782 unformat_input_t *input = vam->input;
14783 vl_api_gpe_enable_disable_t *mp;
14788 /* Parse args required to build the message */
14789 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14791 if (unformat (input, "enable"))
14796 else if (unformat (input, "disable"))
14807 errmsg ("Value not set");
14811 /* Construct the API message */
14812 M (GPE_ENABLE_DISABLE, mp);
14819 /* Wait for a reply... */
14825 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14827 unformat_input_t *input = vam->input;
14828 vl_api_one_rloc_probe_enable_disable_t *mp;
14833 /* Parse args required to build the message */
14834 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14836 if (unformat (input, "enable"))
14841 else if (unformat (input, "disable"))
14849 errmsg ("Value not set");
14853 /* Construct the API message */
14854 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14856 mp->is_enabled = is_en;
14861 /* Wait for a reply... */
14866 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14869 api_one_map_register_enable_disable (vat_main_t * vam)
14871 unformat_input_t *input = vam->input;
14872 vl_api_one_map_register_enable_disable_t *mp;
14877 /* Parse args required to build the message */
14878 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14880 if (unformat (input, "enable"))
14885 else if (unformat (input, "disable"))
14893 errmsg ("Value not set");
14897 /* Construct the API message */
14898 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14900 mp->is_enabled = is_en;
14905 /* Wait for a reply... */
14910 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14913 api_one_enable_disable (vat_main_t * vam)
14915 unformat_input_t *input = vam->input;
14916 vl_api_one_enable_disable_t *mp;
14921 /* Parse args required to build the message */
14922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14924 if (unformat (input, "enable"))
14929 else if (unformat (input, "disable"))
14939 errmsg ("Value not set");
14943 /* Construct the API message */
14944 M (ONE_ENABLE_DISABLE, mp);
14951 /* Wait for a reply... */
14956 #define api_lisp_enable_disable api_one_enable_disable
14959 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14961 unformat_input_t *input = vam->input;
14962 vl_api_one_enable_disable_xtr_mode_t *mp;
14967 /* Parse args required to build the message */
14968 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14970 if (unformat (input, "enable"))
14975 else if (unformat (input, "disable"))
14985 errmsg ("Value not set");
14989 /* Construct the API message */
14990 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
14997 /* Wait for a reply... */
15003 api_one_show_xtr_mode (vat_main_t * vam)
15005 vl_api_one_show_xtr_mode_t *mp;
15008 /* Construct the API message */
15009 M (ONE_SHOW_XTR_MODE, mp);
15014 /* Wait for a reply... */
15020 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15022 unformat_input_t *input = vam->input;
15023 vl_api_one_enable_disable_pitr_mode_t *mp;
15028 /* Parse args required to build the message */
15029 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15031 if (unformat (input, "enable"))
15036 else if (unformat (input, "disable"))
15046 errmsg ("Value not set");
15050 /* Construct the API message */
15051 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15058 /* Wait for a reply... */
15064 api_one_show_pitr_mode (vat_main_t * vam)
15066 vl_api_one_show_pitr_mode_t *mp;
15069 /* Construct the API message */
15070 M (ONE_SHOW_PITR_MODE, mp);
15075 /* Wait for a reply... */
15081 api_one_enable_disable_petr_mode (vat_main_t * vam)
15083 unformat_input_t *input = vam->input;
15084 vl_api_one_enable_disable_petr_mode_t *mp;
15089 /* Parse args required to build the message */
15090 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15092 if (unformat (input, "enable"))
15097 else if (unformat (input, "disable"))
15107 errmsg ("Value not set");
15111 /* Construct the API message */
15112 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15119 /* Wait for a reply... */
15125 api_one_show_petr_mode (vat_main_t * vam)
15127 vl_api_one_show_petr_mode_t *mp;
15130 /* Construct the API message */
15131 M (ONE_SHOW_PETR_MODE, mp);
15136 /* Wait for a reply... */
15142 api_show_one_map_register_state (vat_main_t * vam)
15144 vl_api_show_one_map_register_state_t *mp;
15147 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15152 /* wait for reply */
15157 #define api_show_lisp_map_register_state api_show_one_map_register_state
15160 api_show_one_rloc_probe_state (vat_main_t * vam)
15162 vl_api_show_one_rloc_probe_state_t *mp;
15165 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15170 /* wait for reply */
15175 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15178 api_one_add_del_ndp_entry (vat_main_t * vam)
15180 vl_api_one_add_del_ndp_entry_t *mp;
15181 unformat_input_t *input = vam->input;
15186 u8 mac[6] = { 0, };
15187 u8 ip6[16] = { 0, };
15191 /* Parse args required to build the message */
15192 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15194 if (unformat (input, "del"))
15196 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15198 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15200 else if (unformat (input, "bd %d", &bd))
15204 errmsg ("parse error '%U'", format_unformat_error, input);
15209 if (!bd_set || !ip_set || (!mac_set && is_add))
15211 errmsg ("Missing BD, IP or MAC!");
15215 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15216 mp->is_add = is_add;
15217 clib_memcpy (mp->mac, mac, 6);
15218 mp->bd = clib_host_to_net_u32 (bd);
15219 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
15224 /* wait for reply */
15230 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15232 vl_api_one_add_del_l2_arp_entry_t *mp;
15233 unformat_input_t *input = vam->input;
15238 u8 mac[6] = { 0, };
15239 u32 ip4 = 0, bd = ~0;
15242 /* Parse args required to build the message */
15243 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15245 if (unformat (input, "del"))
15247 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15249 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15251 else if (unformat (input, "bd %d", &bd))
15255 errmsg ("parse error '%U'", format_unformat_error, input);
15260 if (!bd_set || !ip_set || (!mac_set && is_add))
15262 errmsg ("Missing BD, IP or MAC!");
15266 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15267 mp->is_add = is_add;
15268 clib_memcpy (mp->mac, mac, 6);
15269 mp->bd = clib_host_to_net_u32 (bd);
15275 /* wait for reply */
15281 api_one_ndp_bd_get (vat_main_t * vam)
15283 vl_api_one_ndp_bd_get_t *mp;
15286 M (ONE_NDP_BD_GET, mp);
15291 /* wait for reply */
15297 api_one_ndp_entries_get (vat_main_t * vam)
15299 vl_api_one_ndp_entries_get_t *mp;
15300 unformat_input_t *input = vam->input;
15305 /* Parse args required to build the message */
15306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15308 if (unformat (input, "bd %d", &bd))
15312 errmsg ("parse error '%U'", format_unformat_error, input);
15319 errmsg ("Expected bridge domain!");
15323 M (ONE_NDP_ENTRIES_GET, mp);
15324 mp->bd = clib_host_to_net_u32 (bd);
15329 /* wait for reply */
15335 api_one_l2_arp_bd_get (vat_main_t * vam)
15337 vl_api_one_l2_arp_bd_get_t *mp;
15340 M (ONE_L2_ARP_BD_GET, mp);
15345 /* wait for reply */
15351 api_one_l2_arp_entries_get (vat_main_t * vam)
15353 vl_api_one_l2_arp_entries_get_t *mp;
15354 unformat_input_t *input = vam->input;
15359 /* Parse args required to build the message */
15360 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15362 if (unformat (input, "bd %d", &bd))
15366 errmsg ("parse error '%U'", format_unformat_error, input);
15373 errmsg ("Expected bridge domain!");
15377 M (ONE_L2_ARP_ENTRIES_GET, mp);
15378 mp->bd = clib_host_to_net_u32 (bd);
15383 /* wait for reply */
15389 api_one_stats_enable_disable (vat_main_t * vam)
15391 vl_api_one_stats_enable_disable_t *mp;
15392 unformat_input_t *input = vam->input;
15397 /* Parse args required to build the message */
15398 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15400 if (unformat (input, "enable"))
15405 else if (unformat (input, "disable"))
15415 errmsg ("Value not set");
15419 M (ONE_STATS_ENABLE_DISABLE, mp);
15425 /* wait for reply */
15431 api_show_one_stats_enable_disable (vat_main_t * vam)
15433 vl_api_show_one_stats_enable_disable_t *mp;
15436 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15441 /* wait for reply */
15447 api_show_one_map_request_mode (vat_main_t * vam)
15449 vl_api_show_one_map_request_mode_t *mp;
15452 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15457 /* wait for reply */
15462 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15465 api_one_map_request_mode (vat_main_t * vam)
15467 unformat_input_t *input = vam->input;
15468 vl_api_one_map_request_mode_t *mp;
15472 /* Parse args required to build the message */
15473 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15475 if (unformat (input, "dst-only"))
15477 else if (unformat (input, "src-dst"))
15481 errmsg ("parse error '%U'", format_unformat_error, input);
15486 M (ONE_MAP_REQUEST_MODE, mp);
15493 /* wait for reply */
15498 #define api_lisp_map_request_mode api_one_map_request_mode
15501 * Enable/disable ONE proxy ITR.
15503 * @param vam vpp API test context
15504 * @return return code
15507 api_one_pitr_set_locator_set (vat_main_t * vam)
15509 u8 ls_name_set = 0;
15510 unformat_input_t *input = vam->input;
15511 vl_api_one_pitr_set_locator_set_t *mp;
15516 /* Parse args required to build the message */
15517 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15519 if (unformat (input, "del"))
15521 else if (unformat (input, "locator-set %s", &ls_name))
15525 errmsg ("parse error '%U'", format_unformat_error, input);
15532 errmsg ("locator-set name not set!");
15536 M (ONE_PITR_SET_LOCATOR_SET, mp);
15538 mp->is_add = is_add;
15539 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15540 vec_free (ls_name);
15545 /* wait for reply */
15550 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15553 api_one_nsh_set_locator_set (vat_main_t * vam)
15555 u8 ls_name_set = 0;
15556 unformat_input_t *input = vam->input;
15557 vl_api_one_nsh_set_locator_set_t *mp;
15562 /* Parse args required to build the message */
15563 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15565 if (unformat (input, "del"))
15567 else if (unformat (input, "ls %s", &ls_name))
15571 errmsg ("parse error '%U'", format_unformat_error, input);
15576 if (!ls_name_set && is_add)
15578 errmsg ("locator-set name not set!");
15582 M (ONE_NSH_SET_LOCATOR_SET, mp);
15584 mp->is_add = is_add;
15585 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15586 vec_free (ls_name);
15591 /* wait for reply */
15597 api_show_one_pitr (vat_main_t * vam)
15599 vl_api_show_one_pitr_t *mp;
15602 if (!vam->json_output)
15604 print (vam->ofp, "%=20s", "lisp status:");
15607 M (SHOW_ONE_PITR, mp);
15611 /* Wait for a reply... */
15616 #define api_show_lisp_pitr api_show_one_pitr
15619 api_one_use_petr (vat_main_t * vam)
15621 unformat_input_t *input = vam->input;
15622 vl_api_one_use_petr_t *mp;
15627 clib_memset (&ip, 0, sizeof (ip));
15629 /* Parse args required to build the message */
15630 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15632 if (unformat (input, "disable"))
15635 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15638 ip_addr_version (&ip) = AF_IP4;
15641 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15644 ip_addr_version (&ip) = AF_IP6;
15648 errmsg ("parse error '%U'", format_unformat_error, input);
15653 M (ONE_USE_PETR, mp);
15655 mp->is_add = is_add;
15658 mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
15660 clib_memcpy (mp->address, &ip, 4);
15662 clib_memcpy (mp->address, &ip, 16);
15668 /* wait for reply */
15673 #define api_lisp_use_petr api_one_use_petr
15676 api_show_one_nsh_mapping (vat_main_t * vam)
15678 vl_api_show_one_use_petr_t *mp;
15681 if (!vam->json_output)
15683 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15686 M (SHOW_ONE_NSH_MAPPING, mp);
15690 /* Wait for a reply... */
15696 api_show_one_use_petr (vat_main_t * vam)
15698 vl_api_show_one_use_petr_t *mp;
15701 if (!vam->json_output)
15703 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15706 M (SHOW_ONE_USE_PETR, mp);
15710 /* Wait for a reply... */
15715 #define api_show_lisp_use_petr api_show_one_use_petr
15718 * Add/delete mapping between vni and vrf
15721 api_one_eid_table_add_del_map (vat_main_t * vam)
15723 unformat_input_t *input = vam->input;
15724 vl_api_one_eid_table_add_del_map_t *mp;
15725 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15726 u32 vni, vrf, bd_index;
15729 /* Parse args required to build the message */
15730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15732 if (unformat (input, "del"))
15734 else if (unformat (input, "vrf %d", &vrf))
15736 else if (unformat (input, "bd_index %d", &bd_index))
15738 else if (unformat (input, "vni %d", &vni))
15744 if (!vni_set || (!vrf_set && !bd_index_set))
15746 errmsg ("missing arguments!");
15750 if (vrf_set && bd_index_set)
15752 errmsg ("error: both vrf and bd entered!");
15756 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15758 mp->is_add = is_add;
15759 mp->vni = htonl (vni);
15760 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15761 mp->is_l2 = bd_index_set;
15766 /* wait for reply */
15771 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15774 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15776 u32 *action = va_arg (*args, u32 *);
15779 if (unformat (input, "%s", &s))
15781 if (!strcmp ((char *) s, "no-action"))
15783 else if (!strcmp ((char *) s, "natively-forward"))
15785 else if (!strcmp ((char *) s, "send-map-request"))
15787 else if (!strcmp ((char *) s, "drop"))
15791 clib_warning ("invalid action: '%s'", s);
15803 * Add/del remote mapping to/from ONE control plane
15805 * @param vam vpp API test context
15806 * @return return code
15809 api_one_add_del_remote_mapping (vat_main_t * vam)
15811 unformat_input_t *input = vam->input;
15812 vl_api_one_add_del_remote_mapping_t *mp;
15814 lisp_eid_vat_t _eid, *eid = &_eid;
15815 lisp_eid_vat_t _seid, *seid = &_seid;
15816 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15817 u32 action = ~0, p, w, data_len;
15818 ip4_address_t rloc4;
15819 ip6_address_t rloc6;
15820 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15823 clib_memset (&rloc, 0, sizeof (rloc));
15825 /* Parse args required to build the message */
15826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15828 if (unformat (input, "del-all"))
15832 else if (unformat (input, "del"))
15836 else if (unformat (input, "add"))
15840 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15844 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15848 else if (unformat (input, "vni %d", &vni))
15852 else if (unformat (input, "p %d w %d", &p, &w))
15856 errmsg ("No RLOC configured for setting priority/weight!");
15859 curr_rloc->priority = p;
15860 curr_rloc->weight = w;
15862 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15865 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
15866 vec_add1 (rlocs, rloc);
15867 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15869 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15872 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
15873 vec_add1 (rlocs, rloc);
15874 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15876 else if (unformat (input, "action %U",
15877 unformat_negative_mapping_action, &action))
15883 clib_warning ("parse error '%U'", format_unformat_error, input);
15890 errmsg ("missing params!");
15894 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15896 errmsg ("no action set for negative map-reply!");
15900 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15902 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15903 mp->is_add = is_add;
15904 mp->vni = htonl (vni);
15905 mp->action = (u8) action;
15906 mp->is_src_dst = seid_set;
15907 mp->eid_len = eid->len;
15908 mp->seid_len = seid->len;
15909 mp->del_all = del_all;
15910 mp->eid_type = eid->type;
15911 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15912 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
15914 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15915 clib_memcpy (mp->rlocs, rlocs, data_len);
15921 /* Wait for a reply... */
15926 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15929 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15930 * forwarding entries in data-plane accordingly.
15932 * @param vam vpp API test context
15933 * @return return code
15936 api_one_add_del_adjacency (vat_main_t * vam)
15938 unformat_input_t *input = vam->input;
15939 vl_api_one_add_del_adjacency_t *mp;
15941 ip4_address_t leid4, reid4;
15942 ip6_address_t leid6, reid6;
15943 u8 reid_mac[6] = { 0 };
15944 u8 leid_mac[6] = { 0 };
15945 u8 reid_type, leid_type;
15946 u32 leid_len = 0, reid_len = 0, len;
15950 leid_type = reid_type = (u8) ~ 0;
15952 /* Parse args required to build the message */
15953 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15955 if (unformat (input, "del"))
15959 else if (unformat (input, "add"))
15963 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
15966 reid_type = 0; /* ipv4 */
15969 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
15972 reid_type = 1; /* ipv6 */
15975 else if (unformat (input, "reid %U", unformat_ethernet_address,
15978 reid_type = 2; /* mac */
15980 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
15983 leid_type = 0; /* ipv4 */
15986 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
15989 leid_type = 1; /* ipv6 */
15992 else if (unformat (input, "leid %U", unformat_ethernet_address,
15995 leid_type = 2; /* mac */
15997 else if (unformat (input, "vni %d", &vni))
16003 errmsg ("parse error '%U'", format_unformat_error, input);
16008 if ((u8) ~ 0 == reid_type)
16010 errmsg ("missing params!");
16014 if (leid_type != reid_type)
16016 errmsg ("remote and local EIDs are of different types!");
16020 M (ONE_ADD_DEL_ADJACENCY, mp);
16021 mp->is_add = is_add;
16022 mp->vni = htonl (vni);
16023 mp->leid_len = leid_len;
16024 mp->reid_len = reid_len;
16025 mp->eid_type = reid_type;
16027 switch (mp->eid_type)
16030 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
16031 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
16034 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
16035 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
16038 clib_memcpy (mp->leid, leid_mac, 6);
16039 clib_memcpy (mp->reid, reid_mac, 6);
16042 errmsg ("unknown EID type %d!", mp->eid_type);
16049 /* Wait for a reply... */
16054 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16057 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16059 u32 *mode = va_arg (*args, u32 *);
16061 if (unformat (input, "lisp"))
16063 else if (unformat (input, "vxlan"))
16072 api_gpe_get_encap_mode (vat_main_t * vam)
16074 vl_api_gpe_get_encap_mode_t *mp;
16077 /* Construct the API message */
16078 M (GPE_GET_ENCAP_MODE, mp);
16083 /* Wait for a reply... */
16089 api_gpe_set_encap_mode (vat_main_t * vam)
16091 unformat_input_t *input = vam->input;
16092 vl_api_gpe_set_encap_mode_t *mp;
16096 /* Parse args required to build the message */
16097 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16099 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16105 /* Construct the API message */
16106 M (GPE_SET_ENCAP_MODE, mp);
16113 /* Wait for a reply... */
16119 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16121 unformat_input_t *input = vam->input;
16122 vl_api_gpe_add_del_iface_t *mp;
16123 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16124 u32 dp_table = 0, vni = 0;
16127 /* Parse args required to build the message */
16128 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16130 if (unformat (input, "up"))
16135 else if (unformat (input, "down"))
16140 else if (unformat (input, "table_id %d", &dp_table))
16144 else if (unformat (input, "bd_id %d", &dp_table))
16149 else if (unformat (input, "vni %d", &vni))
16157 if (action_set == 0)
16159 errmsg ("Action not set");
16162 if (dp_table_set == 0 || vni_set == 0)
16164 errmsg ("vni and dp_table must be set");
16168 /* Construct the API message */
16169 M (GPE_ADD_DEL_IFACE, mp);
16171 mp->is_add = is_add;
16172 mp->dp_table = clib_host_to_net_u32 (dp_table);
16174 mp->vni = clib_host_to_net_u32 (vni);
16179 /* Wait for a reply... */
16185 api_one_map_register_fallback_threshold (vat_main_t * vam)
16187 unformat_input_t *input = vam->input;
16188 vl_api_one_map_register_fallback_threshold_t *mp;
16193 /* Parse args required to build the message */
16194 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16196 if (unformat (input, "%u", &value))
16200 clib_warning ("parse error '%U'", format_unformat_error, input);
16207 errmsg ("fallback threshold value is missing!");
16211 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16212 mp->value = clib_host_to_net_u32 (value);
16217 /* Wait for a reply... */
16223 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16225 vl_api_show_one_map_register_fallback_threshold_t *mp;
16228 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16233 /* Wait for a reply... */
16239 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16241 u32 *proto = va_arg (*args, u32 *);
16243 if (unformat (input, "udp"))
16245 else if (unformat (input, "api"))
16254 api_one_set_transport_protocol (vat_main_t * vam)
16256 unformat_input_t *input = vam->input;
16257 vl_api_one_set_transport_protocol_t *mp;
16262 /* Parse args required to build the message */
16263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16265 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16269 clib_warning ("parse error '%U'", format_unformat_error, input);
16276 errmsg ("Transport protocol missing!");
16280 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16281 mp->protocol = (u8) protocol;
16286 /* Wait for a reply... */
16292 api_one_get_transport_protocol (vat_main_t * vam)
16294 vl_api_one_get_transport_protocol_t *mp;
16297 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16302 /* Wait for a reply... */
16308 api_one_map_register_set_ttl (vat_main_t * vam)
16310 unformat_input_t *input = vam->input;
16311 vl_api_one_map_register_set_ttl_t *mp;
16316 /* Parse args required to build the message */
16317 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16319 if (unformat (input, "%u", &ttl))
16323 clib_warning ("parse error '%U'", format_unformat_error, input);
16330 errmsg ("TTL value missing!");
16334 M (ONE_MAP_REGISTER_SET_TTL, mp);
16335 mp->ttl = clib_host_to_net_u32 (ttl);
16340 /* Wait for a reply... */
16346 api_show_one_map_register_ttl (vat_main_t * vam)
16348 vl_api_show_one_map_register_ttl_t *mp;
16351 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16356 /* Wait for a reply... */
16362 * Add/del map request itr rlocs from ONE control plane and updates
16364 * @param vam vpp API test context
16365 * @return return code
16368 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16370 unformat_input_t *input = vam->input;
16371 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16372 u8 *locator_set_name = 0;
16373 u8 locator_set_name_set = 0;
16377 /* Parse args required to build the message */
16378 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16380 if (unformat (input, "del"))
16384 else if (unformat (input, "%_%v%_", &locator_set_name))
16386 locator_set_name_set = 1;
16390 clib_warning ("parse error '%U'", format_unformat_error, input);
16395 if (is_add && !locator_set_name_set)
16397 errmsg ("itr-rloc is not set!");
16401 if (is_add && vec_len (locator_set_name) > 64)
16403 errmsg ("itr-rloc locator-set name too long");
16404 vec_free (locator_set_name);
16408 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16409 mp->is_add = is_add;
16412 clib_memcpy (mp->locator_set_name, locator_set_name,
16413 vec_len (locator_set_name));
16417 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16419 vec_free (locator_set_name);
16424 /* Wait for a reply... */
16429 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16432 api_one_locator_dump (vat_main_t * vam)
16434 unformat_input_t *input = vam->input;
16435 vl_api_one_locator_dump_t *mp;
16436 vl_api_control_ping_t *mp_ping;
16437 u8 is_index_set = 0, is_name_set = 0;
16442 /* Parse args required to build the message */
16443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16445 if (unformat (input, "ls_name %_%v%_", &ls_name))
16449 else if (unformat (input, "ls_index %d", &ls_index))
16455 errmsg ("parse error '%U'", format_unformat_error, input);
16460 if (!is_index_set && !is_name_set)
16462 errmsg ("error: expected one of index or name!");
16466 if (is_index_set && is_name_set)
16468 errmsg ("error: only one param expected!");
16472 if (vec_len (ls_name) > 62)
16474 errmsg ("error: locator set name too long!");
16478 if (!vam->json_output)
16480 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16483 M (ONE_LOCATOR_DUMP, mp);
16484 mp->is_index_set = is_index_set;
16487 mp->ls_index = clib_host_to_net_u32 (ls_index);
16490 vec_add1 (ls_name, 0);
16491 strncpy ((char *) mp->ls_name, (char *) ls_name,
16492 sizeof (mp->ls_name) - 1);
16498 /* Use a control ping for synchronization */
16499 MPING (CONTROL_PING, mp_ping);
16502 /* Wait for a reply... */
16507 #define api_lisp_locator_dump api_one_locator_dump
16510 api_one_locator_set_dump (vat_main_t * vam)
16512 vl_api_one_locator_set_dump_t *mp;
16513 vl_api_control_ping_t *mp_ping;
16514 unformat_input_t *input = vam->input;
16518 /* Parse args required to build the message */
16519 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16521 if (unformat (input, "local"))
16525 else if (unformat (input, "remote"))
16531 errmsg ("parse error '%U'", format_unformat_error, input);
16536 if (!vam->json_output)
16538 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16541 M (ONE_LOCATOR_SET_DUMP, mp);
16543 mp->filter = filter;
16548 /* Use a control ping for synchronization */
16549 MPING (CONTROL_PING, mp_ping);
16552 /* Wait for a reply... */
16557 #define api_lisp_locator_set_dump api_one_locator_set_dump
16560 api_one_eid_table_map_dump (vat_main_t * vam)
16564 unformat_input_t *input = vam->input;
16565 vl_api_one_eid_table_map_dump_t *mp;
16566 vl_api_control_ping_t *mp_ping;
16569 /* Parse args required to build the message */
16570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16572 if (unformat (input, "l2"))
16577 else if (unformat (input, "l3"))
16584 errmsg ("parse error '%U'", format_unformat_error, input);
16591 errmsg ("expected one of 'l2' or 'l3' parameter!");
16595 if (!vam->json_output)
16597 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16600 M (ONE_EID_TABLE_MAP_DUMP, mp);
16606 /* Use a control ping for synchronization */
16607 MPING (CONTROL_PING, mp_ping);
16610 /* Wait for a reply... */
16615 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16618 api_one_eid_table_vni_dump (vat_main_t * vam)
16620 vl_api_one_eid_table_vni_dump_t *mp;
16621 vl_api_control_ping_t *mp_ping;
16624 if (!vam->json_output)
16626 print (vam->ofp, "VNI");
16629 M (ONE_EID_TABLE_VNI_DUMP, mp);
16634 /* Use a control ping for synchronization */
16635 MPING (CONTROL_PING, mp_ping);
16638 /* Wait for a reply... */
16643 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16646 api_one_eid_table_dump (vat_main_t * vam)
16648 unformat_input_t *i = vam->input;
16649 vl_api_one_eid_table_dump_t *mp;
16650 vl_api_control_ping_t *mp_ping;
16651 struct in_addr ip4;
16652 struct in6_addr ip6;
16654 u8 eid_type = ~0, eid_set = 0;
16655 u32 prefix_length = ~0, t, vni = 0;
16658 lisp_nsh_api_t nsh;
16660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16662 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
16668 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
16674 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
16679 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
16684 else if (unformat (i, "vni %d", &t))
16688 else if (unformat (i, "local"))
16692 else if (unformat (i, "remote"))
16698 errmsg ("parse error '%U'", format_unformat_error, i);
16703 if (!vam->json_output)
16705 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16706 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16709 M (ONE_EID_TABLE_DUMP, mp);
16711 mp->filter = filter;
16715 mp->vni = htonl (vni);
16716 mp->eid_type = eid_type;
16720 mp->prefix_length = prefix_length;
16721 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
16724 mp->prefix_length = prefix_length;
16725 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
16728 clib_memcpy (mp->eid, mac, sizeof (mac));
16731 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
16734 errmsg ("unknown EID type %d!", eid_type);
16742 /* Use a control ping for synchronization */
16743 MPING (CONTROL_PING, mp_ping);
16746 /* Wait for a reply... */
16751 #define api_lisp_eid_table_dump api_one_eid_table_dump
16754 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16756 unformat_input_t *i = vam->input;
16757 vl_api_gpe_fwd_entries_get_t *mp;
16762 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16764 if (unformat (i, "vni %d", &vni))
16770 errmsg ("parse error '%U'", format_unformat_error, i);
16777 errmsg ("vni not set!");
16781 if (!vam->json_output)
16783 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16787 M (GPE_FWD_ENTRIES_GET, mp);
16788 mp->vni = clib_host_to_net_u32 (vni);
16793 /* Wait for a reply... */
16798 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16799 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16800 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16801 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16802 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16803 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16804 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16805 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16808 api_one_adjacencies_get (vat_main_t * vam)
16810 unformat_input_t *i = vam->input;
16811 vl_api_one_adjacencies_get_t *mp;
16816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16818 if (unformat (i, "vni %d", &vni))
16824 errmsg ("parse error '%U'", format_unformat_error, i);
16831 errmsg ("vni not set!");
16835 if (!vam->json_output)
16837 print (vam->ofp, "%s %40s", "leid", "reid");
16840 M (ONE_ADJACENCIES_GET, mp);
16841 mp->vni = clib_host_to_net_u32 (vni);
16846 /* Wait for a reply... */
16851 #define api_lisp_adjacencies_get api_one_adjacencies_get
16854 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16856 unformat_input_t *i = vam->input;
16857 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16859 u8 ip_family_set = 0, is_ip4 = 1;
16861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16863 if (unformat (i, "ip4"))
16868 else if (unformat (i, "ip6"))
16875 errmsg ("parse error '%U'", format_unformat_error, i);
16880 if (!ip_family_set)
16882 errmsg ("ip family not set!");
16886 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16887 mp->is_ip4 = is_ip4;
16892 /* Wait for a reply... */
16898 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16900 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16903 if (!vam->json_output)
16905 print (vam->ofp, "VNIs");
16908 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16913 /* Wait for a reply... */
16919 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16921 unformat_input_t *i = vam->input;
16922 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16924 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16925 struct in_addr ip4;
16926 struct in6_addr ip6;
16927 u32 table_id = 0, nh_sw_if_index = ~0;
16929 clib_memset (&ip4, 0, sizeof (ip4));
16930 clib_memset (&ip6, 0, sizeof (ip6));
16932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16934 if (unformat (i, "del"))
16936 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16937 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16942 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16943 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16948 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16952 nh_sw_if_index = ~0;
16954 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16958 nh_sw_if_index = ~0;
16960 else if (unformat (i, "table %d", &table_id))
16964 errmsg ("parse error '%U'", format_unformat_error, i);
16971 errmsg ("nh addr not set!");
16975 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16976 mp->is_add = is_add;
16977 mp->table_id = clib_host_to_net_u32 (table_id);
16978 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16979 mp->is_ip4 = is_ip4;
16981 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
16983 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
16988 /* Wait for a reply... */
16994 api_one_map_server_dump (vat_main_t * vam)
16996 vl_api_one_map_server_dump_t *mp;
16997 vl_api_control_ping_t *mp_ping;
17000 if (!vam->json_output)
17002 print (vam->ofp, "%=20s", "Map server");
17005 M (ONE_MAP_SERVER_DUMP, mp);
17009 /* Use a control ping for synchronization */
17010 MPING (CONTROL_PING, mp_ping);
17013 /* Wait for a reply... */
17018 #define api_lisp_map_server_dump api_one_map_server_dump
17021 api_one_map_resolver_dump (vat_main_t * vam)
17023 vl_api_one_map_resolver_dump_t *mp;
17024 vl_api_control_ping_t *mp_ping;
17027 if (!vam->json_output)
17029 print (vam->ofp, "%=20s", "Map resolver");
17032 M (ONE_MAP_RESOLVER_DUMP, mp);
17036 /* Use a control ping for synchronization */
17037 MPING (CONTROL_PING, mp_ping);
17040 /* Wait for a reply... */
17045 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
17048 api_one_stats_flush (vat_main_t * vam)
17050 vl_api_one_stats_flush_t *mp;
17053 M (ONE_STATS_FLUSH, mp);
17060 api_one_stats_dump (vat_main_t * vam)
17062 vl_api_one_stats_dump_t *mp;
17063 vl_api_control_ping_t *mp_ping;
17066 M (ONE_STATS_DUMP, mp);
17070 /* Use a control ping for synchronization */
17071 MPING (CONTROL_PING, mp_ping);
17074 /* Wait for a reply... */
17080 api_show_one_status (vat_main_t * vam)
17082 vl_api_show_one_status_t *mp;
17085 if (!vam->json_output)
17087 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17090 M (SHOW_ONE_STATUS, mp);
17093 /* Wait for a reply... */
17098 #define api_show_lisp_status api_show_one_status
17101 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17103 vl_api_gpe_fwd_entry_path_dump_t *mp;
17104 vl_api_control_ping_t *mp_ping;
17105 unformat_input_t *i = vam->input;
17106 u32 fwd_entry_index = ~0;
17109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17111 if (unformat (i, "index %d", &fwd_entry_index))
17117 if (~0 == fwd_entry_index)
17119 errmsg ("no index specified!");
17123 if (!vam->json_output)
17125 print (vam->ofp, "first line");
17128 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17132 /* Use a control ping for synchronization */
17133 MPING (CONTROL_PING, mp_ping);
17136 /* Wait for a reply... */
17142 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17144 vl_api_one_get_map_request_itr_rlocs_t *mp;
17147 if (!vam->json_output)
17149 print (vam->ofp, "%=20s", "itr-rlocs:");
17152 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17155 /* Wait for a reply... */
17160 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17163 api_af_packet_create (vat_main_t * vam)
17165 unformat_input_t *i = vam->input;
17166 vl_api_af_packet_create_t *mp;
17167 u8 *host_if_name = 0;
17169 u8 random_hw_addr = 1;
17172 clib_memset (hw_addr, 0, sizeof (hw_addr));
17174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17176 if (unformat (i, "name %s", &host_if_name))
17177 vec_add1 (host_if_name, 0);
17178 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17179 random_hw_addr = 0;
17184 if (!vec_len (host_if_name))
17186 errmsg ("host-interface name must be specified");
17190 if (vec_len (host_if_name) > 64)
17192 errmsg ("host-interface name too long");
17196 M (AF_PACKET_CREATE, mp);
17198 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17199 clib_memcpy (mp->hw_addr, hw_addr, 6);
17200 mp->use_random_hw_addr = random_hw_addr;
17201 vec_free (host_if_name);
17209 fprintf (vam->ofp ? vam->ofp : stderr,
17210 " new sw_if_index = %d\n", vam->sw_if_index);
17217 api_af_packet_delete (vat_main_t * vam)
17219 unformat_input_t *i = vam->input;
17220 vl_api_af_packet_delete_t *mp;
17221 u8 *host_if_name = 0;
17224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17226 if (unformat (i, "name %s", &host_if_name))
17227 vec_add1 (host_if_name, 0);
17232 if (!vec_len (host_if_name))
17234 errmsg ("host-interface name must be specified");
17238 if (vec_len (host_if_name) > 64)
17240 errmsg ("host-interface name too long");
17244 M (AF_PACKET_DELETE, mp);
17246 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17247 vec_free (host_if_name);
17254 static void vl_api_af_packet_details_t_handler
17255 (vl_api_af_packet_details_t * mp)
17257 vat_main_t *vam = &vat_main;
17259 print (vam->ofp, "%-16s %d",
17260 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17263 static void vl_api_af_packet_details_t_handler_json
17264 (vl_api_af_packet_details_t * mp)
17266 vat_main_t *vam = &vat_main;
17267 vat_json_node_t *node = NULL;
17269 if (VAT_JSON_ARRAY != vam->json_tree.type)
17271 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17272 vat_json_init_array (&vam->json_tree);
17274 node = vat_json_array_add (&vam->json_tree);
17276 vat_json_init_object (node);
17277 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17278 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17282 api_af_packet_dump (vat_main_t * vam)
17284 vl_api_af_packet_dump_t *mp;
17285 vl_api_control_ping_t *mp_ping;
17288 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17289 /* Get list of tap interfaces */
17290 M (AF_PACKET_DUMP, mp);
17293 /* Use a control ping for synchronization */
17294 MPING (CONTROL_PING, mp_ping);
17302 api_policer_add_del (vat_main_t * vam)
17304 unformat_input_t *i = vam->input;
17305 vl_api_policer_add_del_t *mp;
17315 u8 color_aware = 0;
17316 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17319 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17320 conform_action.dscp = 0;
17321 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17322 exceed_action.dscp = 0;
17323 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17324 violate_action.dscp = 0;
17326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17328 if (unformat (i, "del"))
17330 else if (unformat (i, "name %s", &name))
17331 vec_add1 (name, 0);
17332 else if (unformat (i, "cir %u", &cir))
17334 else if (unformat (i, "eir %u", &eir))
17336 else if (unformat (i, "cb %u", &cb))
17338 else if (unformat (i, "eb %u", &eb))
17340 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17343 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17346 else if (unformat (i, "type %U", unformat_policer_type, &type))
17348 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17351 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17354 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17357 else if (unformat (i, "color-aware"))
17363 if (!vec_len (name))
17365 errmsg ("policer name must be specified");
17369 if (vec_len (name) > 64)
17371 errmsg ("policer name too long");
17375 M (POLICER_ADD_DEL, mp);
17377 clib_memcpy (mp->name, name, vec_len (name));
17379 mp->is_add = is_add;
17380 mp->cir = ntohl (cir);
17381 mp->eir = ntohl (eir);
17382 mp->cb = clib_net_to_host_u64 (cb);
17383 mp->eb = clib_net_to_host_u64 (eb);
17384 mp->rate_type = rate_type;
17385 mp->round_type = round_type;
17387 mp->conform_action.type = conform_action.action_type;
17388 mp->conform_action.dscp = conform_action.dscp;
17389 mp->exceed_action.type = exceed_action.action_type;
17390 mp->exceed_action.dscp = exceed_action.dscp;
17391 mp->violate_action.type = violate_action.action_type;
17392 mp->violate_action.dscp = violate_action.dscp;
17393 mp->color_aware = color_aware;
17401 api_policer_dump (vat_main_t * vam)
17403 unformat_input_t *i = vam->input;
17404 vl_api_policer_dump_t *mp;
17405 vl_api_control_ping_t *mp_ping;
17406 u8 *match_name = 0;
17407 u8 match_name_valid = 0;
17410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17412 if (unformat (i, "name %s", &match_name))
17414 vec_add1 (match_name, 0);
17415 match_name_valid = 1;
17421 M (POLICER_DUMP, mp);
17422 mp->match_name_valid = match_name_valid;
17423 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17424 vec_free (match_name);
17428 /* Use a control ping for synchronization */
17429 MPING (CONTROL_PING, mp_ping);
17432 /* Wait for a reply... */
17438 api_policer_classify_set_interface (vat_main_t * vam)
17440 unformat_input_t *i = vam->input;
17441 vl_api_policer_classify_set_interface_t *mp;
17443 int sw_if_index_set;
17444 u32 ip4_table_index = ~0;
17445 u32 ip6_table_index = ~0;
17446 u32 l2_table_index = ~0;
17450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17452 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17453 sw_if_index_set = 1;
17454 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17455 sw_if_index_set = 1;
17456 else if (unformat (i, "del"))
17458 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17460 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17462 else if (unformat (i, "l2-table %d", &l2_table_index))
17466 clib_warning ("parse error '%U'", format_unformat_error, i);
17471 if (sw_if_index_set == 0)
17473 errmsg ("missing interface name or sw_if_index");
17477 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17479 mp->sw_if_index = ntohl (sw_if_index);
17480 mp->ip4_table_index = ntohl (ip4_table_index);
17481 mp->ip6_table_index = ntohl (ip6_table_index);
17482 mp->l2_table_index = ntohl (l2_table_index);
17483 mp->is_add = is_add;
17491 api_policer_classify_dump (vat_main_t * vam)
17493 unformat_input_t *i = vam->input;
17494 vl_api_policer_classify_dump_t *mp;
17495 vl_api_control_ping_t *mp_ping;
17496 u8 type = POLICER_CLASSIFY_N_TABLES;
17499 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17503 errmsg ("classify table type must be specified");
17507 if (!vam->json_output)
17509 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17512 M (POLICER_CLASSIFY_DUMP, mp);
17517 /* Use a control ping for synchronization */
17518 MPING (CONTROL_PING, mp_ping);
17521 /* Wait for a reply... */
17527 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17529 vl_api_fib_path_nh_proto_t proto =
17530 va_arg (*args, vl_api_fib_path_nh_proto_t);
17534 case FIB_API_PATH_NH_PROTO_IP4:
17535 s = format (s, "ip4");
17537 case FIB_API_PATH_NH_PROTO_IP6:
17538 s = format (s, "ip6");
17540 case FIB_API_PATH_NH_PROTO_MPLS:
17541 s = format (s, "mpls");
17543 case FIB_API_PATH_NH_PROTO_BIER:
17544 s = format (s, "bier");
17546 case FIB_API_PATH_NH_PROTO_ETHERNET:
17547 s = format (s, "ethernet");
17555 format_vl_api_ip_address_union (u8 * s, va_list * args)
17557 vl_api_address_family_t af = va_arg (*args, int);
17558 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17563 s = format (s, "%U", format_ip4_address, u->ip4);
17566 s = format (s, "%U", format_ip6_address, u->ip6);
17573 format_vl_api_fib_path_type (u8 * s, va_list * args)
17575 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17579 case FIB_API_PATH_TYPE_NORMAL:
17580 s = format (s, "normal");
17582 case FIB_API_PATH_TYPE_LOCAL:
17583 s = format (s, "local");
17585 case FIB_API_PATH_TYPE_DROP:
17586 s = format (s, "drop");
17588 case FIB_API_PATH_TYPE_UDP_ENCAP:
17589 s = format (s, "udp-encap");
17591 case FIB_API_PATH_TYPE_BIER_IMP:
17592 s = format (s, "bier-imp");
17594 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17595 s = format (s, "unreach");
17597 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17598 s = format (s, "prohibit");
17600 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17601 s = format (s, "src-lookup");
17603 case FIB_API_PATH_TYPE_DVR:
17604 s = format (s, "dvr");
17606 case FIB_API_PATH_TYPE_INTERFACE_RX:
17607 s = format (s, "interface-rx");
17609 case FIB_API_PATH_TYPE_CLASSIFY:
17610 s = format (s, "classify");
17618 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17621 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17622 ntohl (fp->weight), ntohl (fp->sw_if_index),
17623 format_vl_api_fib_path_type, fp->type,
17624 format_fib_api_path_nh_proto, fp->proto,
17625 format_vl_api_ip_address_union, &fp->nh.address);
17629 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17630 vl_api_fib_path_t * fp)
17632 struct in_addr ip4;
17633 struct in6_addr ip6;
17635 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17636 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17637 vat_json_object_add_uint (node, "type", fp->type);
17638 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17639 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17641 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17642 vat_json_object_add_ip4 (node, "next_hop", ip4);
17644 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17646 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17647 vat_json_object_add_ip6 (node, "next_hop", ip6);
17652 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17654 vat_main_t *vam = &vat_main;
17655 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17656 vl_api_fib_path_t *fp;
17659 print (vam->ofp, "sw_if_index %d via:",
17660 ntohl (mp->mt_tunnel.mt_sw_if_index));
17661 fp = mp->mt_tunnel.mt_paths;
17662 for (i = 0; i < count; i++)
17664 vl_api_fib_path_print (vam, fp);
17668 print (vam->ofp, "");
17671 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17672 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17675 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17677 vat_main_t *vam = &vat_main;
17678 vat_json_node_t *node = NULL;
17679 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17680 vl_api_fib_path_t *fp;
17683 if (VAT_JSON_ARRAY != vam->json_tree.type)
17685 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17686 vat_json_init_array (&vam->json_tree);
17688 node = vat_json_array_add (&vam->json_tree);
17690 vat_json_init_object (node);
17691 vat_json_object_add_uint (node, "sw_if_index",
17692 ntohl (mp->mt_tunnel.mt_sw_if_index));
17694 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17696 fp = mp->mt_tunnel.mt_paths;
17697 for (i = 0; i < count; i++)
17699 vl_api_mpls_fib_path_json_print (node, fp);
17705 api_mpls_tunnel_dump (vat_main_t * vam)
17707 vl_api_mpls_tunnel_dump_t *mp;
17708 vl_api_control_ping_t *mp_ping;
17711 M (MPLS_TUNNEL_DUMP, mp);
17715 /* Use a control ping for synchronization */
17716 MPING (CONTROL_PING, mp_ping);
17723 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17724 #define vl_api_mpls_table_details_t_print vl_noop_handler
17728 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17730 vat_main_t *vam = &vat_main;
17732 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17735 static void vl_api_mpls_table_details_t_handler_json
17736 (vl_api_mpls_table_details_t * mp)
17738 vat_main_t *vam = &vat_main;
17739 vat_json_node_t *node = NULL;
17741 if (VAT_JSON_ARRAY != vam->json_tree.type)
17743 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17744 vat_json_init_array (&vam->json_tree);
17746 node = vat_json_array_add (&vam->json_tree);
17748 vat_json_init_object (node);
17749 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17753 api_mpls_table_dump (vat_main_t * vam)
17755 vl_api_mpls_table_dump_t *mp;
17756 vl_api_control_ping_t *mp_ping;
17759 M (MPLS_TABLE_DUMP, mp);
17762 /* Use a control ping for synchronization */
17763 MPING (CONTROL_PING, mp_ping);
17770 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17771 #define vl_api_mpls_route_details_t_print vl_noop_handler
17774 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17776 vat_main_t *vam = &vat_main;
17777 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17778 vl_api_fib_path_t *fp;
17782 "table-id %d, label %u, ess_bit %u",
17783 ntohl (mp->mr_route.mr_table_id),
17784 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17785 fp = mp->mr_route.mr_paths;
17786 for (i = 0; i < count; i++)
17788 vl_api_fib_path_print (vam, fp);
17793 static void vl_api_mpls_route_details_t_handler_json
17794 (vl_api_mpls_route_details_t * mp)
17796 vat_main_t *vam = &vat_main;
17797 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17798 vat_json_node_t *node = NULL;
17799 vl_api_fib_path_t *fp;
17802 if (VAT_JSON_ARRAY != vam->json_tree.type)
17804 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17805 vat_json_init_array (&vam->json_tree);
17807 node = vat_json_array_add (&vam->json_tree);
17809 vat_json_init_object (node);
17810 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17811 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17812 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17813 vat_json_object_add_uint (node, "path_count", count);
17814 fp = mp->mr_route.mr_paths;
17815 for (i = 0; i < count; i++)
17817 vl_api_mpls_fib_path_json_print (node, fp);
17823 api_mpls_route_dump (vat_main_t * vam)
17825 unformat_input_t *input = vam->input;
17826 vl_api_mpls_route_dump_t *mp;
17827 vl_api_control_ping_t *mp_ping;
17831 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17833 if (unformat (input, "table_id %d", &table_id))
17838 if (table_id == ~0)
17840 errmsg ("missing table id");
17844 M (MPLS_ROUTE_DUMP, mp);
17846 mp->table.mt_table_id = ntohl (table_id);
17849 /* Use a control ping for synchronization */
17850 MPING (CONTROL_PING, mp_ping);
17857 #define vl_api_ip_table_details_t_endian vl_noop_handler
17858 #define vl_api_ip_table_details_t_print vl_noop_handler
17861 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17863 vat_main_t *vam = &vat_main;
17866 "%s; table-id %d, prefix %U/%d",
17867 mp->table.name, ntohl (mp->table.table_id));
17871 static void vl_api_ip_table_details_t_handler_json
17872 (vl_api_ip_table_details_t * mp)
17874 vat_main_t *vam = &vat_main;
17875 vat_json_node_t *node = NULL;
17877 if (VAT_JSON_ARRAY != vam->json_tree.type)
17879 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17880 vat_json_init_array (&vam->json_tree);
17882 node = vat_json_array_add (&vam->json_tree);
17884 vat_json_init_object (node);
17885 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17889 api_ip_table_dump (vat_main_t * vam)
17891 vl_api_ip_table_dump_t *mp;
17892 vl_api_control_ping_t *mp_ping;
17895 M (IP_TABLE_DUMP, mp);
17898 /* Use a control ping for synchronization */
17899 MPING (CONTROL_PING, mp_ping);
17907 api_ip_mtable_dump (vat_main_t * vam)
17909 vl_api_ip_mtable_dump_t *mp;
17910 vl_api_control_ping_t *mp_ping;
17913 M (IP_MTABLE_DUMP, mp);
17916 /* Use a control ping for synchronization */
17917 MPING (CONTROL_PING, mp_ping);
17925 api_ip_mroute_dump (vat_main_t * vam)
17927 unformat_input_t *input = vam->input;
17928 vl_api_control_ping_t *mp_ping;
17929 vl_api_ip_mroute_dump_t *mp;
17934 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17936 if (unformat (input, "table_id %d", &table_id))
17938 else if (unformat (input, "ip6"))
17940 else if (unformat (input, "ip4"))
17945 if (table_id == ~0)
17947 errmsg ("missing table id");
17951 M (IP_MROUTE_DUMP, mp);
17952 mp->table.table_id = table_id;
17953 mp->table.is_ip6 = is_ip6;
17956 /* Use a control ping for synchronization */
17957 MPING (CONTROL_PING, mp_ping);
17964 #define vl_api_ip_route_details_t_endian vl_noop_handler
17965 #define vl_api_ip_route_details_t_print vl_noop_handler
17968 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17970 vat_main_t *vam = &vat_main;
17971 u8 count = mp->route.n_paths;
17972 vl_api_fib_path_t *fp;
17976 "table-id %d, prefix %U/%d",
17977 ntohl (mp->route.table_id),
17978 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17979 for (i = 0; i < count; i++)
17981 fp = &mp->route.paths[i];
17983 vl_api_fib_path_print (vam, fp);
17988 static void vl_api_ip_route_details_t_handler_json
17989 (vl_api_ip_route_details_t * mp)
17991 vat_main_t *vam = &vat_main;
17992 u8 count = mp->route.n_paths;
17993 vat_json_node_t *node = NULL;
17994 struct in_addr ip4;
17995 struct in6_addr ip6;
17996 vl_api_fib_path_t *fp;
17999 if (VAT_JSON_ARRAY != vam->json_tree.type)
18001 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18002 vat_json_init_array (&vam->json_tree);
18004 node = vat_json_array_add (&vam->json_tree);
18006 vat_json_init_object (node);
18007 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
18008 if (ADDRESS_IP6 == mp->route.prefix.address.af)
18010 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
18011 vat_json_object_add_ip6 (node, "prefix", ip6);
18015 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
18016 vat_json_object_add_ip4 (node, "prefix", ip4);
18018 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
18019 vat_json_object_add_uint (node, "path_count", count);
18020 for (i = 0; i < count; i++)
18022 fp = &mp->route.paths[i];
18023 vl_api_mpls_fib_path_json_print (node, fp);
18028 api_ip_route_dump (vat_main_t * vam)
18030 unformat_input_t *input = vam->input;
18031 vl_api_ip_route_dump_t *mp;
18032 vl_api_control_ping_t *mp_ping;
18038 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18040 if (unformat (input, "table_id %d", &table_id))
18042 else if (unformat (input, "ip6"))
18044 else if (unformat (input, "ip4"))
18049 if (table_id == ~0)
18051 errmsg ("missing table id");
18055 M (IP_ROUTE_DUMP, mp);
18057 mp->table.table_id = table_id;
18058 mp->table.is_ip6 = is_ip6;
18062 /* Use a control ping for synchronization */
18063 MPING (CONTROL_PING, mp_ping);
18071 api_classify_table_ids (vat_main_t * vam)
18073 vl_api_classify_table_ids_t *mp;
18076 /* Construct the API message */
18077 M (CLASSIFY_TABLE_IDS, mp);
18086 api_classify_table_by_interface (vat_main_t * vam)
18088 unformat_input_t *input = vam->input;
18089 vl_api_classify_table_by_interface_t *mp;
18091 u32 sw_if_index = ~0;
18093 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18095 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18097 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18102 if (sw_if_index == ~0)
18104 errmsg ("missing interface name or sw_if_index");
18108 /* Construct the API message */
18109 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18111 mp->sw_if_index = ntohl (sw_if_index);
18119 api_classify_table_info (vat_main_t * vam)
18121 unformat_input_t *input = vam->input;
18122 vl_api_classify_table_info_t *mp;
18126 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18128 if (unformat (input, "table_id %d", &table_id))
18133 if (table_id == ~0)
18135 errmsg ("missing table id");
18139 /* Construct the API message */
18140 M (CLASSIFY_TABLE_INFO, mp);
18142 mp->table_id = ntohl (table_id);
18150 api_classify_session_dump (vat_main_t * vam)
18152 unformat_input_t *input = vam->input;
18153 vl_api_classify_session_dump_t *mp;
18154 vl_api_control_ping_t *mp_ping;
18158 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18160 if (unformat (input, "table_id %d", &table_id))
18165 if (table_id == ~0)
18167 errmsg ("missing table id");
18171 /* Construct the API message */
18172 M (CLASSIFY_SESSION_DUMP, mp);
18174 mp->table_id = ntohl (table_id);
18177 /* Use a control ping for synchronization */
18178 MPING (CONTROL_PING, mp_ping);
18186 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18188 vat_main_t *vam = &vat_main;
18190 print (vam->ofp, "collector_address %U, collector_port %d, "
18191 "src_address %U, vrf_id %d, path_mtu %u, "
18192 "template_interval %u, udp_checksum %d",
18193 format_ip4_address, mp->collector_address,
18194 ntohs (mp->collector_port),
18195 format_ip4_address, mp->src_address,
18196 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18197 ntohl (mp->template_interval), mp->udp_checksum);
18200 vam->result_ready = 1;
18204 vl_api_ipfix_exporter_details_t_handler_json
18205 (vl_api_ipfix_exporter_details_t * mp)
18207 vat_main_t *vam = &vat_main;
18208 vat_json_node_t node;
18209 struct in_addr collector_address;
18210 struct in_addr src_address;
18212 vat_json_init_object (&node);
18213 clib_memcpy (&collector_address, &mp->collector_address,
18214 sizeof (collector_address));
18215 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18216 vat_json_object_add_uint (&node, "collector_port",
18217 ntohs (mp->collector_port));
18218 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18219 vat_json_object_add_ip4 (&node, "src_address", src_address);
18220 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18221 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18222 vat_json_object_add_uint (&node, "template_interval",
18223 ntohl (mp->template_interval));
18224 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18226 vat_json_print (vam->ofp, &node);
18227 vat_json_free (&node);
18229 vam->result_ready = 1;
18233 api_ipfix_exporter_dump (vat_main_t * vam)
18235 vl_api_ipfix_exporter_dump_t *mp;
18238 /* Construct the API message */
18239 M (IPFIX_EXPORTER_DUMP, mp);
18248 api_ipfix_classify_stream_dump (vat_main_t * vam)
18250 vl_api_ipfix_classify_stream_dump_t *mp;
18253 /* Construct the API message */
18254 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18265 vl_api_ipfix_classify_stream_details_t_handler
18266 (vl_api_ipfix_classify_stream_details_t * mp)
18268 vat_main_t *vam = &vat_main;
18269 print (vam->ofp, "domain_id %d, src_port %d",
18270 ntohl (mp->domain_id), ntohs (mp->src_port));
18272 vam->result_ready = 1;
18276 vl_api_ipfix_classify_stream_details_t_handler_json
18277 (vl_api_ipfix_classify_stream_details_t * mp)
18279 vat_main_t *vam = &vat_main;
18280 vat_json_node_t node;
18282 vat_json_init_object (&node);
18283 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18284 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18286 vat_json_print (vam->ofp, &node);
18287 vat_json_free (&node);
18289 vam->result_ready = 1;
18293 api_ipfix_classify_table_dump (vat_main_t * vam)
18295 vl_api_ipfix_classify_table_dump_t *mp;
18296 vl_api_control_ping_t *mp_ping;
18299 if (!vam->json_output)
18301 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18302 "transport_protocol");
18305 /* Construct the API message */
18306 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18311 /* Use a control ping for synchronization */
18312 MPING (CONTROL_PING, mp_ping);
18320 vl_api_ipfix_classify_table_details_t_handler
18321 (vl_api_ipfix_classify_table_details_t * mp)
18323 vat_main_t *vam = &vat_main;
18324 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18325 mp->transport_protocol);
18329 vl_api_ipfix_classify_table_details_t_handler_json
18330 (vl_api_ipfix_classify_table_details_t * mp)
18332 vat_json_node_t *node = NULL;
18333 vat_main_t *vam = &vat_main;
18335 if (VAT_JSON_ARRAY != vam->json_tree.type)
18337 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18338 vat_json_init_array (&vam->json_tree);
18341 node = vat_json_array_add (&vam->json_tree);
18342 vat_json_init_object (node);
18344 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18345 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18346 vat_json_object_add_uint (node, "transport_protocol",
18347 mp->transport_protocol);
18351 api_sw_interface_span_enable_disable (vat_main_t * vam)
18353 unformat_input_t *i = vam->input;
18354 vl_api_sw_interface_span_enable_disable_t *mp;
18355 u32 src_sw_if_index = ~0;
18356 u32 dst_sw_if_index = ~0;
18361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18364 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18366 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18370 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18372 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18374 else if (unformat (i, "disable"))
18376 else if (unformat (i, "rx"))
18378 else if (unformat (i, "tx"))
18380 else if (unformat (i, "both"))
18382 else if (unformat (i, "l2"))
18388 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18390 mp->sw_if_index_from = htonl (src_sw_if_index);
18391 mp->sw_if_index_to = htonl (dst_sw_if_index);
18401 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18404 vat_main_t *vam = &vat_main;
18405 u8 *sw_if_from_name = 0;
18406 u8 *sw_if_to_name = 0;
18407 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18408 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18409 char *states[] = { "none", "rx", "tx", "both" };
18413 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18415 if ((u32) p->value[0] == sw_if_index_from)
18417 sw_if_from_name = (u8 *)(p->key);
18421 if ((u32) p->value[0] == sw_if_index_to)
18423 sw_if_to_name = (u8 *)(p->key);
18424 if (sw_if_from_name)
18429 print (vam->ofp, "%20s => %20s (%s) %s",
18430 sw_if_from_name, sw_if_to_name, states[mp->state],
18431 mp->is_l2 ? "l2" : "device");
18435 vl_api_sw_interface_span_details_t_handler_json
18436 (vl_api_sw_interface_span_details_t * mp)
18438 vat_main_t *vam = &vat_main;
18439 vat_json_node_t *node = NULL;
18440 u8 *sw_if_from_name = 0;
18441 u8 *sw_if_to_name = 0;
18442 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18443 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18447 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18449 if ((u32) p->value[0] == sw_if_index_from)
18451 sw_if_from_name = (u8 *)(p->key);
18455 if ((u32) p->value[0] == sw_if_index_to)
18457 sw_if_to_name = (u8 *)(p->key);
18458 if (sw_if_from_name)
18464 if (VAT_JSON_ARRAY != vam->json_tree.type)
18466 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18467 vat_json_init_array (&vam->json_tree);
18469 node = vat_json_array_add (&vam->json_tree);
18471 vat_json_init_object (node);
18472 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18473 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18474 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18475 if (0 != sw_if_to_name)
18477 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18479 vat_json_object_add_uint (node, "state", mp->state);
18480 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18484 api_sw_interface_span_dump (vat_main_t * vam)
18486 unformat_input_t *input = vam->input;
18487 vl_api_sw_interface_span_dump_t *mp;
18488 vl_api_control_ping_t *mp_ping;
18492 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18494 if (unformat (input, "l2"))
18500 M (SW_INTERFACE_SPAN_DUMP, mp);
18504 /* Use a control ping for synchronization */
18505 MPING (CONTROL_PING, mp_ping);
18513 api_pg_create_interface (vat_main_t * vam)
18515 unformat_input_t *input = vam->input;
18516 vl_api_pg_create_interface_t *mp;
18518 u32 if_id = ~0, gso_size = 0;
18519 u8 gso_enabled = 0;
18521 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18523 if (unformat (input, "if_id %d", &if_id))
18525 else if (unformat (input, "gso-enabled"))
18528 if (unformat (input, "gso-size %u", &gso_size))
18532 errmsg ("missing gso-size");
18541 errmsg ("missing pg interface index");
18545 /* Construct the API message */
18546 M (PG_CREATE_INTERFACE, mp);
18548 mp->interface_id = ntohl (if_id);
18549 mp->gso_enabled = gso_enabled;
18557 api_pg_capture (vat_main_t * vam)
18559 unformat_input_t *input = vam->input;
18560 vl_api_pg_capture_t *mp;
18565 u8 pcap_file_set = 0;
18568 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18570 if (unformat (input, "if_id %d", &if_id))
18572 else if (unformat (input, "pcap %s", &pcap_file))
18574 else if (unformat (input, "count %d", &count))
18576 else if (unformat (input, "disable"))
18583 errmsg ("missing pg interface index");
18586 if (pcap_file_set > 0)
18588 if (vec_len (pcap_file) > 255)
18590 errmsg ("pcap file name is too long");
18595 /* Construct the API message */
18596 M (PG_CAPTURE, mp);
18598 mp->interface_id = ntohl (if_id);
18599 mp->is_enabled = enable;
18600 mp->count = ntohl (count);
18601 if (pcap_file_set != 0)
18603 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
18605 vec_free (pcap_file);
18613 api_pg_enable_disable (vat_main_t * vam)
18615 unformat_input_t *input = vam->input;
18616 vl_api_pg_enable_disable_t *mp;
18619 u8 stream_name_set = 0;
18620 u8 *stream_name = 0;
18622 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18624 if (unformat (input, "stream %s", &stream_name))
18625 stream_name_set = 1;
18626 else if (unformat (input, "disable"))
18632 if (stream_name_set > 0)
18634 if (vec_len (stream_name) > 255)
18636 errmsg ("stream name too long");
18641 /* Construct the API message */
18642 M (PG_ENABLE_DISABLE, mp);
18644 mp->is_enabled = enable;
18645 if (stream_name_set != 0)
18647 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
18649 vec_free (stream_name);
18657 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18659 unformat_input_t *input = vam->input;
18660 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18662 u16 *low_ports = 0;
18663 u16 *high_ports = 0;
18666 vl_api_prefix_t prefix;
18673 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18675 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18677 else if (unformat (input, "vrf %d", &vrf_id))
18679 else if (unformat (input, "del"))
18681 else if (unformat (input, "port %d", &tmp))
18683 if (tmp == 0 || tmp > 65535)
18685 errmsg ("port %d out of range", tmp);
18689 this_hi = this_low + 1;
18690 vec_add1 (low_ports, this_low);
18691 vec_add1 (high_ports, this_hi);
18693 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18695 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18697 errmsg ("incorrect range parameters");
18701 /* Note: in debug CLI +1 is added to high before
18702 passing to real fn that does "the work"
18703 (ip_source_and_port_range_check_add_del).
18704 This fn is a wrapper around the binary API fn a
18705 control plane will call, which expects this increment
18706 to have occurred. Hence letting the binary API control
18707 plane fn do the increment for consistency between VAT
18708 and other control planes.
18711 vec_add1 (low_ports, this_low);
18712 vec_add1 (high_ports, this_hi);
18718 if (prefix_set == 0)
18720 errmsg ("<address>/<mask> not specified");
18726 errmsg ("VRF ID required, not specified");
18733 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18737 if (vec_len (low_ports) == 0)
18739 errmsg ("At least one port or port range required");
18743 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18745 mp->is_add = is_add;
18747 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18749 mp->number_of_ranges = vec_len (low_ports);
18751 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18752 vec_free (low_ports);
18754 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18755 vec_free (high_ports);
18757 mp->vrf_id = ntohl (vrf_id);
18765 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18767 unformat_input_t *input = vam->input;
18768 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18769 u32 sw_if_index = ~0;
18771 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18772 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18776 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18778 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18780 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18782 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18784 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18786 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18788 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18790 else if (unformat (input, "del"))
18796 if (sw_if_index == ~0)
18798 errmsg ("Interface required but not specified");
18804 errmsg ("VRF ID required but not specified");
18808 if (tcp_out_vrf_id == 0
18809 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18812 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18816 /* Construct the API message */
18817 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18819 mp->sw_if_index = ntohl (sw_if_index);
18820 mp->is_add = is_add;
18821 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18822 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18823 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18824 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18829 /* Wait for a reply... */
18835 api_set_punt (vat_main_t * vam)
18837 unformat_input_t *i = vam->input;
18838 vl_api_address_family_t af;
18839 vl_api_set_punt_t *mp;
18845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18847 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18849 else if (unformat (i, "protocol %d", &protocol))
18851 else if (unformat (i, "port %d", &port))
18853 else if (unformat (i, "del"))
18857 clib_warning ("parse error '%U'", format_unformat_error, i);
18864 mp->is_add = (u8) is_add;
18865 mp->punt.type = PUNT_API_TYPE_L4;
18866 mp->punt.punt.l4.af = af;
18867 mp->punt.punt.l4.protocol = (u8) protocol;
18868 mp->punt.punt.l4.port = htons ((u16) port);
18876 api_delete_subif (vat_main_t * vam)
18878 unformat_input_t *i = vam->input;
18879 vl_api_delete_subif_t *mp;
18880 u32 sw_if_index = ~0;
18883 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18885 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18887 if (unformat (i, "sw_if_index %d", &sw_if_index))
18893 if (sw_if_index == ~0)
18895 errmsg ("missing sw_if_index");
18899 /* Construct the API message */
18900 M (DELETE_SUBIF, mp);
18901 mp->sw_if_index = ntohl (sw_if_index);
18908 #define foreach_pbb_vtr_op \
18909 _("disable", L2_VTR_DISABLED) \
18910 _("pop", L2_VTR_POP_2) \
18911 _("push", L2_VTR_PUSH_2)
18914 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18916 unformat_input_t *i = vam->input;
18917 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18918 u32 sw_if_index = ~0, vtr_op = ~0;
18919 u16 outer_tag = ~0;
18920 u8 dmac[6], smac[6];
18921 u8 dmac_set = 0, smac_set = 0;
18927 /* Shut up coverity */
18928 clib_memset (dmac, 0, sizeof (dmac));
18929 clib_memset (smac, 0, sizeof (smac));
18931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18933 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18935 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18937 else if (unformat (i, "vtr_op %d", &vtr_op))
18939 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18942 else if (unformat (i, "translate_pbb_stag"))
18944 if (unformat (i, "%d", &tmp))
18946 vtr_op = L2_VTR_TRANSLATE_2_1;
18952 ("translate_pbb_stag operation requires outer tag definition");
18956 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18958 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18960 else if (unformat (i, "sid %d", &sid))
18962 else if (unformat (i, "vlanid %d", &tmp))
18966 clib_warning ("parse error '%U'", format_unformat_error, i);
18971 if ((sw_if_index == ~0) || (vtr_op == ~0))
18973 errmsg ("missing sw_if_index or vtr operation");
18976 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18977 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18980 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18984 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18985 mp->sw_if_index = ntohl (sw_if_index);
18986 mp->vtr_op = ntohl (vtr_op);
18987 mp->outer_tag = ntohs (outer_tag);
18988 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
18989 clib_memcpy (mp->b_smac, smac, sizeof (smac));
18990 mp->b_vlanid = ntohs (vlanid);
18991 mp->i_sid = ntohl (sid);
18999 api_flow_classify_set_interface (vat_main_t * vam)
19001 unformat_input_t *i = vam->input;
19002 vl_api_flow_classify_set_interface_t *mp;
19004 int sw_if_index_set;
19005 u32 ip4_table_index = ~0;
19006 u32 ip6_table_index = ~0;
19010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19012 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19013 sw_if_index_set = 1;
19014 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19015 sw_if_index_set = 1;
19016 else if (unformat (i, "del"))
19018 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19020 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19024 clib_warning ("parse error '%U'", format_unformat_error, i);
19029 if (sw_if_index_set == 0)
19031 errmsg ("missing interface name or sw_if_index");
19035 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
19037 mp->sw_if_index = ntohl (sw_if_index);
19038 mp->ip4_table_index = ntohl (ip4_table_index);
19039 mp->ip6_table_index = ntohl (ip6_table_index);
19040 mp->is_add = is_add;
19048 api_flow_classify_dump (vat_main_t * vam)
19050 unformat_input_t *i = vam->input;
19051 vl_api_flow_classify_dump_t *mp;
19052 vl_api_control_ping_t *mp_ping;
19053 u8 type = FLOW_CLASSIFY_N_TABLES;
19056 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
19060 errmsg ("classify table type must be specified");
19064 if (!vam->json_output)
19066 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19069 M (FLOW_CLASSIFY_DUMP, mp);
19074 /* Use a control ping for synchronization */
19075 MPING (CONTROL_PING, mp_ping);
19078 /* Wait for a reply... */
19084 api_feature_enable_disable (vat_main_t * vam)
19086 unformat_input_t *i = vam->input;
19087 vl_api_feature_enable_disable_t *mp;
19089 u8 *feature_name = 0;
19090 u32 sw_if_index = ~0;
19094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19096 if (unformat (i, "arc_name %s", &arc_name))
19098 else if (unformat (i, "feature_name %s", &feature_name))
19101 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19103 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19105 else if (unformat (i, "disable"))
19113 errmsg ("missing arc name");
19116 if (vec_len (arc_name) > 63)
19118 errmsg ("arc name too long");
19121 if (feature_name == 0)
19123 errmsg ("missing feature name");
19126 if (vec_len (feature_name) > 63)
19128 errmsg ("feature name too long");
19131 if (sw_if_index == ~0)
19133 errmsg ("missing interface name or sw_if_index");
19137 /* Construct the API message */
19138 M (FEATURE_ENABLE_DISABLE, mp);
19139 mp->sw_if_index = ntohl (sw_if_index);
19140 mp->enable = enable;
19141 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19142 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19143 vec_free (arc_name);
19144 vec_free (feature_name);
19152 api_feature_gso_enable_disable (vat_main_t * vam)
19154 unformat_input_t *i = vam->input;
19155 vl_api_feature_gso_enable_disable_t *mp;
19156 u32 sw_if_index = ~0;
19160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19166 else if (unformat (i, "enable"))
19168 else if (unformat (i, "disable"))
19174 if (sw_if_index == ~0)
19176 errmsg ("missing interface name or sw_if_index");
19180 /* Construct the API message */
19181 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19182 mp->sw_if_index = ntohl (sw_if_index);
19183 mp->enable_disable = enable;
19191 api_sw_interface_tag_add_del (vat_main_t * vam)
19193 unformat_input_t *i = vam->input;
19194 vl_api_sw_interface_tag_add_del_t *mp;
19195 u32 sw_if_index = ~0;
19200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19202 if (unformat (i, "tag %s", &tag))
19204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19208 else if (unformat (i, "del"))
19214 if (sw_if_index == ~0)
19216 errmsg ("missing interface name or sw_if_index");
19220 if (enable && (tag == 0))
19222 errmsg ("no tag specified");
19226 /* Construct the API message */
19227 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19228 mp->sw_if_index = ntohl (sw_if_index);
19229 mp->is_add = enable;
19231 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19240 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19242 unformat_input_t *i = vam->input;
19243 vl_api_mac_address_t mac = { 0 };
19244 vl_api_sw_interface_add_del_mac_address_t *mp;
19245 u32 sw_if_index = ~0;
19250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19252 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19254 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19256 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19258 else if (unformat (i, "del"))
19264 if (sw_if_index == ~0)
19266 errmsg ("missing interface name or sw_if_index");
19272 errmsg ("missing MAC address");
19276 /* Construct the API message */
19277 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19278 mp->sw_if_index = ntohl (sw_if_index);
19279 mp->is_add = is_add;
19280 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19287 static void vl_api_l2_xconnect_details_t_handler
19288 (vl_api_l2_xconnect_details_t * mp)
19290 vat_main_t *vam = &vat_main;
19292 print (vam->ofp, "%15d%15d",
19293 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19296 static void vl_api_l2_xconnect_details_t_handler_json
19297 (vl_api_l2_xconnect_details_t * mp)
19299 vat_main_t *vam = &vat_main;
19300 vat_json_node_t *node = NULL;
19302 if (VAT_JSON_ARRAY != vam->json_tree.type)
19304 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19305 vat_json_init_array (&vam->json_tree);
19307 node = vat_json_array_add (&vam->json_tree);
19309 vat_json_init_object (node);
19310 vat_json_object_add_uint (node, "rx_sw_if_index",
19311 ntohl (mp->rx_sw_if_index));
19312 vat_json_object_add_uint (node, "tx_sw_if_index",
19313 ntohl (mp->tx_sw_if_index));
19317 api_l2_xconnect_dump (vat_main_t * vam)
19319 vl_api_l2_xconnect_dump_t *mp;
19320 vl_api_control_ping_t *mp_ping;
19323 if (!vam->json_output)
19325 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19328 M (L2_XCONNECT_DUMP, mp);
19332 /* Use a control ping for synchronization */
19333 MPING (CONTROL_PING, mp_ping);
19341 api_hw_interface_set_mtu (vat_main_t * vam)
19343 unformat_input_t *i = vam->input;
19344 vl_api_hw_interface_set_mtu_t *mp;
19345 u32 sw_if_index = ~0;
19349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19351 if (unformat (i, "mtu %d", &mtu))
19353 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19355 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19361 if (sw_if_index == ~0)
19363 errmsg ("missing interface name or sw_if_index");
19369 errmsg ("no mtu specified");
19373 /* Construct the API message */
19374 M (HW_INTERFACE_SET_MTU, mp);
19375 mp->sw_if_index = ntohl (sw_if_index);
19376 mp->mtu = ntohs ((u16) mtu);
19384 api_p2p_ethernet_add (vat_main_t * vam)
19386 unformat_input_t *i = vam->input;
19387 vl_api_p2p_ethernet_add_t *mp;
19388 u32 parent_if_index = ~0;
19394 clib_memset (remote_mac, 0, sizeof (remote_mac));
19395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19397 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19399 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19403 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19405 else if (unformat (i, "sub_id %d", &sub_id))
19409 clib_warning ("parse error '%U'", format_unformat_error, i);
19414 if (parent_if_index == ~0)
19416 errmsg ("missing interface name or sw_if_index");
19421 errmsg ("missing remote mac address");
19426 errmsg ("missing sub-interface id");
19430 M (P2P_ETHERNET_ADD, mp);
19431 mp->parent_if_index = ntohl (parent_if_index);
19432 mp->subif_id = ntohl (sub_id);
19433 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19441 api_p2p_ethernet_del (vat_main_t * vam)
19443 unformat_input_t *i = vam->input;
19444 vl_api_p2p_ethernet_del_t *mp;
19445 u32 parent_if_index = ~0;
19450 clib_memset (remote_mac, 0, sizeof (remote_mac));
19451 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19453 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19455 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19459 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19463 clib_warning ("parse error '%U'", format_unformat_error, i);
19468 if (parent_if_index == ~0)
19470 errmsg ("missing interface name or sw_if_index");
19475 errmsg ("missing remote mac address");
19479 M (P2P_ETHERNET_DEL, mp);
19480 mp->parent_if_index = ntohl (parent_if_index);
19481 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19489 api_lldp_config (vat_main_t * vam)
19491 unformat_input_t *i = vam->input;
19492 vl_api_lldp_config_t *mp;
19494 int tx_interval = 0;
19495 u8 *sys_name = NULL;
19498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19500 if (unformat (i, "system-name %s", &sys_name))
19502 else if (unformat (i, "tx-hold %d", &tx_hold))
19504 else if (unformat (i, "tx-interval %d", &tx_interval))
19508 clib_warning ("parse error '%U'", format_unformat_error, i);
19513 vec_add1 (sys_name, 0);
19515 M (LLDP_CONFIG, mp);
19516 mp->tx_hold = htonl (tx_hold);
19517 mp->tx_interval = htonl (tx_interval);
19518 vl_api_vec_to_api_string (sys_name, &mp->system_name);
19519 vec_free (sys_name);
19527 api_sw_interface_set_lldp (vat_main_t * vam)
19529 unformat_input_t *i = vam->input;
19530 vl_api_sw_interface_set_lldp_t *mp;
19531 u32 sw_if_index = ~0;
19533 u8 *port_desc = NULL, *mgmt_oid = NULL;
19534 ip4_address_t ip4_addr;
19535 ip6_address_t ip6_addr;
19538 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19539 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19543 if (unformat (i, "disable"))
19546 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19548 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19550 else if (unformat (i, "port-desc %s", &port_desc))
19552 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19554 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19556 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19562 if (sw_if_index == ~0)
19564 errmsg ("missing interface name or sw_if_index");
19568 /* Construct the API message */
19569 vec_add1 (port_desc, 0);
19570 vec_add1 (mgmt_oid, 0);
19571 M (SW_INTERFACE_SET_LLDP, mp);
19572 mp->sw_if_index = ntohl (sw_if_index);
19573 mp->enable = enable;
19574 vl_api_vec_to_api_string (port_desc, &mp->port_desc);
19575 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19576 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19577 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19578 vec_free (port_desc);
19579 vec_free (mgmt_oid);
19587 api_tcp_configure_src_addresses (vat_main_t * vam)
19589 vl_api_tcp_configure_src_addresses_t *mp;
19590 unformat_input_t *i = vam->input;
19591 vl_api_address_t first, last;
19596 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19598 if (unformat (i, "%U - %U",
19599 unformat_vl_api_address, &first,
19600 unformat_vl_api_address, &last))
19604 errmsg ("one range per message (range already set)");
19609 else if (unformat (i, "vrf %d", &vrf_id))
19615 if (range_set == 0)
19617 errmsg ("address range not set");
19621 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19623 mp->vrf_id = ntohl (vrf_id);
19624 clib_memcpy (&mp->first_address, &first, sizeof (first));
19625 clib_memcpy (&mp->last_address, &last, sizeof (last));
19632 static void vl_api_app_namespace_add_del_reply_t_handler
19633 (vl_api_app_namespace_add_del_reply_t * mp)
19635 vat_main_t *vam = &vat_main;
19636 i32 retval = ntohl (mp->retval);
19637 if (vam->async_mode)
19639 vam->async_errors += (retval < 0);
19643 vam->retval = retval;
19645 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19646 vam->result_ready = 1;
19650 static void vl_api_app_namespace_add_del_reply_t_handler_json
19651 (vl_api_app_namespace_add_del_reply_t * mp)
19653 vat_main_t *vam = &vat_main;
19654 vat_json_node_t node;
19656 vat_json_init_object (&node);
19657 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19658 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19660 vat_json_print (vam->ofp, &node);
19661 vat_json_free (&node);
19663 vam->retval = ntohl (mp->retval);
19664 vam->result_ready = 1;
19668 api_app_namespace_add_del (vat_main_t * vam)
19670 vl_api_app_namespace_add_del_t *mp;
19671 unformat_input_t *i = vam->input;
19672 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19673 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19679 if (unformat (i, "id %_%v%_", &ns_id))
19681 else if (unformat (i, "secret %lu", &secret))
19683 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19684 sw_if_index_set = 1;
19685 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19687 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19692 if (!ns_id || !secret_set || !sw_if_index_set)
19694 errmsg ("namespace id, secret and sw_if_index must be set");
19697 if (vec_len (ns_id) > 64)
19699 errmsg ("namespace id too long");
19702 M (APP_NAMESPACE_ADD_DEL, mp);
19704 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
19705 mp->secret = clib_host_to_net_u64 (secret);
19706 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19707 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19708 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19716 api_sock_init_shm (vat_main_t * vam)
19718 #if VPP_API_TEST_BUILTIN == 0
19719 unformat_input_t *i = vam->input;
19720 vl_api_shm_elem_config_t *config = 0;
19721 u64 size = 64 << 20;
19724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19726 if (unformat (i, "size %U", unformat_memory_size, &size))
19733 * Canned custom ring allocator config.
19734 * Should probably parse all of this
19736 vec_validate (config, 6);
19737 config[0].type = VL_API_VLIB_RING;
19738 config[0].size = 256;
19739 config[0].count = 32;
19741 config[1].type = VL_API_VLIB_RING;
19742 config[1].size = 1024;
19743 config[1].count = 16;
19745 config[2].type = VL_API_VLIB_RING;
19746 config[2].size = 4096;
19747 config[2].count = 2;
19749 config[3].type = VL_API_CLIENT_RING;
19750 config[3].size = 256;
19751 config[3].count = 32;
19753 config[4].type = VL_API_CLIENT_RING;
19754 config[4].size = 1024;
19755 config[4].count = 16;
19757 config[5].type = VL_API_CLIENT_RING;
19758 config[5].size = 4096;
19759 config[5].count = 2;
19761 config[6].type = VL_API_QUEUE;
19762 config[6].count = 128;
19763 config[6].size = sizeof (uword);
19765 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19767 vam->client_index_invalid = 1;
19775 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19777 vat_main_t *vam = &vat_main;
19778 fib_prefix_t lcl, rmt;
19780 ip_prefix_decode (&mp->lcl, &lcl);
19781 ip_prefix_decode (&mp->rmt, &rmt);
19783 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19786 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19787 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19788 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
19789 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19790 &rmt.fp_addr.ip4, rmt.fp_len,
19791 clib_net_to_host_u16 (mp->rmt_port),
19792 clib_net_to_host_u32 (mp->action_index), mp->tag);
19797 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19798 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19799 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
19800 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19801 &rmt.fp_addr.ip6, rmt.fp_len,
19802 clib_net_to_host_u16 (mp->rmt_port),
19803 clib_net_to_host_u32 (mp->action_index), mp->tag);
19808 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19811 vat_main_t *vam = &vat_main;
19812 vat_json_node_t *node = NULL;
19813 struct in6_addr ip6;
19814 struct in_addr ip4;
19816 fib_prefix_t lcl, rmt;
19818 ip_prefix_decode (&mp->lcl, &lcl);
19819 ip_prefix_decode (&mp->rmt, &rmt);
19821 if (VAT_JSON_ARRAY != vam->json_tree.type)
19823 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19824 vat_json_init_array (&vam->json_tree);
19826 node = vat_json_array_add (&vam->json_tree);
19827 vat_json_init_object (node);
19829 vat_json_object_add_uint (node, "appns_index",
19830 clib_net_to_host_u32 (mp->appns_index));
19831 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19832 vat_json_object_add_uint (node, "scope", mp->scope);
19833 vat_json_object_add_uint (node, "action_index",
19834 clib_net_to_host_u32 (mp->action_index));
19835 vat_json_object_add_uint (node, "lcl_port",
19836 clib_net_to_host_u16 (mp->lcl_port));
19837 vat_json_object_add_uint (node, "rmt_port",
19838 clib_net_to_host_u16 (mp->rmt_port));
19839 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
19840 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
19841 vat_json_object_add_string_copy (node, "tag", mp->tag);
19842 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19844 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
19845 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19846 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
19847 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19851 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
19852 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19853 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
19854 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19859 api_session_rule_add_del (vat_main_t * vam)
19861 vl_api_session_rule_add_del_t *mp;
19862 unformat_input_t *i = vam->input;
19863 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19864 u32 appns_index = 0, scope = 0;
19865 ip4_address_t lcl_ip4, rmt_ip4;
19866 ip6_address_t lcl_ip6, rmt_ip6;
19867 u8 is_ip4 = 1, conn_set = 0;
19868 u8 is_add = 1, *tag = 0;
19870 fib_prefix_t lcl, rmt;
19872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19874 if (unformat (i, "del"))
19876 else if (unformat (i, "add"))
19878 else if (unformat (i, "proto tcp"))
19880 else if (unformat (i, "proto udp"))
19882 else if (unformat (i, "appns %d", &appns_index))
19884 else if (unformat (i, "scope %d", &scope))
19886 else if (unformat (i, "tag %_%v%_", &tag))
19890 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19891 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19899 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19900 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19906 else if (unformat (i, "action %d", &action))
19911 if (proto == ~0 || !conn_set || action == ~0)
19913 errmsg ("transport proto, connection and action must be set");
19919 errmsg ("scope should be 0-3");
19923 M (SESSION_RULE_ADD_DEL, mp);
19925 clib_memset (&lcl, 0, sizeof (lcl));
19926 clib_memset (&rmt, 0, sizeof (rmt));
19929 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
19930 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
19931 lcl.fp_len = lcl_plen;
19932 rmt.fp_len = rmt_plen;
19936 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
19937 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
19938 lcl.fp_len = lcl_plen;
19939 rmt.fp_len = rmt_plen;
19943 ip_prefix_encode (&lcl, &mp->lcl);
19944 ip_prefix_encode (&rmt, &mp->rmt);
19945 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19946 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19947 mp->transport_proto =
19948 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
19949 mp->action_index = clib_host_to_net_u32 (action);
19950 mp->appns_index = clib_host_to_net_u32 (appns_index);
19952 mp->is_add = is_add;
19955 clib_memcpy (mp->tag, tag, vec_len (tag));
19965 api_session_rules_dump (vat_main_t * vam)
19967 vl_api_session_rules_dump_t *mp;
19968 vl_api_control_ping_t *mp_ping;
19971 if (!vam->json_output)
19973 print (vam->ofp, "%=20s", "Session Rules");
19976 M (SESSION_RULES_DUMP, mp);
19980 /* Use a control ping for synchronization */
19981 MPING (CONTROL_PING, mp_ping);
19984 /* Wait for a reply... */
19990 api_ip_container_proxy_add_del (vat_main_t * vam)
19992 vl_api_ip_container_proxy_add_del_t *mp;
19993 unformat_input_t *i = vam->input;
19994 u32 sw_if_index = ~0;
19995 vl_api_prefix_t pfx = { };
19999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20001 if (unformat (i, "del"))
20003 else if (unformat (i, "add"))
20005 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
20007 else if (unformat (i, "sw_if_index %u", &sw_if_index))
20012 if (sw_if_index == ~0 || pfx.len == 0)
20014 errmsg ("address and sw_if_index must be set");
20018 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
20020 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20021 mp->is_add = is_add;
20022 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
20030 api_qos_record_enable_disable (vat_main_t * vam)
20032 unformat_input_t *i = vam->input;
20033 vl_api_qos_record_enable_disable_t *mp;
20034 u32 sw_if_index, qs = 0xff;
20035 u8 sw_if_index_set = 0;
20039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20041 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20042 sw_if_index_set = 1;
20043 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20044 sw_if_index_set = 1;
20045 else if (unformat (i, "%U", unformat_qos_source, &qs))
20047 else if (unformat (i, "disable"))
20051 clib_warning ("parse error '%U'", format_unformat_error, i);
20056 if (sw_if_index_set == 0)
20058 errmsg ("missing interface name or sw_if_index");
20063 errmsg ("input location must be specified");
20067 M (QOS_RECORD_ENABLE_DISABLE, mp);
20069 mp->record.sw_if_index = ntohl (sw_if_index);
20070 mp->record.input_source = qs;
20071 mp->enable = enable;
20080 q_or_quit (vat_main_t * vam)
20082 #if VPP_API_TEST_BUILTIN == 0
20083 longjmp (vam->jump_buf, 1);
20085 return 0; /* not so much */
20089 q (vat_main_t * vam)
20091 return q_or_quit (vam);
20095 quit (vat_main_t * vam)
20097 return q_or_quit (vam);
20101 comment (vat_main_t * vam)
20107 elog_save (vat_main_t * vam)
20109 #if VPP_API_TEST_BUILTIN == 0
20110 elog_main_t *em = &vam->elog_main;
20111 unformat_input_t *i = vam->input;
20112 char *file, *chroot_file;
20113 clib_error_t *error;
20115 if (!unformat (i, "%s", &file))
20117 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20121 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20122 if (strstr (file, "..") || index (file, '/'))
20124 errmsg ("illegal characters in filename '%s'", file);
20128 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20132 errmsg ("Saving %wd of %wd events to %s",
20133 elog_n_events_in_buffer (em),
20134 elog_buffer_capacity (em), chroot_file);
20136 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20137 vec_free (chroot_file);
20140 clib_error_report (error);
20142 errmsg ("Use the vpp event loger...");
20149 elog_setup (vat_main_t * vam)
20151 #if VPP_API_TEST_BUILTIN == 0
20152 elog_main_t *em = &vam->elog_main;
20153 unformat_input_t *i = vam->input;
20154 u32 nevents = 128 << 10;
20156 (void) unformat (i, "nevents %d", &nevents);
20158 elog_init (em, nevents);
20159 vl_api_set_elog_main (em);
20160 vl_api_set_elog_trace_api_messages (1);
20161 errmsg ("Event logger initialized with %u events", nevents);
20163 errmsg ("Use the vpp event loger...");
20169 elog_enable (vat_main_t * vam)
20171 #if VPP_API_TEST_BUILTIN == 0
20172 elog_main_t *em = &vam->elog_main;
20174 elog_enable_disable (em, 1 /* enable */ );
20175 vl_api_set_elog_trace_api_messages (1);
20176 errmsg ("Event logger enabled...");
20178 errmsg ("Use the vpp event loger...");
20184 elog_disable (vat_main_t * vam)
20186 #if VPP_API_TEST_BUILTIN == 0
20187 elog_main_t *em = &vam->elog_main;
20189 elog_enable_disable (em, 0 /* enable */ );
20190 vl_api_set_elog_trace_api_messages (1);
20191 errmsg ("Event logger disabled...");
20193 errmsg ("Use the vpp event loger...");
20199 statseg (vat_main_t * vam)
20201 ssvm_private_t *ssvmp = &vam->stat_segment;
20202 ssvm_shared_header_t *shared_header = ssvmp->sh;
20203 vlib_counter_t **counters;
20204 u64 thread0_index1_packets;
20205 u64 thread0_index1_bytes;
20206 f64 vector_rate, input_rate;
20209 uword *counter_vector_by_name;
20210 if (vam->stat_segment_lockp == 0)
20212 errmsg ("Stat segment not mapped...");
20216 /* look up "/if/rx for sw_if_index 1 as a test */
20218 clib_spinlock_lock (vam->stat_segment_lockp);
20220 counter_vector_by_name = (uword *) shared_header->opaque[1];
20222 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20225 clib_spinlock_unlock (vam->stat_segment_lockp);
20226 errmsg ("/if/tx not found?");
20230 /* Fish per-thread vector of combined counters from shared memory */
20231 counters = (vlib_counter_t **) p[0];
20233 if (vec_len (counters[0]) < 2)
20235 clib_spinlock_unlock (vam->stat_segment_lockp);
20236 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20240 /* Read thread 0 sw_if_index 1 counter */
20241 thread0_index1_packets = counters[0][1].packets;
20242 thread0_index1_bytes = counters[0][1].bytes;
20244 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20247 clib_spinlock_unlock (vam->stat_segment_lockp);
20248 errmsg ("vector_rate not found?");
20252 vector_rate = *(f64 *) (p[0]);
20253 p = hash_get_mem (counter_vector_by_name, "input_rate");
20256 clib_spinlock_unlock (vam->stat_segment_lockp);
20257 errmsg ("input_rate not found?");
20260 input_rate = *(f64 *) (p[0]);
20262 clib_spinlock_unlock (vam->stat_segment_lockp);
20264 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20265 vector_rate, input_rate);
20266 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20267 thread0_index1_packets, thread0_index1_bytes);
20273 cmd_cmp (void *a1, void *a2)
20278 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20282 help (vat_main_t * vam)
20287 unformat_input_t *i = vam->input;
20290 if (unformat (i, "%s", &name))
20294 vec_add1 (name, 0);
20296 hs = hash_get_mem (vam->help_by_name, name);
20298 print (vam->ofp, "usage: %s %s", name, hs[0]);
20300 print (vam->ofp, "No such msg / command '%s'", name);
20305 print (vam->ofp, "Help is available for the following:");
20308 hash_foreach_pair (p, vam->function_by_name,
20310 vec_add1 (cmds, (u8 *)(p->key));
20314 vec_sort_with_function (cmds, cmd_cmp);
20316 for (j = 0; j < vec_len (cmds); j++)
20317 print (vam->ofp, "%s", cmds[j]);
20324 set (vat_main_t * vam)
20326 u8 *name = 0, *value = 0;
20327 unformat_input_t *i = vam->input;
20329 if (unformat (i, "%s", &name))
20331 /* The input buffer is a vector, not a string. */
20332 value = vec_dup (i->buffer);
20333 vec_delete (value, i->index, 0);
20334 /* Almost certainly has a trailing newline */
20335 if (value[vec_len (value) - 1] == '\n')
20336 value[vec_len (value) - 1] = 0;
20337 /* Make sure it's a proper string, one way or the other */
20338 vec_add1 (value, 0);
20339 (void) clib_macro_set_value (&vam->macro_main,
20340 (char *) name, (char *) value);
20343 errmsg ("usage: set <name> <value>");
20351 unset (vat_main_t * vam)
20355 if (unformat (vam->input, "%s", &name))
20356 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20357 errmsg ("unset: %s wasn't set", name);
20370 macro_sort_cmp (void *a1, void *a2)
20372 macro_sort_t *s1 = a1;
20373 macro_sort_t *s2 = a2;
20375 return strcmp ((char *) (s1->name), (char *) (s2->name));
20379 dump_macro_table (vat_main_t * vam)
20381 macro_sort_t *sort_me = 0, *sm;
20386 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20388 vec_add2 (sort_me, sm, 1);
20389 sm->name = (u8 *)(p->key);
20390 sm->value = (u8 *) (p->value[0]);
20394 vec_sort_with_function (sort_me, macro_sort_cmp);
20396 if (vec_len (sort_me))
20397 print (vam->ofp, "%-15s%s", "Name", "Value");
20399 print (vam->ofp, "The macro table is empty...");
20401 for (i = 0; i < vec_len (sort_me); i++)
20402 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20407 dump_node_table (vat_main_t * vam)
20410 vlib_node_t *node, *next_node;
20412 if (vec_len (vam->graph_nodes) == 0)
20414 print (vam->ofp, "Node table empty, issue get_node_graph...");
20418 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20420 node = vam->graph_nodes[0][i];
20421 print (vam->ofp, "[%d] %s", i, node->name);
20422 for (j = 0; j < vec_len (node->next_nodes); j++)
20424 if (node->next_nodes[j] != ~0)
20426 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20427 print (vam->ofp, " [%d] %s", j, next_node->name);
20435 value_sort_cmp (void *a1, void *a2)
20437 name_sort_t *n1 = a1;
20438 name_sort_t *n2 = a2;
20440 if (n1->value < n2->value)
20442 if (n1->value > n2->value)
20449 dump_msg_api_table (vat_main_t * vam)
20451 api_main_t *am = vlibapi_get_main ();
20452 name_sort_t *nses = 0, *ns;
20457 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20459 vec_add2 (nses, ns, 1);
20460 ns->name = (u8 *)(hp->key);
20461 ns->value = (u32) hp->value[0];
20465 vec_sort_with_function (nses, value_sort_cmp);
20467 for (i = 0; i < vec_len (nses); i++)
20468 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20474 get_msg_id (vat_main_t * vam)
20479 if (unformat (vam->input, "%s", &name_and_crc))
20481 message_index = vl_msg_api_get_msg_index (name_and_crc);
20482 if (message_index == ~0)
20484 print (vam->ofp, " '%s' not found", name_and_crc);
20487 print (vam->ofp, " '%s' has message index %d",
20488 name_and_crc, message_index);
20491 errmsg ("name_and_crc required...");
20496 search_node_table (vat_main_t * vam)
20498 unformat_input_t *line_input = vam->input;
20501 vlib_node_t *node, *next_node;
20504 if (vam->graph_node_index_by_name == 0)
20506 print (vam->ofp, "Node table empty, issue get_node_graph...");
20510 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20512 if (unformat (line_input, "%s", &node_to_find))
20514 vec_add1 (node_to_find, 0);
20515 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20518 print (vam->ofp, "%s not found...", node_to_find);
20521 node = vam->graph_nodes[0][p[0]];
20522 print (vam->ofp, "[%d] %s", p[0], node->name);
20523 for (j = 0; j < vec_len (node->next_nodes); j++)
20525 if (node->next_nodes[j] != ~0)
20527 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20528 print (vam->ofp, " [%d] %s", j, next_node->name);
20535 clib_warning ("parse error '%U'", format_unformat_error,
20541 vec_free (node_to_find);
20550 script (vat_main_t * vam)
20552 #if (VPP_API_TEST_BUILTIN==0)
20554 char *save_current_file;
20555 unformat_input_t save_input;
20556 jmp_buf save_jump_buf;
20557 u32 save_line_number;
20559 FILE *new_fp, *save_ifp;
20561 if (unformat (vam->input, "%s", &s))
20563 new_fp = fopen ((char *) s, "r");
20566 errmsg ("Couldn't open script file %s", s);
20573 errmsg ("Missing script name");
20577 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20578 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20579 save_ifp = vam->ifp;
20580 save_line_number = vam->input_line_number;
20581 save_current_file = (char *) vam->current_file;
20583 vam->input_line_number = 0;
20585 vam->current_file = s;
20588 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20589 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20590 vam->ifp = save_ifp;
20591 vam->input_line_number = save_line_number;
20592 vam->current_file = (u8 *) save_current_file;
20597 clib_warning ("use the exec command...");
20603 echo (vat_main_t * vam)
20605 print (vam->ofp, "%v", vam->input->buffer);
20609 /* List of API message constructors, CLI names map to api_xxx */
20610 #define foreach_vpe_api_msg \
20611 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20612 _(sw_interface_dump,"") \
20613 _(sw_interface_set_flags, \
20614 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20615 _(sw_interface_add_del_address, \
20616 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20617 _(sw_interface_set_rx_mode, \
20618 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20619 _(sw_interface_set_rx_placement, \
20620 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20621 _(sw_interface_rx_placement_dump, \
20622 "[<intfc> | sw_if_index <id>]") \
20623 _(sw_interface_set_table, \
20624 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20625 _(sw_interface_set_mpls_enable, \
20626 "<intfc> | sw_if_index [disable | dis]") \
20627 _(sw_interface_set_vpath, \
20628 "<intfc> | sw_if_index <id> enable | disable") \
20629 _(sw_interface_set_vxlan_bypass, \
20630 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20631 _(sw_interface_set_geneve_bypass, \
20632 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20633 _(sw_interface_set_l2_xconnect, \
20634 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20635 "enable | disable") \
20636 _(sw_interface_set_l2_bridge, \
20637 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20638 "[shg <split-horizon-group>] [bvi]\n" \
20639 "enable | disable") \
20640 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20641 _(bridge_domain_add_del, \
20642 "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") \
20643 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20645 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20646 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20647 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20649 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20651 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20653 "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] [persist] [attach]") \
20655 "<vpp-if-name> | sw_if_index <id>") \
20656 _(sw_interface_tap_v2_dump, "") \
20657 _(virtio_pci_create, \
20658 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20659 _(virtio_pci_delete, \
20660 "<vpp-if-name> | sw_if_index <id>") \
20661 _(sw_interface_virtio_pci_dump, "") \
20663 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20664 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20667 "<vpp-if-name> | sw_if_index <id>") \
20669 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20670 _(bond_detach_slave, \
20671 "sw_if_index <n>") \
20672 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20673 _(sw_interface_bond_dump, "") \
20674 _(sw_interface_slave_dump, \
20675 "<vpp-if-name> | sw_if_index <id>") \
20676 _(ip_table_add_del, \
20677 "table <n> [ipv6] [add | del]\n") \
20678 _(ip_route_add_del, \
20679 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20680 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20681 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20682 "[multipath] [count <n>] [del]") \
20683 _(ip_mroute_add_del, \
20684 "<src> <grp>/<mask> [table-id <n>]\n" \
20685 "[<intfc> | sw_if_index <id>] [local] [del]") \
20686 _(mpls_table_add_del, \
20687 "table <n> [add | del]\n") \
20688 _(mpls_route_add_del, \
20689 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20690 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20691 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20692 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20693 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20694 "[count <n>] [del]") \
20695 _(mpls_ip_bind_unbind, \
20696 "<label> <addr/len>") \
20697 _(mpls_tunnel_add_del, \
20698 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20699 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20700 "[l2-only] [out-label <n>]") \
20701 _(sr_mpls_policy_add, \
20702 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20703 _(sr_mpls_policy_del, \
20705 _(bier_table_add_del, \
20706 "<label> <sub-domain> <set> <bsl> [del]") \
20707 _(bier_route_add_del, \
20708 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20709 "[<intfc> | sw_if_index <id>]" \
20710 "[weight <n>] [del] [multipath]") \
20711 _(sw_interface_set_unnumbered, \
20712 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20713 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20714 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20715 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20716 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20717 "[outer_vlan_id_any][inner_vlan_id_any]") \
20718 _(ip_table_replace_begin, "table <n> [ipv6]") \
20719 _(ip_table_flush, "table <n> [ipv6]") \
20720 _(ip_table_replace_end, "table <n> [ipv6]") \
20721 _(set_ip_flow_hash, \
20722 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20723 _(sw_interface_ip6_enable_disable, \
20724 "<intfc> | sw_if_index <id> enable | disable") \
20725 _(l2_patch_add_del, \
20726 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20727 "enable | disable") \
20728 _(sr_localsid_add_del, \
20729 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20730 "fib-table <num> (end.psp) sw_if_index <num>") \
20731 _(classify_add_del_table, \
20732 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20733 " [del] [del-chain] mask <mask-value>\n" \
20734 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20735 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20736 _(classify_add_del_session, \
20737 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20738 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20739 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20740 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20741 _(classify_set_interface_ip_table, \
20742 "<intfc> | sw_if_index <nn> table <nn>") \
20743 _(classify_set_interface_l2_tables, \
20744 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20745 " [other-table <nn>]") \
20746 _(get_node_index, "node <node-name") \
20747 _(add_node_next, "node <node-name> next <next-node-name>") \
20748 _(l2tpv3_create_tunnel, \
20749 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20750 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20751 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20752 _(l2tpv3_set_tunnel_cookies, \
20753 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20754 "[new_remote_cookie <nn>]\n") \
20755 _(l2tpv3_interface_enable_disable, \
20756 "<intfc> | sw_if_index <nn> enable | disable") \
20757 _(l2tpv3_set_lookup_key, \
20758 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20759 _(sw_if_l2tpv3_tunnel_dump, "") \
20760 _(vxlan_offload_rx, \
20761 "hw { <interface name> | hw_if_index <nn>} " \
20762 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20763 _(vxlan_add_del_tunnel, \
20764 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20765 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20766 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20767 _(geneve_add_del_tunnel, \
20768 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20769 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20770 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20771 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20772 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20773 _(gre_tunnel_add_del, \
20774 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20775 "[teb | erspan <session-id>] [del]") \
20776 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20777 _(l2_fib_clear_table, "") \
20778 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20779 _(l2_interface_vlan_tag_rewrite, \
20780 "<intfc> | sw_if_index <nn> \n" \
20781 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20782 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20783 _(create_vhost_user_if, \
20784 "socket <filename> [server] [renumber <dev_instance>] " \
20785 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20786 "[mac <mac_address>]") \
20787 _(modify_vhost_user_if, \
20788 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20789 "[server] [renumber <dev_instance>] [gso]") \
20790 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20791 _(sw_interface_vhost_user_dump, "") \
20792 _(show_version, "") \
20793 _(show_threads, "") \
20794 _(vxlan_gpe_add_del_tunnel, \
20795 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20796 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20797 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20798 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20799 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20800 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20801 _(interface_name_renumber, \
20802 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20803 _(input_acl_set_interface, \
20804 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20805 " [l2-table <nn>] [del]") \
20806 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20807 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20808 _(ip_dump, "ipv4 | ipv6") \
20809 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20810 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20812 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20813 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20814 " integ_alg <alg> integ_key <hex>") \
20815 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20816 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20817 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20818 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20819 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20820 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20821 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20822 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20823 " [instance <n>]") \
20824 _(ipsec_sa_dump, "[sa_id <n>]") \
20825 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20826 _(delete_loopback,"sw_if_index <nn>") \
20827 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20828 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20829 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20830 _(want_interface_events, "enable|disable") \
20831 _(get_first_msg_id, "client <name>") \
20832 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20833 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20834 "fib-id <nn> [ip4][ip6][default]") \
20835 _(get_node_graph, " ") \
20836 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20837 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20838 _(ioam_disable, "") \
20839 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20840 " sw_if_index <sw_if_index> p <priority> " \
20841 "w <weight>] [del]") \
20842 _(one_add_del_locator, "locator-set <locator_name> " \
20843 "iface <intf> | sw_if_index <sw_if_index> " \
20844 "p <priority> w <weight> [del]") \
20845 _(one_add_del_local_eid,"vni <vni> eid " \
20846 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20847 "locator-set <locator_name> [del]" \
20848 "[key-id sha1|sha256 secret-key <secret-key>]")\
20849 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20850 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20851 _(one_enable_disable, "enable|disable") \
20852 _(one_map_register_enable_disable, "enable|disable") \
20853 _(one_map_register_fallback_threshold, "<value>") \
20854 _(one_rloc_probe_enable_disable, "enable|disable") \
20855 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20857 "rloc <locator> p <prio> " \
20858 "w <weight> [rloc <loc> ... ] " \
20859 "action <action> [del-all]") \
20860 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20862 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20863 _(one_use_petr, "ip-address> | disable") \
20864 _(one_map_request_mode, "src-dst|dst-only") \
20865 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20866 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20867 _(one_locator_set_dump, "[local | remote]") \
20868 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20869 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20870 "[local] | [remote]") \
20871 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20872 _(one_ndp_bd_get, "") \
20873 _(one_ndp_entries_get, "bd <bridge-domain>") \
20874 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20875 _(one_l2_arp_bd_get, "") \
20876 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20877 _(one_stats_enable_disable, "enable|disable") \
20878 _(show_one_stats_enable_disable, "") \
20879 _(one_eid_table_vni_dump, "") \
20880 _(one_eid_table_map_dump, "l2|l3") \
20881 _(one_map_resolver_dump, "") \
20882 _(one_map_server_dump, "") \
20883 _(one_adjacencies_get, "vni <vni>") \
20884 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20885 _(show_one_rloc_probe_state, "") \
20886 _(show_one_map_register_state, "") \
20887 _(show_one_status, "") \
20888 _(one_stats_dump, "") \
20889 _(one_stats_flush, "") \
20890 _(one_get_map_request_itr_rlocs, "") \
20891 _(one_map_register_set_ttl, "<ttl>") \
20892 _(one_set_transport_protocol, "udp|api") \
20893 _(one_get_transport_protocol, "") \
20894 _(one_enable_disable_xtr_mode, "enable|disable") \
20895 _(one_show_xtr_mode, "") \
20896 _(one_enable_disable_pitr_mode, "enable|disable") \
20897 _(one_show_pitr_mode, "") \
20898 _(one_enable_disable_petr_mode, "enable|disable") \
20899 _(one_show_petr_mode, "") \
20900 _(show_one_nsh_mapping, "") \
20901 _(show_one_pitr, "") \
20902 _(show_one_use_petr, "") \
20903 _(show_one_map_request_mode, "") \
20904 _(show_one_map_register_ttl, "") \
20905 _(show_one_map_register_fallback_threshold, "") \
20906 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20907 " sw_if_index <sw_if_index> p <priority> " \
20908 "w <weight>] [del]") \
20909 _(lisp_add_del_locator, "locator-set <locator_name> " \
20910 "iface <intf> | sw_if_index <sw_if_index> " \
20911 "p <priority> w <weight> [del]") \
20912 _(lisp_add_del_local_eid,"vni <vni> eid " \
20913 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20914 "locator-set <locator_name> [del]" \
20915 "[key-id sha1|sha256 secret-key <secret-key>]") \
20916 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20917 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20918 _(lisp_enable_disable, "enable|disable") \
20919 _(lisp_map_register_enable_disable, "enable|disable") \
20920 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20921 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20923 "rloc <locator> p <prio> " \
20924 "w <weight> [rloc <loc> ... ] " \
20925 "action <action> [del-all]") \
20926 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20928 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20929 _(lisp_use_petr, "<ip-address> | disable") \
20930 _(lisp_map_request_mode, "src-dst|dst-only") \
20931 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20932 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20933 _(lisp_locator_set_dump, "[local | remote]") \
20934 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20935 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20936 "[local] | [remote]") \
20937 _(lisp_eid_table_vni_dump, "") \
20938 _(lisp_eid_table_map_dump, "l2|l3") \
20939 _(lisp_map_resolver_dump, "") \
20940 _(lisp_map_server_dump, "") \
20941 _(lisp_adjacencies_get, "vni <vni>") \
20942 _(gpe_fwd_entry_vnis_get, "") \
20943 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20944 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20945 "[table <table-id>]") \
20946 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20947 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20948 _(gpe_set_encap_mode, "lisp|vxlan") \
20949 _(gpe_get_encap_mode, "") \
20950 _(lisp_gpe_add_del_iface, "up|down") \
20951 _(lisp_gpe_enable_disable, "enable|disable") \
20952 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20953 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20954 _(show_lisp_rloc_probe_state, "") \
20955 _(show_lisp_map_register_state, "") \
20956 _(show_lisp_status, "") \
20957 _(lisp_get_map_request_itr_rlocs, "") \
20958 _(show_lisp_pitr, "") \
20959 _(show_lisp_use_petr, "") \
20960 _(show_lisp_map_request_mode, "") \
20961 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20962 _(af_packet_delete, "name <host interface name>") \
20963 _(af_packet_dump, "") \
20964 _(policer_add_del, "name <policer name> <params> [del]") \
20965 _(policer_dump, "[name <policer name>]") \
20966 _(policer_classify_set_interface, \
20967 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20968 " [l2-table <nn>] [del]") \
20969 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20970 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20971 _(mpls_table_dump, "") \
20972 _(mpls_route_dump, "table-id <ID>") \
20973 _(classify_table_ids, "") \
20974 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20975 _(classify_table_info, "table_id <nn>") \
20976 _(classify_session_dump, "table_id <nn>") \
20977 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20978 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20979 "[template_interval <nn>] [udp_checksum]") \
20980 _(ipfix_exporter_dump, "") \
20981 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20982 _(ipfix_classify_stream_dump, "") \
20983 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20984 _(ipfix_classify_table_dump, "") \
20985 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20986 _(sw_interface_span_dump, "[l2]") \
20987 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20988 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
20989 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20990 _(pg_enable_disable, "[stream <id>] disable") \
20991 _(ip_source_and_port_range_check_add_del, \
20992 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20993 _(ip_source_and_port_range_check_interface_add_del, \
20994 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20995 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20996 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20997 _(l2_interface_pbb_tag_rewrite, \
20998 "<intfc> | sw_if_index <nn> \n" \
20999 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
21000 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
21001 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
21002 _(flow_classify_set_interface, \
21003 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
21004 _(flow_classify_dump, "type [ip4|ip6]") \
21005 _(ip_table_dump, "") \
21006 _(ip_route_dump, "table-id [ip4|ip6]") \
21007 _(ip_mtable_dump, "") \
21008 _(ip_mroute_dump, "table-id [ip4|ip6]") \
21009 _(feature_enable_disable, "arc_name <arc_name> " \
21010 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
21011 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
21012 "[enable | disable] ") \
21013 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
21015 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
21016 "mac <mac-address> [del]") \
21017 _(l2_xconnect_dump, "") \
21018 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
21019 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
21020 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
21021 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
21022 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
21023 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
21024 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
21025 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
21026 _(sock_init_shm, "size <nnn>") \
21027 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
21028 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
21029 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
21030 _(session_rules_dump, "") \
21031 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
21032 _(output_acl_set_interface, \
21033 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21034 " [l2-table <nn>] [del]") \
21035 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
21037 /* List of command functions, CLI names map directly to functions */
21038 #define foreach_cli_function \
21039 _(comment, "usage: comment <ignore-rest-of-line>") \
21040 _(dump_interface_table, "usage: dump_interface_table") \
21041 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
21042 _(dump_ipv4_table, "usage: dump_ipv4_table") \
21043 _(dump_ipv6_table, "usage: dump_ipv6_table") \
21044 _(dump_macro_table, "usage: dump_macro_table ") \
21045 _(dump_node_table, "usage: dump_node_table") \
21046 _(dump_msg_api_table, "usage: dump_msg_api_table") \
21047 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
21048 _(elog_disable, "usage: elog_disable") \
21049 _(elog_enable, "usage: elog_enable") \
21050 _(elog_save, "usage: elog_save <filename>") \
21051 _(get_msg_id, "usage: get_msg_id name_and_crc") \
21052 _(echo, "usage: echo <message>") \
21053 _(exec, "usage: exec <vpe-debug-CLI-command>") \
21054 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
21055 _(help, "usage: help") \
21056 _(q, "usage: quit") \
21057 _(quit, "usage: quit") \
21058 _(search_node_table, "usage: search_node_table <name>...") \
21059 _(set, "usage: set <variable-name> <value>") \
21060 _(script, "usage: script <file-name>") \
21061 _(statseg, "usage: statseg") \
21062 _(unset, "usage: unset <variable-name>")
21065 static void vl_api_##n##_t_handler_uni \
21066 (vl_api_##n##_t * mp) \
21068 vat_main_t * vam = &vat_main; \
21069 if (vam->json_output) { \
21070 vl_api_##n##_t_handler_json(mp); \
21072 vl_api_##n##_t_handler(mp); \
21075 foreach_vpe_api_reply_msg;
21076 #if VPP_API_TEST_BUILTIN == 0
21077 foreach_standalone_reply_msg;
21082 vat_api_hookup (vat_main_t * vam)
21085 vl_msg_api_set_handlers(VL_API_##N, #n, \
21086 vl_api_##n##_t_handler_uni, \
21088 vl_api_##n##_t_endian, \
21089 vl_api_##n##_t_print, \
21090 sizeof(vl_api_##n##_t), 1);
21091 foreach_vpe_api_reply_msg;
21092 #if VPP_API_TEST_BUILTIN == 0
21093 foreach_standalone_reply_msg;
21097 #if (VPP_API_TEST_BUILTIN==0)
21098 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21100 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21102 vam->function_by_name = hash_create_string (0, sizeof (uword));
21104 vam->help_by_name = hash_create_string (0, sizeof (uword));
21107 /* API messages we can send */
21108 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21109 foreach_vpe_api_msg;
21113 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21114 foreach_vpe_api_msg;
21117 /* CLI functions */
21118 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21119 foreach_cli_function;
21123 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21124 foreach_cli_function;
21128 #if VPP_API_TEST_BUILTIN
21129 static clib_error_t *
21130 vat_api_hookup_shim (vlib_main_t * vm)
21132 vat_api_hookup (&vat_main);
21136 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21140 * fd.io coding-style-patch-verification: ON
21143 * eval: (c-set-style "gnu")