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 <vpp/api/types.h>
22 #include <vppinfra/socket.h>
23 #include <vlibapi/api.h>
24 #include <vlibmemory/api.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/ip/ip_neighbor.h>
27 #include <vnet/l2/l2_input.h>
28 #include <vnet/l2tp/l2tp.h>
29 #include <vnet/vxlan/vxlan.h>
30 #include <vnet/geneve/geneve.h>
31 #include <vnet/gre/gre.h>
32 #include <vnet/vxlan-gpe/vxlan_gpe.h>
33 #include <vnet/lisp-gpe/lisp_gpe.h>
35 #include <vpp/api/vpe_msg_enum.h>
36 #include <vnet/l2/l2_classify.h>
37 #include <vnet/l2/l2_vtr.h>
38 #include <vnet/classify/in_out_acl.h>
39 #include <vnet/classify/policer_classify.h>
40 #include <vnet/classify/flow_classify.h>
41 #include <vnet/mpls/mpls.h>
42 #include <vnet/ipsec/ipsec.h>
43 #include <vnet/ipsec/ikev2.h>
45 #include <vnet/cop/cop.h>
46 #include <vnet/ip/ip6_hop_by_hop.h>
47 #include <vnet/ip/ip_source_and_port_range_check.h>
48 #include <vnet/policer/xlate.h>
49 #include <vnet/span/span.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
52 #include <vnet/mfib/mfib_types.h>
53 #include <vnet/dhcp/dhcp_proxy.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include "vat/json_format.h"
57 #include <vnet/ip/ip_types_api.h>
58 #include <vnet/ethernet/ethernet_types_api.h>
63 #define vl_typedefs /* define message structures */
64 #include <vpp/api/vpe_all_api_h.h>
67 /* declare message handlers for each api */
69 #define vl_endianfun /* define message structures */
70 #include <vpp/api/vpe_all_api_h.h>
73 /* instantiate all the print functions we know about */
74 #define vl_print(handle, ...)
76 #include <vpp/api/vpe_all_api_h.h>
79 #define __plugin_msg_base 0
80 #include <vlibapi/vat_helper_macros.h>
82 #if VPP_API_TEST_BUILTIN == 0
86 const mac_address_t ZERO_MAC_ADDRESS = {
100 vat_socket_connect (vat_main_t * vam)
102 vam->socket_client_main = &socket_client_main;
103 return vl_socket_client_connect ((char *) vam->socket_name, "vpp_api_test",
104 0 /* default socket rx, tx buffer */ );
106 #else /* vpp built-in case, we don't do sockets... */
108 vat_socket_connect (vat_main_t * vam)
114 vl_socket_client_read (int wait)
120 vl_socket_client_write ()
126 vl_socket_client_msg_alloc (int nbytes)
134 vat_time_now (vat_main_t * vam)
136 #if VPP_API_TEST_BUILTIN
137 return vlib_time_now (vam->vlib_main);
139 return clib_time_now (&vam->clib_time);
144 errmsg (char *fmt, ...)
146 vat_main_t *vam = &vat_main;
151 s = va_format (0, fmt, &va);
156 #if VPP_API_TEST_BUILTIN
157 vlib_cli_output (vam->vlib_main, (char *) s);
160 if (vam->ifp != stdin)
161 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
162 vam->input_line_number);
163 fformat (vam->ofp, (char *) s);
171 #if VPP_API_TEST_BUILTIN == 0
173 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
175 vat_main_t *vam = va_arg (*args, vat_main_t *);
176 u32 *result = va_arg (*args, u32 *);
180 if (!unformat (input, "%s", &if_name))
183 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
191 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
196 /* Parse an IP4 address %d.%d.%d.%d. */
198 unformat_ip4_address (unformat_input_t * input, va_list * args)
200 u8 *result = va_arg (*args, u8 *);
203 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
206 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
218 unformat_ethernet_address (unformat_input_t * input, va_list * args)
220 u8 *result = va_arg (*args, u8 *);
223 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
224 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
228 for (i = 0; i < 6; i++)
229 if (a[i] >= (1 << 8))
232 for (i = 0; i < 6; i++)
238 /* Returns ethernet type as an int in host byte order. */
240 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
243 u16 *result = va_arg (*args, u16 *);
247 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
249 if (type >= (1 << 16))
257 /* Parse an IP6 address. */
259 unformat_ip6_address (unformat_input_t * input, va_list * args)
261 ip6_address_t *result = va_arg (*args, ip6_address_t *);
263 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
264 uword c, n_colon, double_colon_index;
266 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
267 double_colon_index = ARRAY_LEN (hex_quads);
268 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
271 if (c >= '0' && c <= '9')
273 else if (c >= 'a' && c <= 'f')
274 hex_digit = c + 10 - 'a';
275 else if (c >= 'A' && c <= 'F')
276 hex_digit = c + 10 - 'A';
277 else if (c == ':' && n_colon < 2)
281 unformat_put_input (input);
285 /* Too many hex quads. */
286 if (n_hex_quads >= ARRAY_LEN (hex_quads))
291 hex_quad = (hex_quad << 4) | hex_digit;
293 /* Hex quad must fit in 16 bits. */
294 if (n_hex_digits >= 4)
301 /* Save position of :: */
304 /* More than one :: ? */
305 if (double_colon_index < ARRAY_LEN (hex_quads))
307 double_colon_index = n_hex_quads;
310 if (n_colon > 0 && n_hex_digits > 0)
312 hex_quads[n_hex_quads++] = hex_quad;
318 if (n_hex_digits > 0)
319 hex_quads[n_hex_quads++] = hex_quad;
324 /* Expand :: to appropriate number of zero hex quads. */
325 if (double_colon_index < ARRAY_LEN (hex_quads))
327 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
329 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
330 hex_quads[n_zero + i] = hex_quads[i];
332 for (i = 0; i < n_zero; i++)
333 hex_quads[double_colon_index + i] = 0;
335 n_hex_quads = ARRAY_LEN (hex_quads);
338 /* Too few hex quads given. */
339 if (n_hex_quads < ARRAY_LEN (hex_quads))
342 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
343 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
350 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
352 u32 *r = va_arg (*args, u32 *);
355 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
356 foreach_ipsec_policy_action
364 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
366 u32 *r = va_arg (*args, u32 *);
369 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
370 foreach_ipsec_crypto_alg
378 format_ipsec_crypto_alg (u8 * s, va_list * args)
380 u32 i = va_arg (*args, u32);
385 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
386 foreach_ipsec_crypto_alg
389 return format (s, "unknown");
391 return format (s, "%s", t);
395 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
397 u32 *r = va_arg (*args, u32 *);
400 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
401 foreach_ipsec_integ_alg
409 format_ipsec_integ_alg (u8 * s, va_list * args)
411 u32 i = va_arg (*args, u32);
416 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
417 foreach_ipsec_integ_alg
420 return format (s, "unknown");
422 return format (s, "%s", t);
426 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
428 u32 *r = va_arg (*args, u32 *);
431 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
432 foreach_ikev2_auth_method
440 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
442 u32 *r = va_arg (*args, u32 *);
445 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
446 foreach_ikev2_id_type
452 #else /* VPP_API_TEST_BUILTIN == 1 */
454 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
456 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
457 vnet_main_t *vnm = vnet_get_main ();
458 u32 *result = va_arg (*args, u32 *);
460 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
464 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
466 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
467 vnet_main_t *vnm = vnet_get_main ();
468 u32 *result = va_arg (*args, u32 *);
470 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
473 #endif /* VPP_API_TEST_BUILTIN */
476 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
478 u8 *r = va_arg (*args, u8 *);
480 if (unformat (input, "kbps"))
481 *r = SSE2_QOS_RATE_KBPS;
482 else if (unformat (input, "pps"))
483 *r = SSE2_QOS_RATE_PPS;
490 unformat_policer_round_type (unformat_input_t * input, va_list * args)
492 u8 *r = va_arg (*args, u8 *);
494 if (unformat (input, "closest"))
495 *r = SSE2_QOS_ROUND_TO_CLOSEST;
496 else if (unformat (input, "up"))
497 *r = SSE2_QOS_ROUND_TO_UP;
498 else if (unformat (input, "down"))
499 *r = SSE2_QOS_ROUND_TO_DOWN;
506 unformat_policer_type (unformat_input_t * input, va_list * args)
508 u8 *r = va_arg (*args, u8 *);
510 if (unformat (input, "1r2c"))
511 *r = SSE2_QOS_POLICER_TYPE_1R2C;
512 else if (unformat (input, "1r3c"))
513 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
514 else if (unformat (input, "2r3c-2698"))
515 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
516 else if (unformat (input, "2r3c-4115"))
517 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
518 else if (unformat (input, "2r3c-mef5cf1"))
519 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
526 unformat_dscp (unformat_input_t * input, va_list * va)
528 u8 *r = va_arg (*va, u8 *);
531 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
540 unformat_policer_action_type (unformat_input_t * input, va_list * va)
542 sse2_qos_pol_action_params_st *a
543 = va_arg (*va, sse2_qos_pol_action_params_st *);
545 if (unformat (input, "drop"))
546 a->action_type = SSE2_QOS_ACTION_DROP;
547 else if (unformat (input, "transmit"))
548 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
549 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
550 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
557 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
559 u32 *r = va_arg (*va, u32 *);
562 if (unformat (input, "ip4"))
563 tid = POLICER_CLASSIFY_TABLE_IP4;
564 else if (unformat (input, "ip6"))
565 tid = POLICER_CLASSIFY_TABLE_IP6;
566 else if (unformat (input, "l2"))
567 tid = POLICER_CLASSIFY_TABLE_L2;
576 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
578 u32 *r = va_arg (*va, u32 *);
581 if (unformat (input, "ip4"))
582 tid = FLOW_CLASSIFY_TABLE_IP4;
583 else if (unformat (input, "ip6"))
584 tid = FLOW_CLASSIFY_TABLE_IP6;
592 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
593 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
594 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
595 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
597 #if (VPP_API_TEST_BUILTIN==0)
599 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
601 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
602 mfib_itf_attribute_t attr;
605 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
607 if (unformat (input, mfib_itf_flag_long_names[attr]))
608 *iflags |= (1 << attr);
610 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
612 if (unformat (input, mfib_itf_flag_names[attr]))
613 *iflags |= (1 << attr);
616 return (old == *iflags ? 0 : 1);
620 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
622 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
623 mfib_entry_attribute_t attr;
626 FOR_EACH_MFIB_ATTRIBUTE (attr)
628 if (unformat (input, mfib_flag_long_names[attr]))
629 *eflags |= (1 << attr);
631 FOR_EACH_MFIB_ATTRIBUTE (attr)
633 if (unformat (input, mfib_flag_names[attr]))
634 *eflags |= (1 << attr);
637 return (old == *eflags ? 0 : 1);
641 format_ip4_address (u8 * s, va_list * args)
643 u8 *a = va_arg (*args, u8 *);
644 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
648 format_ip6_address (u8 * s, va_list * args)
650 ip6_address_t *a = va_arg (*args, ip6_address_t *);
651 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
653 i_max_n_zero = ARRAY_LEN (a->as_u16);
655 i_first_zero = i_max_n_zero;
657 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
659 u32 is_zero = a->as_u16[i] == 0;
660 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
666 if ((!is_zero && n_zeros > max_n_zeros)
667 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
669 i_max_n_zero = i_first_zero;
670 max_n_zeros = n_zeros;
671 i_first_zero = ARRAY_LEN (a->as_u16);
676 last_double_colon = 0;
677 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
679 if (i == i_max_n_zero && max_n_zeros > 1)
681 s = format (s, "::");
682 i += max_n_zeros - 1;
683 last_double_colon = 1;
687 s = format (s, "%s%x",
688 (last_double_colon || i == 0) ? "" : ":",
689 clib_net_to_host_u16 (a->as_u16[i]));
690 last_double_colon = 0;
697 /* Format an IP46 address. */
699 format_ip46_address (u8 * s, va_list * args)
701 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
702 ip46_type_t type = va_arg (*args, ip46_type_t);
708 is_ip4 = ip46_address_is_ip4 (ip46);
719 format (s, "%U", format_ip4_address, &ip46->ip4) :
720 format (s, "%U", format_ip6_address, &ip46->ip6);
724 format_ethernet_address (u8 * s, va_list * args)
726 u8 *a = va_arg (*args, u8 *);
728 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
729 a[0], a[1], a[2], a[3], a[4], a[5]);
734 increment_v4_address (ip4_address_t * a)
738 v = ntohl (a->as_u32) + 1;
739 a->as_u32 = ntohl (v);
743 increment_v6_address (ip6_address_t * a)
747 v0 = clib_net_to_host_u64 (a->as_u64[0]);
748 v1 = clib_net_to_host_u64 (a->as_u64[1]);
753 a->as_u64[0] = clib_net_to_host_u64 (v0);
754 a->as_u64[1] = clib_net_to_host_u64 (v1);
758 increment_mac_address (u8 * mac)
760 u64 tmp = *((u64 *) mac);
761 tmp = clib_net_to_host_u64 (tmp);
762 tmp += 1 << 16; /* skip unused (least significant) octets */
763 tmp = clib_host_to_net_u64 (tmp);
765 clib_memcpy (mac, &tmp, 6);
768 static void vl_api_create_loopback_reply_t_handler
769 (vl_api_create_loopback_reply_t * mp)
771 vat_main_t *vam = &vat_main;
772 i32 retval = ntohl (mp->retval);
774 vam->retval = retval;
775 vam->regenerate_interface_table = 1;
776 vam->sw_if_index = ntohl (mp->sw_if_index);
777 vam->result_ready = 1;
780 static void vl_api_create_loopback_reply_t_handler_json
781 (vl_api_create_loopback_reply_t * mp)
783 vat_main_t *vam = &vat_main;
784 vat_json_node_t node;
786 vat_json_init_object (&node);
787 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
788 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
790 vat_json_print (vam->ofp, &node);
791 vat_json_free (&node);
792 vam->retval = ntohl (mp->retval);
793 vam->result_ready = 1;
796 static void vl_api_create_loopback_instance_reply_t_handler
797 (vl_api_create_loopback_instance_reply_t * mp)
799 vat_main_t *vam = &vat_main;
800 i32 retval = ntohl (mp->retval);
802 vam->retval = retval;
803 vam->regenerate_interface_table = 1;
804 vam->sw_if_index = ntohl (mp->sw_if_index);
805 vam->result_ready = 1;
808 static void vl_api_create_loopback_instance_reply_t_handler_json
809 (vl_api_create_loopback_instance_reply_t * mp)
811 vat_main_t *vam = &vat_main;
812 vat_json_node_t node;
814 vat_json_init_object (&node);
815 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
816 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
818 vat_json_print (vam->ofp, &node);
819 vat_json_free (&node);
820 vam->retval = ntohl (mp->retval);
821 vam->result_ready = 1;
824 static void vl_api_af_packet_create_reply_t_handler
825 (vl_api_af_packet_create_reply_t * mp)
827 vat_main_t *vam = &vat_main;
828 i32 retval = ntohl (mp->retval);
830 vam->retval = retval;
831 vam->regenerate_interface_table = 1;
832 vam->sw_if_index = ntohl (mp->sw_if_index);
833 vam->result_ready = 1;
836 static void vl_api_af_packet_create_reply_t_handler_json
837 (vl_api_af_packet_create_reply_t * mp)
839 vat_main_t *vam = &vat_main;
840 vat_json_node_t node;
842 vat_json_init_object (&node);
843 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
844 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
846 vat_json_print (vam->ofp, &node);
847 vat_json_free (&node);
849 vam->retval = ntohl (mp->retval);
850 vam->result_ready = 1;
853 static void vl_api_create_vlan_subif_reply_t_handler
854 (vl_api_create_vlan_subif_reply_t * mp)
856 vat_main_t *vam = &vat_main;
857 i32 retval = ntohl (mp->retval);
859 vam->retval = retval;
860 vam->regenerate_interface_table = 1;
861 vam->sw_if_index = ntohl (mp->sw_if_index);
862 vam->result_ready = 1;
865 static void vl_api_create_vlan_subif_reply_t_handler_json
866 (vl_api_create_vlan_subif_reply_t * mp)
868 vat_main_t *vam = &vat_main;
869 vat_json_node_t node;
871 vat_json_init_object (&node);
872 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
873 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
875 vat_json_print (vam->ofp, &node);
876 vat_json_free (&node);
878 vam->retval = ntohl (mp->retval);
879 vam->result_ready = 1;
882 static void vl_api_create_subif_reply_t_handler
883 (vl_api_create_subif_reply_t * mp)
885 vat_main_t *vam = &vat_main;
886 i32 retval = ntohl (mp->retval);
888 vam->retval = retval;
889 vam->regenerate_interface_table = 1;
890 vam->sw_if_index = ntohl (mp->sw_if_index);
891 vam->result_ready = 1;
894 static void vl_api_create_subif_reply_t_handler_json
895 (vl_api_create_subif_reply_t * mp)
897 vat_main_t *vam = &vat_main;
898 vat_json_node_t node;
900 vat_json_init_object (&node);
901 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
902 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
904 vat_json_print (vam->ofp, &node);
905 vat_json_free (&node);
907 vam->retval = ntohl (mp->retval);
908 vam->result_ready = 1;
911 static void vl_api_interface_name_renumber_reply_t_handler
912 (vl_api_interface_name_renumber_reply_t * mp)
914 vat_main_t *vam = &vat_main;
915 i32 retval = ntohl (mp->retval);
917 vam->retval = retval;
918 vam->regenerate_interface_table = 1;
919 vam->result_ready = 1;
922 static void vl_api_interface_name_renumber_reply_t_handler_json
923 (vl_api_interface_name_renumber_reply_t * mp)
925 vat_main_t *vam = &vat_main;
926 vat_json_node_t node;
928 vat_json_init_object (&node);
929 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
931 vat_json_print (vam->ofp, &node);
932 vat_json_free (&node);
934 vam->retval = ntohl (mp->retval);
935 vam->result_ready = 1;
939 * Special-case: build the interface table, maintain
940 * the next loopback sw_if_index vbl.
942 static void vl_api_sw_interface_details_t_handler
943 (vl_api_sw_interface_details_t * mp)
945 vat_main_t *vam = &vat_main;
946 u8 *s = format (0, "%s%c", mp->interface_name, 0);
948 hash_set_mem (vam->sw_if_index_by_interface_name, s,
949 ntohl (mp->sw_if_index));
951 /* In sub interface case, fill the sub interface table entry */
952 if (mp->sw_if_index != mp->sup_sw_if_index)
954 sw_interface_subif_t *sub = NULL;
956 vec_add2 (vam->sw_if_subif_table, sub, 1);
958 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
959 strncpy ((char *) sub->interface_name, (char *) s,
960 vec_len (sub->interface_name));
961 sub->sw_if_index = ntohl (mp->sw_if_index);
962 sub->sub_id = ntohl (mp->sub_id);
964 sub->sub_dot1ad = mp->sub_dot1ad;
965 sub->sub_number_of_tags = mp->sub_number_of_tags;
966 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
967 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
968 sub->sub_exact_match = mp->sub_exact_match;
969 sub->sub_default = mp->sub_default;
970 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
971 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
973 /* vlan tag rewrite */
974 sub->vtr_op = ntohl (mp->vtr_op);
975 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
976 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
977 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
981 static void vl_api_sw_interface_details_t_handler_json
982 (vl_api_sw_interface_details_t * mp)
984 vat_main_t *vam = &vat_main;
985 vat_json_node_t *node = NULL;
987 if (VAT_JSON_ARRAY != vam->json_tree.type)
989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
990 vat_json_init_array (&vam->json_tree);
992 node = vat_json_array_add (&vam->json_tree);
994 vat_json_init_object (node);
995 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
996 vat_json_object_add_uint (node, "sup_sw_if_index",
997 ntohl (mp->sup_sw_if_index));
998 vat_json_object_add_uint (node, "l2_address_length",
999 ntohl (mp->l2_address_length));
1000 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1001 sizeof (mp->l2_address));
1002 vat_json_object_add_string_copy (node, "interface_name",
1003 mp->interface_name);
1004 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
1005 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
1006 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1007 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1008 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1009 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1010 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
1011 vat_json_object_add_uint (node, "sub_number_of_tags",
1012 mp->sub_number_of_tags);
1013 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1014 ntohs (mp->sub_outer_vlan_id));
1015 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1016 ntohs (mp->sub_inner_vlan_id));
1017 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
1018 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
1019 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
1020 mp->sub_outer_vlan_id_any);
1021 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
1022 mp->sub_inner_vlan_id_any);
1023 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1024 vat_json_object_add_uint (node, "vtr_push_dot1q",
1025 ntohl (mp->vtr_push_dot1q));
1026 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1027 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1030 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1032 format_ethernet_address,
1034 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1036 format_ethernet_address,
1038 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1039 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1043 #if VPP_API_TEST_BUILTIN == 0
1044 static void vl_api_sw_interface_event_t_handler
1045 (vl_api_sw_interface_event_t * mp)
1047 vat_main_t *vam = &vat_main;
1048 if (vam->interface_event_display)
1049 errmsg ("interface flags: sw_if_index %d %s %s",
1050 ntohl (mp->sw_if_index),
1051 mp->admin_up_down ? "admin-up" : "admin-down",
1052 mp->link_up_down ? "link-up" : "link-down");
1056 static void vl_api_sw_interface_event_t_handler_json
1057 (vl_api_sw_interface_event_t * mp)
1059 /* JSON output not supported */
1063 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1065 vat_main_t *vam = &vat_main;
1066 i32 retval = ntohl (mp->retval);
1068 vam->retval = retval;
1069 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1070 vam->result_ready = 1;
1074 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1076 vat_main_t *vam = &vat_main;
1077 vat_json_node_t node;
1078 api_main_t *am = &api_main;
1082 vat_json_init_object (&node);
1083 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1084 vat_json_object_add_uint (&node, "reply_in_shmem",
1085 ntohl (mp->reply_in_shmem));
1086 /* Toss the shared-memory original... */
1087 pthread_mutex_lock (&am->vlib_rp->mutex);
1088 oldheap = svm_push_data_heap (am->vlib_rp);
1090 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1093 svm_pop_heap (oldheap);
1094 pthread_mutex_unlock (&am->vlib_rp->mutex);
1096 vat_json_print (vam->ofp, &node);
1097 vat_json_free (&node);
1099 vam->retval = ntohl (mp->retval);
1100 vam->result_ready = 1;
1104 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1106 vat_main_t *vam = &vat_main;
1107 i32 retval = ntohl (mp->retval);
1108 u32 length = ntohl (mp->length);
1110 vec_reset_length (vam->cmd_reply);
1112 vam->retval = retval;
1115 vec_validate (vam->cmd_reply, length);
1116 clib_memcpy ((char *) (vam->cmd_reply), mp->reply, length);
1117 vam->cmd_reply[length] = 0;
1119 vam->result_ready = 1;
1123 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1125 vat_main_t *vam = &vat_main;
1126 vat_json_node_t node;
1128 vec_reset_length (vam->cmd_reply);
1130 vat_json_init_object (&node);
1131 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1132 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1134 vat_json_print (vam->ofp, &node);
1135 vat_json_free (&node);
1137 vam->retval = ntohl (mp->retval);
1138 vam->result_ready = 1;
1141 static void vl_api_classify_add_del_table_reply_t_handler
1142 (vl_api_classify_add_del_table_reply_t * mp)
1144 vat_main_t *vam = &vat_main;
1145 i32 retval = ntohl (mp->retval);
1146 if (vam->async_mode)
1148 vam->async_errors += (retval < 0);
1152 vam->retval = retval;
1154 ((mp->new_table_index != 0xFFFFFFFF) ||
1155 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1156 (mp->match_n_vectors != 0xFFFFFFFF)))
1158 * Note: this is just barely thread-safe, depends on
1159 * the main thread spinning waiting for an answer...
1161 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1162 ntohl (mp->new_table_index),
1163 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1164 vam->result_ready = 1;
1168 static void vl_api_classify_add_del_table_reply_t_handler_json
1169 (vl_api_classify_add_del_table_reply_t * mp)
1171 vat_main_t *vam = &vat_main;
1172 vat_json_node_t node;
1174 vat_json_init_object (&node);
1175 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1176 vat_json_object_add_uint (&node, "new_table_index",
1177 ntohl (mp->new_table_index));
1178 vat_json_object_add_uint (&node, "skip_n_vectors",
1179 ntohl (mp->skip_n_vectors));
1180 vat_json_object_add_uint (&node, "match_n_vectors",
1181 ntohl (mp->match_n_vectors));
1183 vat_json_print (vam->ofp, &node);
1184 vat_json_free (&node);
1186 vam->retval = ntohl (mp->retval);
1187 vam->result_ready = 1;
1190 static void vl_api_get_node_index_reply_t_handler
1191 (vl_api_get_node_index_reply_t * mp)
1193 vat_main_t *vam = &vat_main;
1194 i32 retval = ntohl (mp->retval);
1195 if (vam->async_mode)
1197 vam->async_errors += (retval < 0);
1201 vam->retval = retval;
1203 errmsg ("node index %d", ntohl (mp->node_index));
1204 vam->result_ready = 1;
1208 static void vl_api_get_node_index_reply_t_handler_json
1209 (vl_api_get_node_index_reply_t * mp)
1211 vat_main_t *vam = &vat_main;
1212 vat_json_node_t node;
1214 vat_json_init_object (&node);
1215 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1216 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1218 vat_json_print (vam->ofp, &node);
1219 vat_json_free (&node);
1221 vam->retval = ntohl (mp->retval);
1222 vam->result_ready = 1;
1225 static void vl_api_get_next_index_reply_t_handler
1226 (vl_api_get_next_index_reply_t * mp)
1228 vat_main_t *vam = &vat_main;
1229 i32 retval = ntohl (mp->retval);
1230 if (vam->async_mode)
1232 vam->async_errors += (retval < 0);
1236 vam->retval = retval;
1238 errmsg ("next node index %d", ntohl (mp->next_index));
1239 vam->result_ready = 1;
1243 static void vl_api_get_next_index_reply_t_handler_json
1244 (vl_api_get_next_index_reply_t * mp)
1246 vat_main_t *vam = &vat_main;
1247 vat_json_node_t node;
1249 vat_json_init_object (&node);
1250 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1251 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1253 vat_json_print (vam->ofp, &node);
1254 vat_json_free (&node);
1256 vam->retval = ntohl (mp->retval);
1257 vam->result_ready = 1;
1260 static void vl_api_add_node_next_reply_t_handler
1261 (vl_api_add_node_next_reply_t * mp)
1263 vat_main_t *vam = &vat_main;
1264 i32 retval = ntohl (mp->retval);
1265 if (vam->async_mode)
1267 vam->async_errors += (retval < 0);
1271 vam->retval = retval;
1273 errmsg ("next index %d", ntohl (mp->next_index));
1274 vam->result_ready = 1;
1278 static void vl_api_add_node_next_reply_t_handler_json
1279 (vl_api_add_node_next_reply_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 vat_json_node_t node;
1284 vat_json_init_object (&node);
1285 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1286 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1288 vat_json_print (vam->ofp, &node);
1289 vat_json_free (&node);
1291 vam->retval = ntohl (mp->retval);
1292 vam->result_ready = 1;
1295 static void vl_api_show_version_reply_t_handler
1296 (vl_api_show_version_reply_t * mp)
1298 vat_main_t *vam = &vat_main;
1299 i32 retval = ntohl (mp->retval);
1303 errmsg (" program: %s", mp->program);
1304 errmsg (" version: %s", mp->version);
1305 errmsg (" build date: %s", mp->build_date);
1306 errmsg ("build directory: %s", mp->build_directory);
1308 vam->retval = retval;
1309 vam->result_ready = 1;
1312 static void vl_api_show_version_reply_t_handler_json
1313 (vl_api_show_version_reply_t * mp)
1315 vat_main_t *vam = &vat_main;
1316 vat_json_node_t node;
1318 vat_json_init_object (&node);
1319 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1320 vat_json_object_add_string_copy (&node, "program", mp->program);
1321 vat_json_object_add_string_copy (&node, "version", mp->version);
1322 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1323 vat_json_object_add_string_copy (&node, "build_directory",
1324 mp->build_directory);
1326 vat_json_print (vam->ofp, &node);
1327 vat_json_free (&node);
1329 vam->retval = ntohl (mp->retval);
1330 vam->result_ready = 1;
1333 static void vl_api_show_threads_reply_t_handler
1334 (vl_api_show_threads_reply_t * mp)
1336 vat_main_t *vam = &vat_main;
1337 i32 retval = ntohl (mp->retval);
1341 count = ntohl (mp->count);
1343 for (i = 0; i < count; i++)
1345 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1346 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1347 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1348 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1349 ntohl (mp->thread_data[i].cpu_socket));
1351 vam->retval = retval;
1352 vam->result_ready = 1;
1355 static void vl_api_show_threads_reply_t_handler_json
1356 (vl_api_show_threads_reply_t * mp)
1358 vat_main_t *vam = &vat_main;
1359 vat_json_node_t node;
1360 vl_api_thread_data_t *td;
1361 i32 retval = ntohl (mp->retval);
1365 count = ntohl (mp->count);
1367 vat_json_init_object (&node);
1368 vat_json_object_add_int (&node, "retval", retval);
1369 vat_json_object_add_uint (&node, "count", count);
1371 for (i = 0; i < count; i++)
1373 td = &mp->thread_data[i];
1374 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1375 vat_json_object_add_string_copy (&node, "name", td->name);
1376 vat_json_object_add_string_copy (&node, "type", td->type);
1377 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1378 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1379 vat_json_object_add_int (&node, "core", ntohl (td->id));
1380 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1383 vat_json_print (vam->ofp, &node);
1384 vat_json_free (&node);
1386 vam->retval = retval;
1387 vam->result_ready = 1;
1391 api_show_threads (vat_main_t * vam)
1393 vl_api_show_threads_t *mp;
1397 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1398 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1400 M (SHOW_THREADS, mp);
1408 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1410 u32 sw_if_index = ntohl (mp->sw_if_index);
1411 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1412 mp->mac_ip ? "mac/ip binding" : "address resolution",
1413 ntohl (mp->pid), format_ip4_address, &mp->address,
1414 format_ethernet_address, mp->new_mac, sw_if_index);
1418 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1420 /* JSON output not supported */
1424 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1426 u32 sw_if_index = ntohl (mp->sw_if_index);
1427 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1428 mp->mac_ip ? "mac/ip binding" : "address resolution",
1429 ntohl (mp->pid), format_ip6_address, mp->address,
1430 format_ethernet_address, mp->new_mac, sw_if_index);
1434 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1436 /* JSON output not supported */
1440 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1442 u32 n_macs = ntohl (mp->n_macs);
1443 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1444 ntohl (mp->pid), mp->client_index, n_macs);
1446 for (i = 0; i < n_macs; i++)
1448 vl_api_mac_entry_t *mac = &mp->mac[i];
1449 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1450 i + 1, ntohl (mac->sw_if_index),
1451 format_ethernet_address, mac->mac_addr, mac->action);
1458 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1460 /* JSON output not supported */
1463 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1464 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1467 * Special-case: build the bridge domain table, maintain
1468 * the next bd id vbl.
1470 static void vl_api_bridge_domain_details_t_handler
1471 (vl_api_bridge_domain_details_t * mp)
1473 vat_main_t *vam = &vat_main;
1474 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1477 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1478 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1480 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1481 ntohl (mp->bd_id), mp->learn, mp->forward,
1482 mp->flood, ntohl (mp->bvi_sw_if_index),
1483 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1487 vl_api_bridge_domain_sw_if_t *sw_ifs;
1488 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1491 sw_ifs = mp->sw_if_details;
1492 for (i = 0; i < n_sw_ifs; i++)
1498 sw_if_index = ntohl (sw_ifs->sw_if_index);
1501 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1503 if ((u32) p->value[0] == sw_if_index)
1505 sw_if_name = (u8 *)(p->key);
1510 print (vam->ofp, "%7d %3d %s", sw_if_index,
1511 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1512 "sw_if_index not found!");
1519 static void vl_api_bridge_domain_details_t_handler_json
1520 (vl_api_bridge_domain_details_t * mp)
1522 vat_main_t *vam = &vat_main;
1523 vat_json_node_t *node, *array = NULL;
1524 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1526 if (VAT_JSON_ARRAY != vam->json_tree.type)
1528 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1529 vat_json_init_array (&vam->json_tree);
1531 node = vat_json_array_add (&vam->json_tree);
1533 vat_json_init_object (node);
1534 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1535 vat_json_object_add_uint (node, "flood", mp->flood);
1536 vat_json_object_add_uint (node, "forward", mp->forward);
1537 vat_json_object_add_uint (node, "learn", mp->learn);
1538 vat_json_object_add_uint (node, "bvi_sw_if_index",
1539 ntohl (mp->bvi_sw_if_index));
1540 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1541 array = vat_json_object_add (node, "sw_if");
1542 vat_json_init_array (array);
1548 vl_api_bridge_domain_sw_if_t *sw_ifs;
1551 sw_ifs = mp->sw_if_details;
1552 for (i = 0; i < n_sw_ifs; i++)
1554 node = vat_json_array_add (array);
1555 vat_json_init_object (node);
1556 vat_json_object_add_uint (node, "sw_if_index",
1557 ntohl (sw_ifs->sw_if_index));
1558 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1564 static void vl_api_control_ping_reply_t_handler
1565 (vl_api_control_ping_reply_t * mp)
1567 vat_main_t *vam = &vat_main;
1568 i32 retval = ntohl (mp->retval);
1569 if (vam->async_mode)
1571 vam->async_errors += (retval < 0);
1575 vam->retval = retval;
1576 vam->result_ready = 1;
1578 if (vam->socket_client_main)
1579 vam->socket_client_main->control_pings_outstanding--;
1582 static void vl_api_control_ping_reply_t_handler_json
1583 (vl_api_control_ping_reply_t * mp)
1585 vat_main_t *vam = &vat_main;
1586 i32 retval = ntohl (mp->retval);
1588 if (VAT_JSON_NONE != vam->json_tree.type)
1590 vat_json_print (vam->ofp, &vam->json_tree);
1591 vat_json_free (&vam->json_tree);
1592 vam->json_tree.type = VAT_JSON_NONE;
1597 vat_json_init_array (&vam->json_tree);
1598 vat_json_print (vam->ofp, &vam->json_tree);
1599 vam->json_tree.type = VAT_JSON_NONE;
1602 vam->retval = retval;
1603 vam->result_ready = 1;
1607 vl_api_bridge_domain_set_mac_age_reply_t_handler
1608 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1610 vat_main_t *vam = &vat_main;
1611 i32 retval = ntohl (mp->retval);
1612 if (vam->async_mode)
1614 vam->async_errors += (retval < 0);
1618 vam->retval = retval;
1619 vam->result_ready = 1;
1623 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1624 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1626 vat_main_t *vam = &vat_main;
1627 vat_json_node_t node;
1629 vat_json_init_object (&node);
1630 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1632 vat_json_print (vam->ofp, &node);
1633 vat_json_free (&node);
1635 vam->retval = ntohl (mp->retval);
1636 vam->result_ready = 1;
1640 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1642 vat_main_t *vam = &vat_main;
1643 i32 retval = ntohl (mp->retval);
1644 if (vam->async_mode)
1646 vam->async_errors += (retval < 0);
1650 vam->retval = retval;
1651 vam->result_ready = 1;
1655 static void vl_api_l2_flags_reply_t_handler_json
1656 (vl_api_l2_flags_reply_t * mp)
1658 vat_main_t *vam = &vat_main;
1659 vat_json_node_t node;
1661 vat_json_init_object (&node);
1662 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1663 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1664 ntohl (mp->resulting_feature_bitmap));
1666 vat_json_print (vam->ofp, &node);
1667 vat_json_free (&node);
1669 vam->retval = ntohl (mp->retval);
1670 vam->result_ready = 1;
1673 static void vl_api_bridge_flags_reply_t_handler
1674 (vl_api_bridge_flags_reply_t * mp)
1676 vat_main_t *vam = &vat_main;
1677 i32 retval = ntohl (mp->retval);
1678 if (vam->async_mode)
1680 vam->async_errors += (retval < 0);
1684 vam->retval = retval;
1685 vam->result_ready = 1;
1689 static void vl_api_bridge_flags_reply_t_handler_json
1690 (vl_api_bridge_flags_reply_t * mp)
1692 vat_main_t *vam = &vat_main;
1693 vat_json_node_t node;
1695 vat_json_init_object (&node);
1696 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1697 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1698 ntohl (mp->resulting_feature_bitmap));
1700 vat_json_print (vam->ofp, &node);
1701 vat_json_free (&node);
1703 vam->retval = ntohl (mp->retval);
1704 vam->result_ready = 1;
1707 static void vl_api_tap_connect_reply_t_handler
1708 (vl_api_tap_connect_reply_t * mp)
1710 vat_main_t *vam = &vat_main;
1711 i32 retval = ntohl (mp->retval);
1712 if (vam->async_mode)
1714 vam->async_errors += (retval < 0);
1718 vam->retval = retval;
1719 vam->sw_if_index = ntohl (mp->sw_if_index);
1720 vam->result_ready = 1;
1725 static void vl_api_tap_connect_reply_t_handler_json
1726 (vl_api_tap_connect_reply_t * mp)
1728 vat_main_t *vam = &vat_main;
1729 vat_json_node_t node;
1731 vat_json_init_object (&node);
1732 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1733 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1735 vat_json_print (vam->ofp, &node);
1736 vat_json_free (&node);
1738 vam->retval = ntohl (mp->retval);
1739 vam->result_ready = 1;
1744 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1746 vat_main_t *vam = &vat_main;
1747 i32 retval = ntohl (mp->retval);
1748 if (vam->async_mode)
1750 vam->async_errors += (retval < 0);
1754 vam->retval = retval;
1755 vam->sw_if_index = ntohl (mp->sw_if_index);
1756 vam->result_ready = 1;
1760 static void vl_api_tap_modify_reply_t_handler_json
1761 (vl_api_tap_modify_reply_t * mp)
1763 vat_main_t *vam = &vat_main;
1764 vat_json_node_t node;
1766 vat_json_init_object (&node);
1767 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1768 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1770 vat_json_print (vam->ofp, &node);
1771 vat_json_free (&node);
1773 vam->retval = ntohl (mp->retval);
1774 vam->result_ready = 1;
1778 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1780 vat_main_t *vam = &vat_main;
1781 i32 retval = ntohl (mp->retval);
1782 if (vam->async_mode)
1784 vam->async_errors += (retval < 0);
1788 vam->retval = retval;
1789 vam->result_ready = 1;
1793 static void vl_api_tap_delete_reply_t_handler_json
1794 (vl_api_tap_delete_reply_t * mp)
1796 vat_main_t *vam = &vat_main;
1797 vat_json_node_t node;
1799 vat_json_init_object (&node);
1800 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1802 vat_json_print (vam->ofp, &node);
1803 vat_json_free (&node);
1805 vam->retval = ntohl (mp->retval);
1806 vam->result_ready = 1;
1810 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1812 vat_main_t *vam = &vat_main;
1813 i32 retval = ntohl (mp->retval);
1814 if (vam->async_mode)
1816 vam->async_errors += (retval < 0);
1820 vam->retval = retval;
1821 vam->sw_if_index = ntohl (mp->sw_if_index);
1822 vam->result_ready = 1;
1827 static void vl_api_tap_create_v2_reply_t_handler_json
1828 (vl_api_tap_create_v2_reply_t * mp)
1830 vat_main_t *vam = &vat_main;
1831 vat_json_node_t node;
1833 vat_json_init_object (&node);
1834 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1835 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1837 vat_json_print (vam->ofp, &node);
1838 vat_json_free (&node);
1840 vam->retval = ntohl (mp->retval);
1841 vam->result_ready = 1;
1846 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1848 vat_main_t *vam = &vat_main;
1849 i32 retval = ntohl (mp->retval);
1850 if (vam->async_mode)
1852 vam->async_errors += (retval < 0);
1856 vam->retval = retval;
1857 vam->result_ready = 1;
1861 static void vl_api_tap_delete_v2_reply_t_handler_json
1862 (vl_api_tap_delete_v2_reply_t * mp)
1864 vat_main_t *vam = &vat_main;
1865 vat_json_node_t node;
1867 vat_json_init_object (&node);
1868 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1870 vat_json_print (vam->ofp, &node);
1871 vat_json_free (&node);
1873 vam->retval = ntohl (mp->retval);
1874 vam->result_ready = 1;
1878 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1880 vat_main_t *vam = &vat_main;
1881 i32 retval = ntohl (mp->retval);
1883 if (vam->async_mode)
1885 vam->async_errors += (retval < 0);
1889 vam->retval = retval;
1890 vam->sw_if_index = ntohl (mp->sw_if_index);
1891 vam->result_ready = 1;
1895 static void vl_api_bond_create_reply_t_handler_json
1896 (vl_api_bond_create_reply_t * mp)
1898 vat_main_t *vam = &vat_main;
1899 vat_json_node_t node;
1901 vat_json_init_object (&node);
1902 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1903 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1905 vat_json_print (vam->ofp, &node);
1906 vat_json_free (&node);
1908 vam->retval = ntohl (mp->retval);
1909 vam->result_ready = 1;
1913 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1915 vat_main_t *vam = &vat_main;
1916 i32 retval = ntohl (mp->retval);
1918 if (vam->async_mode)
1920 vam->async_errors += (retval < 0);
1924 vam->retval = retval;
1925 vam->result_ready = 1;
1929 static void vl_api_bond_delete_reply_t_handler_json
1930 (vl_api_bond_delete_reply_t * mp)
1932 vat_main_t *vam = &vat_main;
1933 vat_json_node_t node;
1935 vat_json_init_object (&node);
1936 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1938 vat_json_print (vam->ofp, &node);
1939 vat_json_free (&node);
1941 vam->retval = ntohl (mp->retval);
1942 vam->result_ready = 1;
1946 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1948 vat_main_t *vam = &vat_main;
1949 i32 retval = ntohl (mp->retval);
1951 if (vam->async_mode)
1953 vam->async_errors += (retval < 0);
1957 vam->retval = retval;
1958 vam->result_ready = 1;
1962 static void vl_api_bond_enslave_reply_t_handler_json
1963 (vl_api_bond_enslave_reply_t * mp)
1965 vat_main_t *vam = &vat_main;
1966 vat_json_node_t node;
1968 vat_json_init_object (&node);
1969 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1971 vat_json_print (vam->ofp, &node);
1972 vat_json_free (&node);
1974 vam->retval = ntohl (mp->retval);
1975 vam->result_ready = 1;
1979 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1982 vat_main_t *vam = &vat_main;
1983 i32 retval = ntohl (mp->retval);
1985 if (vam->async_mode)
1987 vam->async_errors += (retval < 0);
1991 vam->retval = retval;
1992 vam->result_ready = 1;
1996 static void vl_api_bond_detach_slave_reply_t_handler_json
1997 (vl_api_bond_detach_slave_reply_t * mp)
1999 vat_main_t *vam = &vat_main;
2000 vat_json_node_t node;
2002 vat_json_init_object (&node);
2003 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2005 vat_json_print (vam->ofp, &node);
2006 vat_json_free (&node);
2008 vam->retval = ntohl (mp->retval);
2009 vam->result_ready = 1;
2012 static void vl_api_sw_interface_bond_details_t_handler
2013 (vl_api_sw_interface_bond_details_t * mp)
2015 vat_main_t *vam = &vat_main;
2018 "%-16s %-12d %-12U %-13U %-14u %-14u",
2019 mp->interface_name, ntohl (mp->sw_if_index),
2020 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2021 ntohl (mp->active_slaves), ntohl (mp->slaves));
2024 static void vl_api_sw_interface_bond_details_t_handler_json
2025 (vl_api_sw_interface_bond_details_t * mp)
2027 vat_main_t *vam = &vat_main;
2028 vat_json_node_t *node = NULL;
2030 if (VAT_JSON_ARRAY != vam->json_tree.type)
2032 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2033 vat_json_init_array (&vam->json_tree);
2035 node = vat_json_array_add (&vam->json_tree);
2037 vat_json_init_object (node);
2038 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2039 vat_json_object_add_string_copy (node, "interface_name",
2040 mp->interface_name);
2041 vat_json_object_add_uint (node, "mode", mp->mode);
2042 vat_json_object_add_uint (node, "load_balance", mp->lb);
2043 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2044 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2048 api_sw_interface_bond_dump (vat_main_t * vam)
2050 vl_api_sw_interface_bond_dump_t *mp;
2051 vl_api_control_ping_t *mp_ping;
2055 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2056 "interface name", "sw_if_index", "mode", "load balance",
2057 "active slaves", "slaves");
2059 /* Get list of bond interfaces */
2060 M (SW_INTERFACE_BOND_DUMP, mp);
2063 /* Use a control ping for synchronization */
2064 MPING (CONTROL_PING, mp_ping);
2071 static void vl_api_sw_interface_slave_details_t_handler
2072 (vl_api_sw_interface_slave_details_t * mp)
2074 vat_main_t *vam = &vat_main;
2077 "%-25s %-12d %-12d %d", mp->interface_name,
2078 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2081 static void vl_api_sw_interface_slave_details_t_handler_json
2082 (vl_api_sw_interface_slave_details_t * mp)
2084 vat_main_t *vam = &vat_main;
2085 vat_json_node_t *node = NULL;
2087 if (VAT_JSON_ARRAY != vam->json_tree.type)
2089 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2090 vat_json_init_array (&vam->json_tree);
2092 node = vat_json_array_add (&vam->json_tree);
2094 vat_json_init_object (node);
2095 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2096 vat_json_object_add_string_copy (node, "interface_name",
2097 mp->interface_name);
2098 vat_json_object_add_uint (node, "passive", mp->is_passive);
2099 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2103 api_sw_interface_slave_dump (vat_main_t * vam)
2105 unformat_input_t *i = vam->input;
2106 vl_api_sw_interface_slave_dump_t *mp;
2107 vl_api_control_ping_t *mp_ping;
2108 u32 sw_if_index = ~0;
2109 u8 sw_if_index_set = 0;
2112 /* Parse args required to build the message */
2113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2115 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2116 sw_if_index_set = 1;
2117 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2118 sw_if_index_set = 1;
2123 if (sw_if_index_set == 0)
2125 errmsg ("missing vpp interface name. ");
2130 "\n%-25s %-12s %-12s %s",
2131 "slave interface name", "sw_if_index", "passive", "long_timeout");
2133 /* Get list of bond interfaces */
2134 M (SW_INTERFACE_SLAVE_DUMP, mp);
2135 mp->sw_if_index = ntohl (sw_if_index);
2138 /* Use a control ping for synchronization */
2139 MPING (CONTROL_PING, mp_ping);
2146 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2147 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2149 vat_main_t *vam = &vat_main;
2150 i32 retval = ntohl (mp->retval);
2151 if (vam->async_mode)
2153 vam->async_errors += (retval < 0);
2157 vam->retval = retval;
2158 vam->sw_if_index = ntohl (mp->sw_if_index);
2159 vam->result_ready = 1;
2161 vam->regenerate_interface_table = 1;
2164 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2165 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2167 vat_main_t *vam = &vat_main;
2168 vat_json_node_t node;
2170 vat_json_init_object (&node);
2171 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2172 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2173 ntohl (mp->sw_if_index));
2175 vat_json_print (vam->ofp, &node);
2176 vat_json_free (&node);
2178 vam->retval = ntohl (mp->retval);
2179 vam->result_ready = 1;
2182 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2183 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2185 vat_main_t *vam = &vat_main;
2186 i32 retval = ntohl (mp->retval);
2187 if (vam->async_mode)
2189 vam->async_errors += (retval < 0);
2193 vam->retval = retval;
2194 vam->sw_if_index = ntohl (mp->sw_if_index);
2195 vam->result_ready = 1;
2199 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2200 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2202 vat_main_t *vam = &vat_main;
2203 vat_json_node_t node;
2205 vat_json_init_object (&node);
2206 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2207 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2209 vat_json_print (vam->ofp, &node);
2210 vat_json_free (&node);
2212 vam->retval = ntohl (mp->retval);
2213 vam->result_ready = 1;
2216 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2217 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2219 vat_main_t *vam = &vat_main;
2220 i32 retval = ntohl (mp->retval);
2221 if (vam->async_mode)
2223 vam->async_errors += (retval < 0);
2227 vam->retval = retval;
2228 vam->result_ready = 1;
2232 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2233 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2235 vat_main_t *vam = &vat_main;
2236 vat_json_node_t node;
2238 vat_json_init_object (&node);
2239 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2240 vat_json_object_add_uint (&node, "fwd_entry_index",
2241 clib_net_to_host_u32 (mp->fwd_entry_index));
2243 vat_json_print (vam->ofp, &node);
2244 vat_json_free (&node);
2246 vam->retval = ntohl (mp->retval);
2247 vam->result_ready = 1;
2251 format_lisp_transport_protocol (u8 * s, va_list * args)
2253 u32 proto = va_arg (*args, u32);
2258 return format (s, "udp");
2260 return format (s, "api");
2267 static void vl_api_one_get_transport_protocol_reply_t_handler
2268 (vl_api_one_get_transport_protocol_reply_t * mp)
2270 vat_main_t *vam = &vat_main;
2271 i32 retval = ntohl (mp->retval);
2272 if (vam->async_mode)
2274 vam->async_errors += (retval < 0);
2278 u32 proto = mp->protocol;
2279 print (vam->ofp, "Transport protocol: %U",
2280 format_lisp_transport_protocol, proto);
2281 vam->retval = retval;
2282 vam->result_ready = 1;
2286 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2287 (vl_api_one_get_transport_protocol_reply_t * mp)
2289 vat_main_t *vam = &vat_main;
2290 vat_json_node_t node;
2293 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2296 vat_json_init_object (&node);
2297 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2298 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2301 vat_json_print (vam->ofp, &node);
2302 vat_json_free (&node);
2304 vam->retval = ntohl (mp->retval);
2305 vam->result_ready = 1;
2308 static void vl_api_one_add_del_locator_set_reply_t_handler
2309 (vl_api_one_add_del_locator_set_reply_t * mp)
2311 vat_main_t *vam = &vat_main;
2312 i32 retval = ntohl (mp->retval);
2313 if (vam->async_mode)
2315 vam->async_errors += (retval < 0);
2319 vam->retval = retval;
2320 vam->result_ready = 1;
2324 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2325 (vl_api_one_add_del_locator_set_reply_t * mp)
2327 vat_main_t *vam = &vat_main;
2328 vat_json_node_t node;
2330 vat_json_init_object (&node);
2331 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2332 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2334 vat_json_print (vam->ofp, &node);
2335 vat_json_free (&node);
2337 vam->retval = ntohl (mp->retval);
2338 vam->result_ready = 1;
2341 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2342 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2344 vat_main_t *vam = &vat_main;
2345 i32 retval = ntohl (mp->retval);
2346 if (vam->async_mode)
2348 vam->async_errors += (retval < 0);
2352 vam->retval = retval;
2353 vam->sw_if_index = ntohl (mp->sw_if_index);
2354 vam->result_ready = 1;
2356 vam->regenerate_interface_table = 1;
2359 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2360 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2362 vat_main_t *vam = &vat_main;
2363 vat_json_node_t node;
2365 vat_json_init_object (&node);
2366 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2367 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2369 vat_json_print (vam->ofp, &node);
2370 vat_json_free (&node);
2372 vam->retval = ntohl (mp->retval);
2373 vam->result_ready = 1;
2376 static void vl_api_vxlan_offload_rx_reply_t_handler
2377 (vl_api_vxlan_offload_rx_reply_t * mp)
2379 vat_main_t *vam = &vat_main;
2380 i32 retval = ntohl (mp->retval);
2381 if (vam->async_mode)
2383 vam->async_errors += (retval < 0);
2387 vam->retval = retval;
2388 vam->result_ready = 1;
2392 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2393 (vl_api_vxlan_offload_rx_reply_t * mp)
2395 vat_main_t *vam = &vat_main;
2396 vat_json_node_t node;
2398 vat_json_init_object (&node);
2399 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
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_geneve_add_del_tunnel_reply_t_handler
2409 (vl_api_geneve_add_del_tunnel_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->sw_if_index = ntohl (mp->sw_if_index);
2421 vam->result_ready = 1;
2425 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2426 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2428 vat_main_t *vam = &vat_main;
2429 vat_json_node_t node;
2431 vat_json_init_object (&node);
2432 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2433 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2435 vat_json_print (vam->ofp, &node);
2436 vat_json_free (&node);
2438 vam->retval = ntohl (mp->retval);
2439 vam->result_ready = 1;
2442 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2443 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2445 vat_main_t *vam = &vat_main;
2446 i32 retval = ntohl (mp->retval);
2447 if (vam->async_mode)
2449 vam->async_errors += (retval < 0);
2453 vam->retval = retval;
2454 vam->sw_if_index = ntohl (mp->sw_if_index);
2455 vam->result_ready = 1;
2457 vam->regenerate_interface_table = 1;
2460 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2461 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2463 vat_main_t *vam = &vat_main;
2464 vat_json_node_t node;
2466 vat_json_init_object (&node);
2467 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2468 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2470 vat_json_print (vam->ofp, &node);
2471 vat_json_free (&node);
2473 vam->retval = ntohl (mp->retval);
2474 vam->result_ready = 1;
2477 static void vl_api_gre_add_del_tunnel_reply_t_handler
2478 (vl_api_gre_add_del_tunnel_reply_t * mp)
2480 vat_main_t *vam = &vat_main;
2481 i32 retval = ntohl (mp->retval);
2482 if (vam->async_mode)
2484 vam->async_errors += (retval < 0);
2488 vam->retval = retval;
2489 vam->sw_if_index = ntohl (mp->sw_if_index);
2490 vam->result_ready = 1;
2494 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2495 (vl_api_gre_add_del_tunnel_reply_t * mp)
2497 vat_main_t *vam = &vat_main;
2498 vat_json_node_t node;
2500 vat_json_init_object (&node);
2501 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2502 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2504 vat_json_print (vam->ofp, &node);
2505 vat_json_free (&node);
2507 vam->retval = ntohl (mp->retval);
2508 vam->result_ready = 1;
2511 static void vl_api_create_vhost_user_if_reply_t_handler
2512 (vl_api_create_vhost_user_if_reply_t * mp)
2514 vat_main_t *vam = &vat_main;
2515 i32 retval = ntohl (mp->retval);
2516 if (vam->async_mode)
2518 vam->async_errors += (retval < 0);
2522 vam->retval = retval;
2523 vam->sw_if_index = ntohl (mp->sw_if_index);
2524 vam->result_ready = 1;
2526 vam->regenerate_interface_table = 1;
2529 static void vl_api_create_vhost_user_if_reply_t_handler_json
2530 (vl_api_create_vhost_user_if_reply_t * mp)
2532 vat_main_t *vam = &vat_main;
2533 vat_json_node_t node;
2535 vat_json_init_object (&node);
2536 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2537 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2539 vat_json_print (vam->ofp, &node);
2540 vat_json_free (&node);
2542 vam->retval = ntohl (mp->retval);
2543 vam->result_ready = 1;
2546 static void vl_api_dns_resolve_name_reply_t_handler
2547 (vl_api_dns_resolve_name_reply_t * mp)
2549 vat_main_t *vam = &vat_main;
2550 i32 retval = ntohl (mp->retval);
2551 if (vam->async_mode)
2553 vam->async_errors += (retval < 0);
2557 vam->retval = retval;
2558 vam->result_ready = 1;
2563 clib_warning ("ip4 address %U", format_ip4_address,
2564 (ip4_address_t *) mp->ip4_address);
2566 clib_warning ("ip6 address %U", format_ip6_address,
2567 (ip6_address_t *) mp->ip6_address);
2570 clib_warning ("retval %d", retval);
2574 static void vl_api_dns_resolve_name_reply_t_handler_json
2575 (vl_api_dns_resolve_name_reply_t * mp)
2577 clib_warning ("not implemented");
2580 static void vl_api_dns_resolve_ip_reply_t_handler
2581 (vl_api_dns_resolve_ip_reply_t * mp)
2583 vat_main_t *vam = &vat_main;
2584 i32 retval = ntohl (mp->retval);
2585 if (vam->async_mode)
2587 vam->async_errors += (retval < 0);
2591 vam->retval = retval;
2592 vam->result_ready = 1;
2596 clib_warning ("canonical name %s", mp->name);
2599 clib_warning ("retval %d", retval);
2603 static void vl_api_dns_resolve_ip_reply_t_handler_json
2604 (vl_api_dns_resolve_ip_reply_t * mp)
2606 clib_warning ("not implemented");
2610 static void vl_api_ip_address_details_t_handler
2611 (vl_api_ip_address_details_t * mp)
2613 vat_main_t *vam = &vat_main;
2614 static ip_address_details_t empty_ip_address_details = { {0} };
2615 ip_address_details_t *address = NULL;
2616 ip_details_t *current_ip_details = NULL;
2617 ip_details_t *details = NULL;
2619 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2621 if (!details || vam->current_sw_if_index >= vec_len (details)
2622 || !details[vam->current_sw_if_index].present)
2624 errmsg ("ip address details arrived but not stored");
2625 errmsg ("ip_dump should be called first");
2629 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2631 #define addresses (current_ip_details->addr)
2633 vec_validate_init_empty (addresses, vec_len (addresses),
2634 empty_ip_address_details);
2636 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2638 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2639 address->prefix_length = mp->prefix_length;
2643 static void vl_api_ip_address_details_t_handler_json
2644 (vl_api_ip_address_details_t * mp)
2646 vat_main_t *vam = &vat_main;
2647 vat_json_node_t *node = NULL;
2648 struct in6_addr ip6;
2651 if (VAT_JSON_ARRAY != vam->json_tree.type)
2653 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2654 vat_json_init_array (&vam->json_tree);
2656 node = vat_json_array_add (&vam->json_tree);
2658 vat_json_init_object (node);
2661 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2662 vat_json_object_add_ip6 (node, "ip", ip6);
2666 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2667 vat_json_object_add_ip4 (node, "ip", ip4);
2669 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2673 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2675 vat_main_t *vam = &vat_main;
2676 static ip_details_t empty_ip_details = { 0 };
2677 ip_details_t *ip = NULL;
2678 u32 sw_if_index = ~0;
2680 sw_if_index = ntohl (mp->sw_if_index);
2682 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2683 sw_if_index, empty_ip_details);
2685 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2692 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2694 vat_main_t *vam = &vat_main;
2696 if (VAT_JSON_ARRAY != vam->json_tree.type)
2698 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2699 vat_json_init_array (&vam->json_tree);
2701 vat_json_array_add_uint (&vam->json_tree,
2702 clib_net_to_host_u32 (mp->sw_if_index));
2706 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2708 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2709 "router_addr %U host_mac %U",
2710 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2712 format_ip4_address, &mp->lease.host_address,
2713 format_ip4_address, &mp->lease.router_address,
2714 format_ethernet_address, mp->lease.host_mac);
2717 static void vl_api_dhcp_compl_event_t_handler_json
2718 (vl_api_dhcp_compl_event_t * mp)
2720 /* JSON output not supported */
2724 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2727 vat_main_t *vam = &vat_main;
2728 static u64 default_counter = 0;
2730 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2732 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2733 sw_if_index, default_counter);
2734 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2738 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2739 interface_counter_t counter)
2741 vat_main_t *vam = &vat_main;
2742 static interface_counter_t default_counter = { 0, };
2744 vec_validate_init_empty (vam->combined_interface_counters,
2745 vnet_counter_type, NULL);
2746 vec_validate_init_empty (vam->combined_interface_counters
2747 [vnet_counter_type], sw_if_index, default_counter);
2748 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2751 static void vl_api_vnet_interface_simple_counters_t_handler
2752 (vl_api_vnet_interface_simple_counters_t * mp)
2757 static void vl_api_vnet_interface_combined_counters_t_handler
2758 (vl_api_vnet_interface_combined_counters_t * mp)
2763 static void vl_api_vnet_interface_simple_counters_t_handler_json
2764 (vl_api_vnet_interface_simple_counters_t * mp)
2769 u32 first_sw_if_index;
2772 count = ntohl (mp->count);
2773 first_sw_if_index = ntohl (mp->first_sw_if_index);
2775 v_packets = (u64 *) & mp->data;
2776 for (i = 0; i < count; i++)
2778 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2779 set_simple_interface_counter (mp->vnet_counter_type,
2780 first_sw_if_index + i, packets);
2785 static void vl_api_vnet_interface_combined_counters_t_handler_json
2786 (vl_api_vnet_interface_combined_counters_t * mp)
2788 interface_counter_t counter;
2790 u32 first_sw_if_index;
2794 count = ntohl (mp->count);
2795 first_sw_if_index = ntohl (mp->first_sw_if_index);
2797 v = (vlib_counter_t *) & mp->data;
2798 for (i = 0; i < count; i++)
2801 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2803 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2804 set_combined_interface_counter (mp->vnet_counter_type,
2805 first_sw_if_index + i, counter);
2811 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2813 vat_main_t *vam = &vat_main;
2816 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2818 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2827 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2829 vat_main_t *vam = &vat_main;
2832 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2834 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2842 static void vl_api_vnet_ip4_fib_counters_t_handler
2843 (vl_api_vnet_ip4_fib_counters_t * mp)
2848 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2849 (vl_api_vnet_ip4_fib_counters_t * mp)
2851 vat_main_t *vam = &vat_main;
2852 vl_api_ip4_fib_counter_t *v;
2853 ip4_fib_counter_t *counter;
2860 vrf_id = ntohl (mp->vrf_id);
2861 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2862 if (~0 == vrf_index)
2864 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2865 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2866 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2867 vec_validate (vam->ip4_fib_counters, vrf_index);
2868 vam->ip4_fib_counters[vrf_index] = NULL;
2871 vec_free (vam->ip4_fib_counters[vrf_index]);
2872 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2873 count = ntohl (mp->count);
2874 for (i = 0; i < count; i++)
2876 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2877 counter = &vam->ip4_fib_counters[vrf_index][i];
2878 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2879 counter->address = ip4;
2880 counter->address_length = v->address_length;
2881 counter->packets = clib_net_to_host_u64 (v->packets);
2882 counter->bytes = clib_net_to_host_u64 (v->bytes);
2887 static void vl_api_vnet_ip4_nbr_counters_t_handler
2888 (vl_api_vnet_ip4_nbr_counters_t * mp)
2893 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2894 (vl_api_vnet_ip4_nbr_counters_t * mp)
2896 vat_main_t *vam = &vat_main;
2897 vl_api_ip4_nbr_counter_t *v;
2898 ip4_nbr_counter_t *counter;
2903 sw_if_index = ntohl (mp->sw_if_index);
2904 count = ntohl (mp->count);
2905 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2908 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2910 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2911 for (i = 0; i < count; i++)
2913 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2914 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2915 counter->address.s_addr = v->address;
2916 counter->packets = clib_net_to_host_u64 (v->packets);
2917 counter->bytes = clib_net_to_host_u64 (v->bytes);
2918 counter->linkt = v->link_type;
2923 static void vl_api_vnet_ip6_fib_counters_t_handler
2924 (vl_api_vnet_ip6_fib_counters_t * mp)
2929 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2930 (vl_api_vnet_ip6_fib_counters_t * mp)
2932 vat_main_t *vam = &vat_main;
2933 vl_api_ip6_fib_counter_t *v;
2934 ip6_fib_counter_t *counter;
2935 struct in6_addr ip6;
2941 vrf_id = ntohl (mp->vrf_id);
2942 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2943 if (~0 == vrf_index)
2945 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2946 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2947 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2948 vec_validate (vam->ip6_fib_counters, vrf_index);
2949 vam->ip6_fib_counters[vrf_index] = NULL;
2952 vec_free (vam->ip6_fib_counters[vrf_index]);
2953 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2954 count = ntohl (mp->count);
2955 for (i = 0; i < count; i++)
2957 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2958 counter = &vam->ip6_fib_counters[vrf_index][i];
2959 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2960 counter->address = ip6;
2961 counter->address_length = v->address_length;
2962 counter->packets = clib_net_to_host_u64 (v->packets);
2963 counter->bytes = clib_net_to_host_u64 (v->bytes);
2968 static void vl_api_vnet_ip6_nbr_counters_t_handler
2969 (vl_api_vnet_ip6_nbr_counters_t * mp)
2974 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2975 (vl_api_vnet_ip6_nbr_counters_t * mp)
2977 vat_main_t *vam = &vat_main;
2978 vl_api_ip6_nbr_counter_t *v;
2979 ip6_nbr_counter_t *counter;
2980 struct in6_addr ip6;
2985 sw_if_index = ntohl (mp->sw_if_index);
2986 count = ntohl (mp->count);
2987 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2990 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2992 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2993 for (i = 0; i < count; i++)
2995 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2996 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2997 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2998 counter->address = ip6;
2999 counter->packets = clib_net_to_host_u64 (v->packets);
3000 counter->bytes = clib_net_to_host_u64 (v->bytes);
3005 static void vl_api_get_first_msg_id_reply_t_handler
3006 (vl_api_get_first_msg_id_reply_t * mp)
3008 vat_main_t *vam = &vat_main;
3009 i32 retval = ntohl (mp->retval);
3011 if (vam->async_mode)
3013 vam->async_errors += (retval < 0);
3017 vam->retval = retval;
3018 vam->result_ready = 1;
3022 errmsg ("first message id %d", ntohs (mp->first_msg_id));
3026 static void vl_api_get_first_msg_id_reply_t_handler_json
3027 (vl_api_get_first_msg_id_reply_t * mp)
3029 vat_main_t *vam = &vat_main;
3030 vat_json_node_t node;
3032 vat_json_init_object (&node);
3033 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3034 vat_json_object_add_uint (&node, "first_msg_id",
3035 (uint) ntohs (mp->first_msg_id));
3037 vat_json_print (vam->ofp, &node);
3038 vat_json_free (&node);
3040 vam->retval = ntohl (mp->retval);
3041 vam->result_ready = 1;
3044 static void vl_api_get_node_graph_reply_t_handler
3045 (vl_api_get_node_graph_reply_t * mp)
3047 vat_main_t *vam = &vat_main;
3048 api_main_t *am = &api_main;
3049 i32 retval = ntohl (mp->retval);
3050 u8 *pvt_copy, *reply;
3055 if (vam->async_mode)
3057 vam->async_errors += (retval < 0);
3061 vam->retval = retval;
3062 vam->result_ready = 1;
3065 /* "Should never happen..." */
3069 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
3070 pvt_copy = vec_dup (reply);
3072 /* Toss the shared-memory original... */
3073 pthread_mutex_lock (&am->vlib_rp->mutex);
3074 oldheap = svm_push_data_heap (am->vlib_rp);
3078 svm_pop_heap (oldheap);
3079 pthread_mutex_unlock (&am->vlib_rp->mutex);
3081 if (vam->graph_nodes)
3083 hash_free (vam->graph_node_index_by_name);
3085 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
3087 node = vam->graph_nodes[0][i];
3088 vec_free (node->name);
3089 vec_free (node->next_nodes);
3092 vec_free (vam->graph_nodes[0]);
3093 vec_free (vam->graph_nodes);
3096 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
3097 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
3098 vec_free (pvt_copy);
3100 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
3102 node = vam->graph_nodes[0][i];
3103 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
3107 static void vl_api_get_node_graph_reply_t_handler_json
3108 (vl_api_get_node_graph_reply_t * mp)
3110 vat_main_t *vam = &vat_main;
3111 api_main_t *am = &api_main;
3113 vat_json_node_t node;
3116 /* $$$$ make this real? */
3117 vat_json_init_object (&node);
3118 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3119 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
3121 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
3123 /* Toss the shared-memory original... */
3124 pthread_mutex_lock (&am->vlib_rp->mutex);
3125 oldheap = svm_push_data_heap (am->vlib_rp);
3129 svm_pop_heap (oldheap);
3130 pthread_mutex_unlock (&am->vlib_rp->mutex);
3132 vat_json_print (vam->ofp, &node);
3133 vat_json_free (&node);
3135 vam->retval = ntohl (mp->retval);
3136 vam->result_ready = 1;
3140 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
3142 vat_main_t *vam = &vat_main;
3147 s = format (s, "%=16d%=16d%=16d",
3148 ntohl (mp->sw_if_index), mp->priority, mp->weight);
3152 s = format (s, "%=16U%=16d%=16d",
3153 mp->is_ipv6 ? format_ip6_address :
3155 mp->ip_address, mp->priority, mp->weight);
3158 print (vam->ofp, "%v", s);
3163 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
3165 vat_main_t *vam = &vat_main;
3166 vat_json_node_t *node = NULL;
3167 struct in6_addr ip6;
3170 if (VAT_JSON_ARRAY != vam->json_tree.type)
3172 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3173 vat_json_init_array (&vam->json_tree);
3175 node = vat_json_array_add (&vam->json_tree);
3176 vat_json_init_object (node);
3178 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
3179 vat_json_object_add_uint (node, "priority", mp->priority);
3180 vat_json_object_add_uint (node, "weight", mp->weight);
3183 vat_json_object_add_uint (node, "sw_if_index",
3184 clib_net_to_host_u32 (mp->sw_if_index));
3189 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3190 vat_json_object_add_ip6 (node, "address", ip6);
3194 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3195 vat_json_object_add_ip4 (node, "address", ip4);
3201 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
3204 vat_main_t *vam = &vat_main;
3207 ls_name = format (0, "%s", mp->ls_name);
3209 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
3215 vl_api_one_locator_set_details_t_handler_json
3216 (vl_api_one_locator_set_details_t * mp)
3218 vat_main_t *vam = &vat_main;
3219 vat_json_node_t *node = 0;
3222 ls_name = format (0, "%s", mp->ls_name);
3223 vec_add1 (ls_name, 0);
3225 if (VAT_JSON_ARRAY != vam->json_tree.type)
3227 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3228 vat_json_init_array (&vam->json_tree);
3230 node = vat_json_array_add (&vam->json_tree);
3232 vat_json_init_object (node);
3233 vat_json_object_add_string_copy (node, "ls_name", ls_name);
3234 vat_json_object_add_uint (node, "ls_index",
3235 clib_net_to_host_u32 (mp->ls_index));
3243 } __attribute__ ((__packed__)) lisp_nsh_api_t;
3246 unformat_nsh_address (unformat_input_t * input, va_list * args)
3248 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
3249 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
3253 format_nsh_address_vat (u8 * s, va_list * args)
3255 nsh_t *a = va_arg (*args, nsh_t *);
3256 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
3260 format_lisp_flat_eid (u8 * s, va_list * args)
3262 u32 type = va_arg (*args, u32);
3263 u8 *eid = va_arg (*args, u8 *);
3264 u32 eid_len = va_arg (*args, u32);
3269 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3271 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3273 return format (s, "%U", format_ethernet_address, eid);
3275 return format (s, "%U", format_nsh_address_vat, eid);
3281 format_lisp_eid_vat (u8 * s, va_list * args)
3283 u32 type = va_arg (*args, u32);
3284 u8 *eid = va_arg (*args, u8 *);
3285 u32 eid_len = va_arg (*args, u32);
3286 u8 *seid = va_arg (*args, u8 *);
3287 u32 seid_len = va_arg (*args, u32);
3288 u32 is_src_dst = va_arg (*args, u32);
3291 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3293 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3299 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3301 vat_main_t *vam = &vat_main;
3302 u8 *s = 0, *eid = 0;
3304 if (~0 == mp->locator_set_index)
3305 s = format (0, "action: %d", mp->action);
3307 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3309 eid = format (0, "%U", format_lisp_eid_vat,
3313 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3316 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3317 clib_net_to_host_u32 (mp->vni),
3319 mp->is_local ? "local" : "remote",
3320 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3321 clib_net_to_host_u16 (mp->key_id), mp->key);
3328 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3331 vat_main_t *vam = &vat_main;
3332 vat_json_node_t *node = 0;
3335 if (VAT_JSON_ARRAY != vam->json_tree.type)
3337 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3338 vat_json_init_array (&vam->json_tree);
3340 node = vat_json_array_add (&vam->json_tree);
3342 vat_json_init_object (node);
3343 if (~0 == mp->locator_set_index)
3344 vat_json_object_add_uint (node, "action", mp->action);
3346 vat_json_object_add_uint (node, "locator_set_index",
3347 clib_net_to_host_u32 (mp->locator_set_index));
3349 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3350 if (mp->eid_type == 3)
3352 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3353 vat_json_init_object (nsh_json);
3354 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3355 vat_json_object_add_uint (nsh_json, "spi",
3356 clib_net_to_host_u32 (nsh->spi));
3357 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3361 eid = format (0, "%U", format_lisp_eid_vat,
3365 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3367 vat_json_object_add_string_copy (node, "eid", eid);
3370 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3371 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3372 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3376 vat_json_object_add_uint (node, "key_id",
3377 clib_net_to_host_u16 (mp->key_id));
3378 vat_json_object_add_string_copy (node, "key", mp->key);
3383 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3385 vat_main_t *vam = &vat_main;
3386 u8 *seid = 0, *deid = 0;
3387 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3389 deid = format (0, "%U", format_lisp_eid_vat,
3390 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3392 seid = format (0, "%U", format_lisp_eid_vat,
3393 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3399 format_ip_address_fcn = format_ip4_address;
3401 format_ip_address_fcn = format_ip6_address;
3404 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3405 clib_net_to_host_u32 (mp->vni),
3407 format_ip_address_fcn, mp->lloc,
3408 format_ip_address_fcn, mp->rloc,
3409 clib_net_to_host_u32 (mp->pkt_count),
3410 clib_net_to_host_u32 (mp->bytes));
3417 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3419 struct in6_addr ip6;
3421 vat_main_t *vam = &vat_main;
3422 vat_json_node_t *node = 0;
3423 u8 *deid = 0, *seid = 0;
3425 if (VAT_JSON_ARRAY != vam->json_tree.type)
3427 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3428 vat_json_init_array (&vam->json_tree);
3430 node = vat_json_array_add (&vam->json_tree);
3432 vat_json_init_object (node);
3433 deid = format (0, "%U", format_lisp_eid_vat,
3434 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3436 seid = format (0, "%U", format_lisp_eid_vat,
3437 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3442 vat_json_object_add_string_copy (node, "seid", seid);
3443 vat_json_object_add_string_copy (node, "deid", deid);
3444 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3448 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3449 vat_json_object_add_ip4 (node, "lloc", ip4);
3450 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3451 vat_json_object_add_ip4 (node, "rloc", ip4);
3455 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3456 vat_json_object_add_ip6 (node, "lloc", ip6);
3457 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3458 vat_json_object_add_ip6 (node, "rloc", ip6);
3460 vat_json_object_add_uint (node, "pkt_count",
3461 clib_net_to_host_u32 (mp->pkt_count));
3462 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3469 vl_api_one_eid_table_map_details_t_handler
3470 (vl_api_one_eid_table_map_details_t * mp)
3472 vat_main_t *vam = &vat_main;
3474 u8 *line = format (0, "%=10d%=10d",
3475 clib_net_to_host_u32 (mp->vni),
3476 clib_net_to_host_u32 (mp->dp_table));
3477 print (vam->ofp, "%v", line);
3482 vl_api_one_eid_table_map_details_t_handler_json
3483 (vl_api_one_eid_table_map_details_t * mp)
3485 vat_main_t *vam = &vat_main;
3486 vat_json_node_t *node = NULL;
3488 if (VAT_JSON_ARRAY != vam->json_tree.type)
3490 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3491 vat_json_init_array (&vam->json_tree);
3493 node = vat_json_array_add (&vam->json_tree);
3494 vat_json_init_object (node);
3495 vat_json_object_add_uint (node, "dp_table",
3496 clib_net_to_host_u32 (mp->dp_table));
3497 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3501 vl_api_one_eid_table_vni_details_t_handler
3502 (vl_api_one_eid_table_vni_details_t * mp)
3504 vat_main_t *vam = &vat_main;
3506 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3507 print (vam->ofp, "%v", line);
3512 vl_api_one_eid_table_vni_details_t_handler_json
3513 (vl_api_one_eid_table_vni_details_t * mp)
3515 vat_main_t *vam = &vat_main;
3516 vat_json_node_t *node = NULL;
3518 if (VAT_JSON_ARRAY != vam->json_tree.type)
3520 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3521 vat_json_init_array (&vam->json_tree);
3523 node = vat_json_array_add (&vam->json_tree);
3524 vat_json_init_object (node);
3525 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3529 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3530 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3532 vat_main_t *vam = &vat_main;
3533 int retval = clib_net_to_host_u32 (mp->retval);
3535 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3536 print (vam->ofp, "fallback threshold value: %d", mp->value);
3538 vam->retval = retval;
3539 vam->result_ready = 1;
3543 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3544 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3546 vat_main_t *vam = &vat_main;
3547 vat_json_node_t _node, *node = &_node;
3548 int retval = clib_net_to_host_u32 (mp->retval);
3550 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3551 vat_json_init_object (node);
3552 vat_json_object_add_uint (node, "value", mp->value);
3554 vat_json_print (vam->ofp, node);
3555 vat_json_free (node);
3557 vam->retval = retval;
3558 vam->result_ready = 1;
3562 vl_api_show_one_map_register_state_reply_t_handler
3563 (vl_api_show_one_map_register_state_reply_t * mp)
3565 vat_main_t *vam = &vat_main;
3566 int retval = clib_net_to_host_u32 (mp->retval);
3568 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3570 vam->retval = retval;
3571 vam->result_ready = 1;
3575 vl_api_show_one_map_register_state_reply_t_handler_json
3576 (vl_api_show_one_map_register_state_reply_t * mp)
3578 vat_main_t *vam = &vat_main;
3579 vat_json_node_t _node, *node = &_node;
3580 int retval = clib_net_to_host_u32 (mp->retval);
3582 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3584 vat_json_init_object (node);
3585 vat_json_object_add_string_copy (node, "state", s);
3587 vat_json_print (vam->ofp, node);
3588 vat_json_free (node);
3590 vam->retval = retval;
3591 vam->result_ready = 1;
3596 vl_api_show_one_rloc_probe_state_reply_t_handler
3597 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3599 vat_main_t *vam = &vat_main;
3600 int retval = clib_net_to_host_u32 (mp->retval);
3605 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3607 vam->retval = retval;
3608 vam->result_ready = 1;
3612 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3613 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3615 vat_main_t *vam = &vat_main;
3616 vat_json_node_t _node, *node = &_node;
3617 int retval = clib_net_to_host_u32 (mp->retval);
3619 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3620 vat_json_init_object (node);
3621 vat_json_object_add_string_copy (node, "state", s);
3623 vat_json_print (vam->ofp, node);
3624 vat_json_free (node);
3626 vam->retval = retval;
3627 vam->result_ready = 1;
3632 vl_api_show_one_stats_enable_disable_reply_t_handler
3633 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3635 vat_main_t *vam = &vat_main;
3636 int retval = clib_net_to_host_u32 (mp->retval);
3641 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3643 vam->retval = retval;
3644 vam->result_ready = 1;
3648 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3649 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3651 vat_main_t *vam = &vat_main;
3652 vat_json_node_t _node, *node = &_node;
3653 int retval = clib_net_to_host_u32 (mp->retval);
3655 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3656 vat_json_init_object (node);
3657 vat_json_object_add_string_copy (node, "state", s);
3659 vat_json_print (vam->ofp, node);
3660 vat_json_free (node);
3662 vam->retval = retval;
3663 vam->result_ready = 1;
3668 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3670 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3671 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3672 e->vni = clib_net_to_host_u32 (e->vni);
3676 gpe_fwd_entries_get_reply_t_net_to_host
3677 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3681 mp->count = clib_net_to_host_u32 (mp->count);
3682 for (i = 0; i < mp->count; i++)
3684 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3689 format_gpe_encap_mode (u8 * s, va_list * args)
3691 u32 mode = va_arg (*args, u32);
3696 return format (s, "lisp");
3698 return format (s, "vxlan");
3704 vl_api_gpe_get_encap_mode_reply_t_handler
3705 (vl_api_gpe_get_encap_mode_reply_t * mp)
3707 vat_main_t *vam = &vat_main;
3709 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3710 vam->retval = ntohl (mp->retval);
3711 vam->result_ready = 1;
3715 vl_api_gpe_get_encap_mode_reply_t_handler_json
3716 (vl_api_gpe_get_encap_mode_reply_t * mp)
3718 vat_main_t *vam = &vat_main;
3719 vat_json_node_t node;
3721 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3722 vec_add1 (encap_mode, 0);
3724 vat_json_init_object (&node);
3725 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3727 vec_free (encap_mode);
3728 vat_json_print (vam->ofp, &node);
3729 vat_json_free (&node);
3731 vam->retval = ntohl (mp->retval);
3732 vam->result_ready = 1;
3736 vl_api_gpe_fwd_entry_path_details_t_handler
3737 (vl_api_gpe_fwd_entry_path_details_t * mp)
3739 vat_main_t *vam = &vat_main;
3740 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3742 if (mp->lcl_loc.is_ip4)
3743 format_ip_address_fcn = format_ip4_address;
3745 format_ip_address_fcn = format_ip6_address;
3747 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3748 format_ip_address_fcn, &mp->lcl_loc,
3749 format_ip_address_fcn, &mp->rmt_loc);
3753 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3755 struct in6_addr ip6;
3760 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3761 vat_json_object_add_ip4 (n, "address", ip4);
3765 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3766 vat_json_object_add_ip6 (n, "address", ip6);
3768 vat_json_object_add_uint (n, "weight", loc->weight);
3772 vl_api_gpe_fwd_entry_path_details_t_handler_json
3773 (vl_api_gpe_fwd_entry_path_details_t * mp)
3775 vat_main_t *vam = &vat_main;
3776 vat_json_node_t *node = NULL;
3777 vat_json_node_t *loc_node;
3779 if (VAT_JSON_ARRAY != vam->json_tree.type)
3781 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3782 vat_json_init_array (&vam->json_tree);
3784 node = vat_json_array_add (&vam->json_tree);
3785 vat_json_init_object (node);
3787 loc_node = vat_json_object_add (node, "local_locator");
3788 vat_json_init_object (loc_node);
3789 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3791 loc_node = vat_json_object_add (node, "remote_locator");
3792 vat_json_init_object (loc_node);
3793 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3797 vl_api_gpe_fwd_entries_get_reply_t_handler
3798 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3800 vat_main_t *vam = &vat_main;
3802 int retval = clib_net_to_host_u32 (mp->retval);
3803 vl_api_gpe_fwd_entry_t *e;
3808 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3810 for (i = 0; i < mp->count; i++)
3812 e = &mp->entries[i];
3813 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3814 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3815 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3819 vam->retval = retval;
3820 vam->result_ready = 1;
3824 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3825 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3828 vat_main_t *vam = &vat_main;
3829 vat_json_node_t *e = 0, root;
3831 int retval = clib_net_to_host_u32 (mp->retval);
3832 vl_api_gpe_fwd_entry_t *fwd;
3837 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3838 vat_json_init_array (&root);
3840 for (i = 0; i < mp->count; i++)
3842 e = vat_json_array_add (&root);
3843 fwd = &mp->entries[i];
3845 vat_json_init_object (e);
3846 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3847 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3848 vat_json_object_add_int (e, "vni", fwd->vni);
3849 vat_json_object_add_int (e, "action", fwd->action);
3851 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3852 fwd->leid_prefix_len);
3854 vat_json_object_add_string_copy (e, "leid", s);
3857 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3858 fwd->reid_prefix_len);
3860 vat_json_object_add_string_copy (e, "reid", s);
3864 vat_json_print (vam->ofp, &root);
3865 vat_json_free (&root);
3868 vam->retval = retval;
3869 vam->result_ready = 1;
3873 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3874 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3876 vat_main_t *vam = &vat_main;
3878 int retval = clib_net_to_host_u32 (mp->retval);
3879 vl_api_gpe_native_fwd_rpath_t *r;
3884 n = clib_net_to_host_u32 (mp->count);
3886 for (i = 0; i < n; i++)
3888 r = &mp->entries[i];
3889 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3890 clib_net_to_host_u32 (r->fib_index),
3891 clib_net_to_host_u32 (r->nh_sw_if_index),
3892 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3896 vam->retval = retval;
3897 vam->result_ready = 1;
3901 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3902 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3904 vat_main_t *vam = &vat_main;
3905 vat_json_node_t root, *e;
3907 int retval = clib_net_to_host_u32 (mp->retval);
3908 vl_api_gpe_native_fwd_rpath_t *r;
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 vat_json_init_object (e);
3921 r = &mp->entries[i];
3923 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3926 vat_json_object_add_string_copy (e, "ip4", s);
3929 vat_json_object_add_uint (e, "fib_index",
3930 clib_net_to_host_u32 (r->fib_index));
3931 vat_json_object_add_uint (e, "nh_sw_if_index",
3932 clib_net_to_host_u32 (r->nh_sw_if_index));
3935 vat_json_print (vam->ofp, &root);
3936 vat_json_free (&root);
3939 vam->retval = retval;
3940 vam->result_ready = 1;
3944 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3945 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3947 vat_main_t *vam = &vat_main;
3949 int retval = clib_net_to_host_u32 (mp->retval);
3954 n = clib_net_to_host_u32 (mp->count);
3956 for (i = 0; i < n; i++)
3957 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3960 vam->retval = retval;
3961 vam->result_ready = 1;
3965 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3966 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3968 vat_main_t *vam = &vat_main;
3969 vat_json_node_t root;
3971 int retval = clib_net_to_host_u32 (mp->retval);
3976 n = clib_net_to_host_u32 (mp->count);
3977 vat_json_init_array (&root);
3979 for (i = 0; i < n; i++)
3980 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3982 vat_json_print (vam->ofp, &root);
3983 vat_json_free (&root);
3986 vam->retval = retval;
3987 vam->result_ready = 1;
3991 vl_api_one_ndp_entries_get_reply_t_handler
3992 (vl_api_one_ndp_entries_get_reply_t * mp)
3994 vat_main_t *vam = &vat_main;
3996 int retval = clib_net_to_host_u32 (mp->retval);
4001 n = clib_net_to_host_u32 (mp->count);
4003 for (i = 0; i < n; i++)
4004 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
4005 format_ethernet_address, mp->entries[i].mac);
4008 vam->retval = retval;
4009 vam->result_ready = 1;
4013 vl_api_one_ndp_entries_get_reply_t_handler_json
4014 (vl_api_one_ndp_entries_get_reply_t * mp)
4017 vat_main_t *vam = &vat_main;
4018 vat_json_node_t *e = 0, root;
4020 int retval = clib_net_to_host_u32 (mp->retval);
4021 vl_api_one_ndp_entry_t *arp_entry;
4026 n = clib_net_to_host_u32 (mp->count);
4027 vat_json_init_array (&root);
4029 for (i = 0; i < n; i++)
4031 e = vat_json_array_add (&root);
4032 arp_entry = &mp->entries[i];
4034 vat_json_init_object (e);
4035 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
4038 vat_json_object_add_string_copy (e, "mac", s);
4041 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
4043 vat_json_object_add_string_copy (e, "ip6", s);
4047 vat_json_print (vam->ofp, &root);
4048 vat_json_free (&root);
4051 vam->retval = retval;
4052 vam->result_ready = 1;
4056 vl_api_one_l2_arp_entries_get_reply_t_handler
4057 (vl_api_one_l2_arp_entries_get_reply_t * mp)
4059 vat_main_t *vam = &vat_main;
4061 int retval = clib_net_to_host_u32 (mp->retval);
4066 n = clib_net_to_host_u32 (mp->count);
4068 for (i = 0; i < n; i++)
4069 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
4070 format_ethernet_address, mp->entries[i].mac);
4073 vam->retval = retval;
4074 vam->result_ready = 1;
4078 vl_api_one_l2_arp_entries_get_reply_t_handler_json
4079 (vl_api_one_l2_arp_entries_get_reply_t * mp)
4082 vat_main_t *vam = &vat_main;
4083 vat_json_node_t *e = 0, root;
4085 int retval = clib_net_to_host_u32 (mp->retval);
4086 vl_api_one_l2_arp_entry_t *arp_entry;
4091 n = clib_net_to_host_u32 (mp->count);
4092 vat_json_init_array (&root);
4094 for (i = 0; i < n; i++)
4096 e = vat_json_array_add (&root);
4097 arp_entry = &mp->entries[i];
4099 vat_json_init_object (e);
4100 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
4103 vat_json_object_add_string_copy (e, "mac", s);
4106 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
4108 vat_json_object_add_string_copy (e, "ip4", s);
4112 vat_json_print (vam->ofp, &root);
4113 vat_json_free (&root);
4116 vam->retval = retval;
4117 vam->result_ready = 1;
4121 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
4123 vat_main_t *vam = &vat_main;
4125 int retval = clib_net_to_host_u32 (mp->retval);
4130 n = clib_net_to_host_u32 (mp->count);
4132 for (i = 0; i < n; i++)
4134 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
4138 vam->retval = retval;
4139 vam->result_ready = 1;
4143 vl_api_one_ndp_bd_get_reply_t_handler_json
4144 (vl_api_one_ndp_bd_get_reply_t * mp)
4146 vat_main_t *vam = &vat_main;
4147 vat_json_node_t root;
4149 int retval = clib_net_to_host_u32 (mp->retval);
4154 n = clib_net_to_host_u32 (mp->count);
4155 vat_json_init_array (&root);
4157 for (i = 0; i < n; i++)
4159 vat_json_array_add_uint (&root,
4160 clib_net_to_host_u32 (mp->bridge_domains[i]));
4163 vat_json_print (vam->ofp, &root);
4164 vat_json_free (&root);
4167 vam->retval = retval;
4168 vam->result_ready = 1;
4172 vl_api_one_l2_arp_bd_get_reply_t_handler
4173 (vl_api_one_l2_arp_bd_get_reply_t * mp)
4175 vat_main_t *vam = &vat_main;
4177 int retval = clib_net_to_host_u32 (mp->retval);
4182 n = clib_net_to_host_u32 (mp->count);
4184 for (i = 0; i < n; i++)
4186 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
4190 vam->retval = retval;
4191 vam->result_ready = 1;
4195 vl_api_one_l2_arp_bd_get_reply_t_handler_json
4196 (vl_api_one_l2_arp_bd_get_reply_t * mp)
4198 vat_main_t *vam = &vat_main;
4199 vat_json_node_t root;
4201 int retval = clib_net_to_host_u32 (mp->retval);
4206 n = clib_net_to_host_u32 (mp->count);
4207 vat_json_init_array (&root);
4209 for (i = 0; i < n; i++)
4211 vat_json_array_add_uint (&root,
4212 clib_net_to_host_u32 (mp->bridge_domains[i]));
4215 vat_json_print (vam->ofp, &root);
4216 vat_json_free (&root);
4219 vam->retval = retval;
4220 vam->result_ready = 1;
4224 vl_api_one_adjacencies_get_reply_t_handler
4225 (vl_api_one_adjacencies_get_reply_t * mp)
4227 vat_main_t *vam = &vat_main;
4229 int retval = clib_net_to_host_u32 (mp->retval);
4230 vl_api_one_adjacency_t *a;
4235 n = clib_net_to_host_u32 (mp->count);
4237 for (i = 0; i < n; i++)
4239 a = &mp->adjacencies[i];
4240 print (vam->ofp, "%U %40U",
4241 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
4242 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
4246 vam->retval = retval;
4247 vam->result_ready = 1;
4251 vl_api_one_adjacencies_get_reply_t_handler_json
4252 (vl_api_one_adjacencies_get_reply_t * mp)
4255 vat_main_t *vam = &vat_main;
4256 vat_json_node_t *e = 0, root;
4258 int retval = clib_net_to_host_u32 (mp->retval);
4259 vl_api_one_adjacency_t *a;
4264 n = clib_net_to_host_u32 (mp->count);
4265 vat_json_init_array (&root);
4267 for (i = 0; i < n; i++)
4269 e = vat_json_array_add (&root);
4270 a = &mp->adjacencies[i];
4272 vat_json_init_object (e);
4273 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4274 a->leid_prefix_len);
4276 vat_json_object_add_string_copy (e, "leid", s);
4279 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4280 a->reid_prefix_len);
4282 vat_json_object_add_string_copy (e, "reid", s);
4286 vat_json_print (vam->ofp, &root);
4287 vat_json_free (&root);
4290 vam->retval = retval;
4291 vam->result_ready = 1;
4295 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4297 vat_main_t *vam = &vat_main;
4299 print (vam->ofp, "%=20U",
4300 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4305 vl_api_one_map_server_details_t_handler_json
4306 (vl_api_one_map_server_details_t * mp)
4308 vat_main_t *vam = &vat_main;
4309 vat_json_node_t *node = NULL;
4310 struct in6_addr ip6;
4313 if (VAT_JSON_ARRAY != vam->json_tree.type)
4315 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4316 vat_json_init_array (&vam->json_tree);
4318 node = vat_json_array_add (&vam->json_tree);
4320 vat_json_init_object (node);
4323 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4324 vat_json_object_add_ip6 (node, "map-server", ip6);
4328 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4329 vat_json_object_add_ip4 (node, "map-server", ip4);
4334 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4337 vat_main_t *vam = &vat_main;
4339 print (vam->ofp, "%=20U",
4340 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4345 vl_api_one_map_resolver_details_t_handler_json
4346 (vl_api_one_map_resolver_details_t * mp)
4348 vat_main_t *vam = &vat_main;
4349 vat_json_node_t *node = NULL;
4350 struct in6_addr ip6;
4353 if (VAT_JSON_ARRAY != vam->json_tree.type)
4355 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4356 vat_json_init_array (&vam->json_tree);
4358 node = vat_json_array_add (&vam->json_tree);
4360 vat_json_init_object (node);
4363 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4364 vat_json_object_add_ip6 (node, "map resolver", ip6);
4368 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4369 vat_json_object_add_ip4 (node, "map resolver", ip4);
4374 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4376 vat_main_t *vam = &vat_main;
4377 i32 retval = ntohl (mp->retval);
4381 print (vam->ofp, "feature: %s\ngpe: %s",
4382 mp->feature_status ? "enabled" : "disabled",
4383 mp->gpe_status ? "enabled" : "disabled");
4386 vam->retval = retval;
4387 vam->result_ready = 1;
4391 vl_api_show_one_status_reply_t_handler_json
4392 (vl_api_show_one_status_reply_t * mp)
4394 vat_main_t *vam = &vat_main;
4395 vat_json_node_t node;
4396 u8 *gpe_status = NULL;
4397 u8 *feature_status = NULL;
4399 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4400 feature_status = format (0, "%s",
4401 mp->feature_status ? "enabled" : "disabled");
4402 vec_add1 (gpe_status, 0);
4403 vec_add1 (feature_status, 0);
4405 vat_json_init_object (&node);
4406 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4407 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4409 vec_free (gpe_status);
4410 vec_free (feature_status);
4412 vat_json_print (vam->ofp, &node);
4413 vat_json_free (&node);
4415 vam->retval = ntohl (mp->retval);
4416 vam->result_ready = 1;
4420 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4421 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4423 vat_main_t *vam = &vat_main;
4424 i32 retval = ntohl (mp->retval);
4428 print (vam->ofp, "%=20s", mp->locator_set_name);
4431 vam->retval = retval;
4432 vam->result_ready = 1;
4436 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4437 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4439 vat_main_t *vam = &vat_main;
4440 vat_json_node_t *node = NULL;
4442 if (VAT_JSON_ARRAY != vam->json_tree.type)
4444 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4445 vat_json_init_array (&vam->json_tree);
4447 node = vat_json_array_add (&vam->json_tree);
4449 vat_json_init_object (node);
4450 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4452 vat_json_print (vam->ofp, node);
4453 vat_json_free (node);
4455 vam->retval = ntohl (mp->retval);
4456 vam->result_ready = 1;
4460 format_lisp_map_request_mode (u8 * s, va_list * args)
4462 u32 mode = va_arg (*args, u32);
4467 return format (0, "dst-only");
4469 return format (0, "src-dst");
4475 vl_api_show_one_map_request_mode_reply_t_handler
4476 (vl_api_show_one_map_request_mode_reply_t * mp)
4478 vat_main_t *vam = &vat_main;
4479 i32 retval = ntohl (mp->retval);
4483 u32 mode = mp->mode;
4484 print (vam->ofp, "map_request_mode: %U",
4485 format_lisp_map_request_mode, mode);
4488 vam->retval = retval;
4489 vam->result_ready = 1;
4493 vl_api_show_one_map_request_mode_reply_t_handler_json
4494 (vl_api_show_one_map_request_mode_reply_t * mp)
4496 vat_main_t *vam = &vat_main;
4497 vat_json_node_t node;
4502 s = format (0, "%U", format_lisp_map_request_mode, mode);
4505 vat_json_init_object (&node);
4506 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4507 vat_json_print (vam->ofp, &node);
4508 vat_json_free (&node);
4511 vam->retval = ntohl (mp->retval);
4512 vam->result_ready = 1;
4516 vl_api_one_show_xtr_mode_reply_t_handler
4517 (vl_api_one_show_xtr_mode_reply_t * mp)
4519 vat_main_t *vam = &vat_main;
4520 i32 retval = ntohl (mp->retval);
4524 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4527 vam->retval = retval;
4528 vam->result_ready = 1;
4532 vl_api_one_show_xtr_mode_reply_t_handler_json
4533 (vl_api_one_show_xtr_mode_reply_t * mp)
4535 vat_main_t *vam = &vat_main;
4536 vat_json_node_t node;
4539 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4540 vec_add1 (status, 0);
4542 vat_json_init_object (&node);
4543 vat_json_object_add_string_copy (&node, "status", status);
4547 vat_json_print (vam->ofp, &node);
4548 vat_json_free (&node);
4550 vam->retval = ntohl (mp->retval);
4551 vam->result_ready = 1;
4555 vl_api_one_show_pitr_mode_reply_t_handler
4556 (vl_api_one_show_pitr_mode_reply_t * mp)
4558 vat_main_t *vam = &vat_main;
4559 i32 retval = ntohl (mp->retval);
4563 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4566 vam->retval = retval;
4567 vam->result_ready = 1;
4571 vl_api_one_show_pitr_mode_reply_t_handler_json
4572 (vl_api_one_show_pitr_mode_reply_t * mp)
4574 vat_main_t *vam = &vat_main;
4575 vat_json_node_t node;
4578 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4579 vec_add1 (status, 0);
4581 vat_json_init_object (&node);
4582 vat_json_object_add_string_copy (&node, "status", status);
4586 vat_json_print (vam->ofp, &node);
4587 vat_json_free (&node);
4589 vam->retval = ntohl (mp->retval);
4590 vam->result_ready = 1;
4594 vl_api_one_show_petr_mode_reply_t_handler
4595 (vl_api_one_show_petr_mode_reply_t * mp)
4597 vat_main_t *vam = &vat_main;
4598 i32 retval = ntohl (mp->retval);
4602 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4605 vam->retval = retval;
4606 vam->result_ready = 1;
4610 vl_api_one_show_petr_mode_reply_t_handler_json
4611 (vl_api_one_show_petr_mode_reply_t * mp)
4613 vat_main_t *vam = &vat_main;
4614 vat_json_node_t node;
4617 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4618 vec_add1 (status, 0);
4620 vat_json_init_object (&node);
4621 vat_json_object_add_string_copy (&node, "status", status);
4625 vat_json_print (vam->ofp, &node);
4626 vat_json_free (&node);
4628 vam->retval = ntohl (mp->retval);
4629 vam->result_ready = 1;
4633 vl_api_show_one_use_petr_reply_t_handler
4634 (vl_api_show_one_use_petr_reply_t * mp)
4636 vat_main_t *vam = &vat_main;
4637 i32 retval = ntohl (mp->retval);
4641 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4644 print (vam->ofp, "Proxy-ETR address; %U",
4645 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4650 vam->retval = retval;
4651 vam->result_ready = 1;
4655 vl_api_show_one_use_petr_reply_t_handler_json
4656 (vl_api_show_one_use_petr_reply_t * mp)
4658 vat_main_t *vam = &vat_main;
4659 vat_json_node_t node;
4662 struct in6_addr ip6;
4664 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4665 vec_add1 (status, 0);
4667 vat_json_init_object (&node);
4668 vat_json_object_add_string_copy (&node, "status", status);
4673 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4674 vat_json_object_add_ip6 (&node, "address", ip6);
4678 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4679 vat_json_object_add_ip4 (&node, "address", ip4);
4685 vat_json_print (vam->ofp, &node);
4686 vat_json_free (&node);
4688 vam->retval = ntohl (mp->retval);
4689 vam->result_ready = 1;
4693 vl_api_show_one_nsh_mapping_reply_t_handler
4694 (vl_api_show_one_nsh_mapping_reply_t * mp)
4696 vat_main_t *vam = &vat_main;
4697 i32 retval = ntohl (mp->retval);
4701 print (vam->ofp, "%-20s%-16s",
4702 mp->is_set ? "set" : "not-set",
4703 mp->is_set ? (char *) mp->locator_set_name : "");
4706 vam->retval = retval;
4707 vam->result_ready = 1;
4711 vl_api_show_one_nsh_mapping_reply_t_handler_json
4712 (vl_api_show_one_nsh_mapping_reply_t * mp)
4714 vat_main_t *vam = &vat_main;
4715 vat_json_node_t node;
4718 status = format (0, "%s", mp->is_set ? "yes" : "no");
4719 vec_add1 (status, 0);
4721 vat_json_init_object (&node);
4722 vat_json_object_add_string_copy (&node, "is_set", status);
4725 vat_json_object_add_string_copy (&node, "locator_set",
4726 mp->locator_set_name);
4731 vat_json_print (vam->ofp, &node);
4732 vat_json_free (&node);
4734 vam->retval = ntohl (mp->retval);
4735 vam->result_ready = 1;
4739 vl_api_show_one_map_register_ttl_reply_t_handler
4740 (vl_api_show_one_map_register_ttl_reply_t * mp)
4742 vat_main_t *vam = &vat_main;
4743 i32 retval = ntohl (mp->retval);
4745 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4749 print (vam->ofp, "ttl: %u", mp->ttl);
4752 vam->retval = retval;
4753 vam->result_ready = 1;
4757 vl_api_show_one_map_register_ttl_reply_t_handler_json
4758 (vl_api_show_one_map_register_ttl_reply_t * mp)
4760 vat_main_t *vam = &vat_main;
4761 vat_json_node_t node;
4763 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4764 vat_json_init_object (&node);
4765 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4767 vat_json_print (vam->ofp, &node);
4768 vat_json_free (&node);
4770 vam->retval = ntohl (mp->retval);
4771 vam->result_ready = 1;
4775 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4777 vat_main_t *vam = &vat_main;
4778 i32 retval = ntohl (mp->retval);
4782 print (vam->ofp, "%-20s%-16s",
4783 mp->status ? "enabled" : "disabled",
4784 mp->status ? (char *) mp->locator_set_name : "");
4787 vam->retval = retval;
4788 vam->result_ready = 1;
4792 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4794 vat_main_t *vam = &vat_main;
4795 vat_json_node_t node;
4798 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4799 vec_add1 (status, 0);
4801 vat_json_init_object (&node);
4802 vat_json_object_add_string_copy (&node, "status", status);
4805 vat_json_object_add_string_copy (&node, "locator_set",
4806 mp->locator_set_name);
4811 vat_json_print (vam->ofp, &node);
4812 vat_json_free (&node);
4814 vam->retval = ntohl (mp->retval);
4815 vam->result_ready = 1;
4819 format_policer_type (u8 * s, va_list * va)
4821 u32 i = va_arg (*va, u32);
4823 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4824 s = format (s, "1r2c");
4825 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4826 s = format (s, "1r3c");
4827 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4828 s = format (s, "2r3c-2698");
4829 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4830 s = format (s, "2r3c-4115");
4831 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4832 s = format (s, "2r3c-mef5cf1");
4834 s = format (s, "ILLEGAL");
4839 format_policer_rate_type (u8 * s, va_list * va)
4841 u32 i = va_arg (*va, u32);
4843 if (i == SSE2_QOS_RATE_KBPS)
4844 s = format (s, "kbps");
4845 else if (i == SSE2_QOS_RATE_PPS)
4846 s = format (s, "pps");
4848 s = format (s, "ILLEGAL");
4853 format_policer_round_type (u8 * s, va_list * va)
4855 u32 i = va_arg (*va, u32);
4857 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4858 s = format (s, "closest");
4859 else if (i == SSE2_QOS_ROUND_TO_UP)
4860 s = format (s, "up");
4861 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4862 s = format (s, "down");
4864 s = format (s, "ILLEGAL");
4869 format_policer_action_type (u8 * s, va_list * va)
4871 u32 i = va_arg (*va, u32);
4873 if (i == SSE2_QOS_ACTION_DROP)
4874 s = format (s, "drop");
4875 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4876 s = format (s, "transmit");
4877 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4878 s = format (s, "mark-and-transmit");
4880 s = format (s, "ILLEGAL");
4885 format_dscp (u8 * s, va_list * va)
4887 u32 i = va_arg (*va, u32);
4892 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4896 return format (s, "ILLEGAL");
4898 s = format (s, "%s", t);
4903 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4905 vat_main_t *vam = &vat_main;
4906 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4908 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4909 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4911 conform_dscp_str = format (0, "");
4913 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4914 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4916 exceed_dscp_str = format (0, "");
4918 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4919 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4921 violate_dscp_str = format (0, "");
4923 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4924 "rate type %U, round type %U, %s rate, %s color-aware, "
4925 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4926 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4927 "conform action %U%s, exceed action %U%s, violate action %U%s",
4929 format_policer_type, mp->type,
4932 clib_net_to_host_u64 (mp->cb),
4933 clib_net_to_host_u64 (mp->eb),
4934 format_policer_rate_type, mp->rate_type,
4935 format_policer_round_type, mp->round_type,
4936 mp->single_rate ? "single" : "dual",
4937 mp->color_aware ? "is" : "not",
4938 ntohl (mp->cir_tokens_per_period),
4939 ntohl (mp->pir_tokens_per_period),
4941 ntohl (mp->current_limit),
4942 ntohl (mp->current_bucket),
4943 ntohl (mp->extended_limit),
4944 ntohl (mp->extended_bucket),
4945 clib_net_to_host_u64 (mp->last_update_time),
4946 format_policer_action_type, mp->conform_action_type,
4948 format_policer_action_type, mp->exceed_action_type,
4950 format_policer_action_type, mp->violate_action_type,
4953 vec_free (conform_dscp_str);
4954 vec_free (exceed_dscp_str);
4955 vec_free (violate_dscp_str);
4958 static void vl_api_policer_details_t_handler_json
4959 (vl_api_policer_details_t * mp)
4961 vat_main_t *vam = &vat_main;
4962 vat_json_node_t *node;
4963 u8 *rate_type_str, *round_type_str, *type_str;
4964 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4966 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4968 format (0, "%U", format_policer_round_type, mp->round_type);
4969 type_str = format (0, "%U", format_policer_type, mp->type);
4970 conform_action_str = format (0, "%U", format_policer_action_type,
4971 mp->conform_action_type);
4972 exceed_action_str = format (0, "%U", format_policer_action_type,
4973 mp->exceed_action_type);
4974 violate_action_str = format (0, "%U", format_policer_action_type,
4975 mp->violate_action_type);
4977 if (VAT_JSON_ARRAY != vam->json_tree.type)
4979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4980 vat_json_init_array (&vam->json_tree);
4982 node = vat_json_array_add (&vam->json_tree);
4984 vat_json_init_object (node);
4985 vat_json_object_add_string_copy (node, "name", mp->name);
4986 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4987 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4988 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4989 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4990 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4991 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4992 vat_json_object_add_string_copy (node, "type", type_str);
4993 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4994 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4995 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4996 vat_json_object_add_uint (node, "cir_tokens_per_period",
4997 ntohl (mp->cir_tokens_per_period));
4998 vat_json_object_add_uint (node, "eir_tokens_per_period",
4999 ntohl (mp->pir_tokens_per_period));
5000 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
5001 vat_json_object_add_uint (node, "current_bucket",
5002 ntohl (mp->current_bucket));
5003 vat_json_object_add_uint (node, "extended_limit",
5004 ntohl (mp->extended_limit));
5005 vat_json_object_add_uint (node, "extended_bucket",
5006 ntohl (mp->extended_bucket));
5007 vat_json_object_add_uint (node, "last_update_time",
5008 ntohl (mp->last_update_time));
5009 vat_json_object_add_string_copy (node, "conform_action",
5010 conform_action_str);
5011 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5013 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
5014 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
5015 vec_free (dscp_str);
5017 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
5018 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5020 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
5021 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
5022 vec_free (dscp_str);
5024 vat_json_object_add_string_copy (node, "violate_action",
5025 violate_action_str);
5026 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
5028 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
5029 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
5030 vec_free (dscp_str);
5033 vec_free (rate_type_str);
5034 vec_free (round_type_str);
5035 vec_free (type_str);
5036 vec_free (conform_action_str);
5037 vec_free (exceed_action_str);
5038 vec_free (violate_action_str);
5042 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
5045 vat_main_t *vam = &vat_main;
5046 int i, count = ntohl (mp->count);
5049 print (vam->ofp, "classify table ids (%d) : ", count);
5050 for (i = 0; i < count; i++)
5052 print (vam->ofp, "%d", ntohl (mp->ids[i]));
5053 print (vam->ofp, (i < count - 1) ? "," : "");
5055 vam->retval = ntohl (mp->retval);
5056 vam->result_ready = 1;
5060 vl_api_classify_table_ids_reply_t_handler_json
5061 (vl_api_classify_table_ids_reply_t * mp)
5063 vat_main_t *vam = &vat_main;
5064 int i, count = ntohl (mp->count);
5068 vat_json_node_t node;
5070 vat_json_init_object (&node);
5071 for (i = 0; i < count; i++)
5073 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
5075 vat_json_print (vam->ofp, &node);
5076 vat_json_free (&node);
5078 vam->retval = ntohl (mp->retval);
5079 vam->result_ready = 1;
5083 vl_api_classify_table_by_interface_reply_t_handler
5084 (vl_api_classify_table_by_interface_reply_t * mp)
5086 vat_main_t *vam = &vat_main;
5089 table_id = ntohl (mp->l2_table_id);
5091 print (vam->ofp, "l2 table id : %d", table_id);
5093 print (vam->ofp, "l2 table id : No input ACL tables configured");
5094 table_id = ntohl (mp->ip4_table_id);
5096 print (vam->ofp, "ip4 table id : %d", table_id);
5098 print (vam->ofp, "ip4 table id : No input ACL tables configured");
5099 table_id = ntohl (mp->ip6_table_id);
5101 print (vam->ofp, "ip6 table id : %d", table_id);
5103 print (vam->ofp, "ip6 table id : No input ACL tables configured");
5104 vam->retval = ntohl (mp->retval);
5105 vam->result_ready = 1;
5109 vl_api_classify_table_by_interface_reply_t_handler_json
5110 (vl_api_classify_table_by_interface_reply_t * mp)
5112 vat_main_t *vam = &vat_main;
5113 vat_json_node_t node;
5115 vat_json_init_object (&node);
5117 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
5118 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
5119 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
5121 vat_json_print (vam->ofp, &node);
5122 vat_json_free (&node);
5124 vam->retval = ntohl (mp->retval);
5125 vam->result_ready = 1;
5128 static void vl_api_policer_add_del_reply_t_handler
5129 (vl_api_policer_add_del_reply_t * mp)
5131 vat_main_t *vam = &vat_main;
5132 i32 retval = ntohl (mp->retval);
5133 if (vam->async_mode)
5135 vam->async_errors += (retval < 0);
5139 vam->retval = retval;
5140 vam->result_ready = 1;
5141 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
5143 * Note: this is just barely thread-safe, depends on
5144 * the main thread spinning waiting for an answer...
5146 errmsg ("policer index %d", ntohl (mp->policer_index));
5150 static void vl_api_policer_add_del_reply_t_handler_json
5151 (vl_api_policer_add_del_reply_t * mp)
5153 vat_main_t *vam = &vat_main;
5154 vat_json_node_t node;
5156 vat_json_init_object (&node);
5157 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5158 vat_json_object_add_uint (&node, "policer_index",
5159 ntohl (mp->policer_index));
5161 vat_json_print (vam->ofp, &node);
5162 vat_json_free (&node);
5164 vam->retval = ntohl (mp->retval);
5165 vam->result_ready = 1;
5168 /* Format hex dump. */
5170 format_hex_bytes (u8 * s, va_list * va)
5172 u8 *bytes = va_arg (*va, u8 *);
5173 int n_bytes = va_arg (*va, int);
5176 /* Print short or long form depending on byte count. */
5177 uword short_form = n_bytes <= 32;
5178 u32 indent = format_get_indent (s);
5183 for (i = 0; i < n_bytes; i++)
5185 if (!short_form && (i % 32) == 0)
5186 s = format (s, "%08x: ", i);
5187 s = format (s, "%02x", bytes[i]);
5188 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
5189 s = format (s, "\n%U", format_white_space, indent);
5196 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
5199 vat_main_t *vam = &vat_main;
5200 i32 retval = ntohl (mp->retval);
5203 print (vam->ofp, "classify table info :");
5204 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
5205 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
5206 ntohl (mp->miss_next_index));
5207 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
5208 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
5209 ntohl (mp->match_n_vectors));
5210 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
5211 ntohl (mp->mask_length));
5213 vam->retval = retval;
5214 vam->result_ready = 1;
5218 vl_api_classify_table_info_reply_t_handler_json
5219 (vl_api_classify_table_info_reply_t * mp)
5221 vat_main_t *vam = &vat_main;
5222 vat_json_node_t node;
5224 i32 retval = ntohl (mp->retval);
5227 vat_json_init_object (&node);
5229 vat_json_object_add_int (&node, "sessions",
5230 ntohl (mp->active_sessions));
5231 vat_json_object_add_int (&node, "nexttbl",
5232 ntohl (mp->next_table_index));
5233 vat_json_object_add_int (&node, "nextnode",
5234 ntohl (mp->miss_next_index));
5235 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
5236 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
5237 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
5238 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
5239 ntohl (mp->mask_length), 0);
5240 vat_json_object_add_string_copy (&node, "mask", s);
5242 vat_json_print (vam->ofp, &node);
5243 vat_json_free (&node);
5245 vam->retval = ntohl (mp->retval);
5246 vam->result_ready = 1;
5250 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
5253 vat_main_t *vam = &vat_main;
5255 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
5256 ntohl (mp->hit_next_index), ntohl (mp->advance),
5257 ntohl (mp->opaque_index));
5258 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
5259 ntohl (mp->match_length));
5263 vl_api_classify_session_details_t_handler_json
5264 (vl_api_classify_session_details_t * mp)
5266 vat_main_t *vam = &vat_main;
5267 vat_json_node_t *node = NULL;
5269 if (VAT_JSON_ARRAY != vam->json_tree.type)
5271 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5272 vat_json_init_array (&vam->json_tree);
5274 node = vat_json_array_add (&vam->json_tree);
5276 vat_json_init_object (node);
5277 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5278 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5279 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5281 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5283 vat_json_object_add_string_copy (node, "match", s);
5286 static void vl_api_pg_create_interface_reply_t_handler
5287 (vl_api_pg_create_interface_reply_t * mp)
5289 vat_main_t *vam = &vat_main;
5291 vam->retval = ntohl (mp->retval);
5292 vam->result_ready = 1;
5295 static void vl_api_pg_create_interface_reply_t_handler_json
5296 (vl_api_pg_create_interface_reply_t * mp)
5298 vat_main_t *vam = &vat_main;
5299 vat_json_node_t node;
5301 i32 retval = ntohl (mp->retval);
5304 vat_json_init_object (&node);
5306 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5308 vat_json_print (vam->ofp, &node);
5309 vat_json_free (&node);
5311 vam->retval = ntohl (mp->retval);
5312 vam->result_ready = 1;
5315 static void vl_api_policer_classify_details_t_handler
5316 (vl_api_policer_classify_details_t * mp)
5318 vat_main_t *vam = &vat_main;
5320 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5321 ntohl (mp->table_index));
5324 static void vl_api_policer_classify_details_t_handler_json
5325 (vl_api_policer_classify_details_t * mp)
5327 vat_main_t *vam = &vat_main;
5328 vat_json_node_t *node;
5330 if (VAT_JSON_ARRAY != vam->json_tree.type)
5332 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5333 vat_json_init_array (&vam->json_tree);
5335 node = vat_json_array_add (&vam->json_tree);
5337 vat_json_init_object (node);
5338 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5339 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5342 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5343 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5345 vat_main_t *vam = &vat_main;
5346 i32 retval = ntohl (mp->retval);
5347 if (vam->async_mode)
5349 vam->async_errors += (retval < 0);
5353 vam->retval = retval;
5354 vam->sw_if_index = ntohl (mp->sw_if_index);
5355 vam->result_ready = 1;
5357 vam->regenerate_interface_table = 1;
5360 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5361 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5363 vat_main_t *vam = &vat_main;
5364 vat_json_node_t node;
5366 vat_json_init_object (&node);
5367 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5368 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5370 vat_json_print (vam->ofp, &node);
5371 vat_json_free (&node);
5373 vam->retval = ntohl (mp->retval);
5374 vam->result_ready = 1;
5377 static void vl_api_flow_classify_details_t_handler
5378 (vl_api_flow_classify_details_t * mp)
5380 vat_main_t *vam = &vat_main;
5382 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5383 ntohl (mp->table_index));
5386 static void vl_api_flow_classify_details_t_handler_json
5387 (vl_api_flow_classify_details_t * mp)
5389 vat_main_t *vam = &vat_main;
5390 vat_json_node_t *node;
5392 if (VAT_JSON_ARRAY != vam->json_tree.type)
5394 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5395 vat_json_init_array (&vam->json_tree);
5397 node = vat_json_array_add (&vam->json_tree);
5399 vat_json_init_object (node);
5400 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5401 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5404 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5405 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5406 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5407 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5408 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5409 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5410 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5411 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5412 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5413 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5414 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5415 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5416 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5417 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5418 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5419 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5420 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5421 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5422 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5423 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5424 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5425 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5428 * Generate boilerplate reply handlers, which
5429 * dig the return value out of the xxx_reply_t API message,
5430 * stick it into vam->retval, and set vam->result_ready
5432 * Could also do this by pointing N message decode slots at
5433 * a single function, but that could break in subtle ways.
5436 #define foreach_standard_reply_retval_handler \
5437 _(sw_interface_set_flags_reply) \
5438 _(sw_interface_add_del_address_reply) \
5439 _(sw_interface_set_rx_mode_reply) \
5440 _(sw_interface_set_rx_placement_reply) \
5441 _(sw_interface_set_table_reply) \
5442 _(sw_interface_set_mpls_enable_reply) \
5443 _(sw_interface_set_vpath_reply) \
5444 _(sw_interface_set_vxlan_bypass_reply) \
5445 _(sw_interface_set_geneve_bypass_reply) \
5446 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5447 _(sw_interface_set_l2_bridge_reply) \
5448 _(bridge_domain_add_del_reply) \
5449 _(sw_interface_set_l2_xconnect_reply) \
5450 _(l2fib_add_del_reply) \
5451 _(l2fib_flush_int_reply) \
5452 _(l2fib_flush_bd_reply) \
5453 _(ip_add_del_route_reply) \
5454 _(ip_table_add_del_reply) \
5455 _(ip_mroute_add_del_reply) \
5456 _(mpls_route_add_del_reply) \
5457 _(mpls_table_add_del_reply) \
5458 _(mpls_ip_bind_unbind_reply) \
5459 _(bier_route_add_del_reply) \
5460 _(bier_table_add_del_reply) \
5461 _(proxy_arp_add_del_reply) \
5462 _(proxy_arp_intfc_enable_disable_reply) \
5463 _(sw_interface_set_unnumbered_reply) \
5464 _(ip_neighbor_add_del_reply) \
5465 _(oam_add_del_reply) \
5466 _(reset_fib_reply) \
5467 _(dhcp_proxy_config_reply) \
5468 _(dhcp_proxy_set_vss_reply) \
5469 _(dhcp_client_config_reply) \
5470 _(set_ip_flow_hash_reply) \
5471 _(sw_interface_ip6_enable_disable_reply) \
5472 _(ip6nd_proxy_add_del_reply) \
5473 _(sw_interface_ip6nd_ra_prefix_reply) \
5474 _(sw_interface_ip6nd_ra_config_reply) \
5475 _(set_arp_neighbor_limit_reply) \
5476 _(l2_patch_add_del_reply) \
5477 _(sr_mpls_policy_add_reply) \
5478 _(sr_mpls_policy_mod_reply) \
5479 _(sr_mpls_policy_del_reply) \
5480 _(sr_policy_add_reply) \
5481 _(sr_policy_mod_reply) \
5482 _(sr_policy_del_reply) \
5483 _(sr_localsid_add_del_reply) \
5484 _(sr_steering_add_del_reply) \
5485 _(classify_add_del_session_reply) \
5486 _(classify_set_interface_ip_table_reply) \
5487 _(classify_set_interface_l2_tables_reply) \
5488 _(l2tpv3_set_tunnel_cookies_reply) \
5489 _(l2tpv3_interface_enable_disable_reply) \
5490 _(l2tpv3_set_lookup_key_reply) \
5491 _(l2_fib_clear_table_reply) \
5492 _(l2_interface_efp_filter_reply) \
5493 _(l2_interface_vlan_tag_rewrite_reply) \
5494 _(modify_vhost_user_if_reply) \
5495 _(delete_vhost_user_if_reply) \
5496 _(ip_probe_neighbor_reply) \
5497 _(ip_scan_neighbor_enable_disable_reply) \
5498 _(want_ip4_arp_events_reply) \
5499 _(want_ip6_nd_events_reply) \
5500 _(want_l2_macs_events_reply) \
5501 _(input_acl_set_interface_reply) \
5502 _(ipsec_spd_add_del_reply) \
5503 _(ipsec_interface_add_del_spd_reply) \
5504 _(ipsec_spd_add_del_entry_reply) \
5505 _(ipsec_sad_add_del_entry_reply) \
5506 _(ipsec_sa_set_key_reply) \
5507 _(ipsec_tunnel_if_add_del_reply) \
5508 _(ipsec_tunnel_if_set_key_reply) \
5509 _(ipsec_tunnel_if_set_sa_reply) \
5510 _(ikev2_profile_add_del_reply) \
5511 _(ikev2_profile_set_auth_reply) \
5512 _(ikev2_profile_set_id_reply) \
5513 _(ikev2_profile_set_ts_reply) \
5514 _(ikev2_set_local_key_reply) \
5515 _(ikev2_set_responder_reply) \
5516 _(ikev2_set_ike_transforms_reply) \
5517 _(ikev2_set_esp_transforms_reply) \
5518 _(ikev2_set_sa_lifetime_reply) \
5519 _(ikev2_initiate_sa_init_reply) \
5520 _(ikev2_initiate_del_ike_sa_reply) \
5521 _(ikev2_initiate_del_child_sa_reply) \
5522 _(ikev2_initiate_rekey_child_sa_reply) \
5523 _(delete_loopback_reply) \
5524 _(bd_ip_mac_add_del_reply) \
5525 _(want_interface_events_reply) \
5526 _(want_stats_reply) \
5527 _(cop_interface_enable_disable_reply) \
5528 _(cop_whitelist_enable_disable_reply) \
5529 _(sw_interface_clear_stats_reply) \
5530 _(ioam_enable_reply) \
5531 _(ioam_disable_reply) \
5532 _(one_add_del_locator_reply) \
5533 _(one_add_del_local_eid_reply) \
5534 _(one_add_del_remote_mapping_reply) \
5535 _(one_add_del_adjacency_reply) \
5536 _(one_add_del_map_resolver_reply) \
5537 _(one_add_del_map_server_reply) \
5538 _(one_enable_disable_reply) \
5539 _(one_rloc_probe_enable_disable_reply) \
5540 _(one_map_register_enable_disable_reply) \
5541 _(one_map_register_set_ttl_reply) \
5542 _(one_set_transport_protocol_reply) \
5543 _(one_map_register_fallback_threshold_reply) \
5544 _(one_pitr_set_locator_set_reply) \
5545 _(one_map_request_mode_reply) \
5546 _(one_add_del_map_request_itr_rlocs_reply) \
5547 _(one_eid_table_add_del_map_reply) \
5548 _(one_use_petr_reply) \
5549 _(one_stats_enable_disable_reply) \
5550 _(one_add_del_l2_arp_entry_reply) \
5551 _(one_add_del_ndp_entry_reply) \
5552 _(one_stats_flush_reply) \
5553 _(one_enable_disable_xtr_mode_reply) \
5554 _(one_enable_disable_pitr_mode_reply) \
5555 _(one_enable_disable_petr_mode_reply) \
5556 _(gpe_enable_disable_reply) \
5557 _(gpe_set_encap_mode_reply) \
5558 _(gpe_add_del_iface_reply) \
5559 _(gpe_add_del_native_fwd_rpath_reply) \
5560 _(af_packet_delete_reply) \
5561 _(policer_classify_set_interface_reply) \
5562 _(netmap_create_reply) \
5563 _(netmap_delete_reply) \
5564 _(set_ipfix_exporter_reply) \
5565 _(set_ipfix_classify_stream_reply) \
5566 _(ipfix_classify_table_add_del_reply) \
5567 _(flow_classify_set_interface_reply) \
5568 _(sw_interface_span_enable_disable_reply) \
5569 _(pg_capture_reply) \
5570 _(pg_enable_disable_reply) \
5571 _(ip_source_and_port_range_check_add_del_reply) \
5572 _(ip_source_and_port_range_check_interface_add_del_reply)\
5573 _(delete_subif_reply) \
5574 _(l2_interface_pbb_tag_rewrite_reply) \
5576 _(feature_enable_disable_reply) \
5577 _(sw_interface_tag_add_del_reply) \
5578 _(hw_interface_set_mtu_reply) \
5579 _(p2p_ethernet_add_reply) \
5580 _(p2p_ethernet_del_reply) \
5581 _(lldp_config_reply) \
5582 _(sw_interface_set_lldp_reply) \
5583 _(tcp_configure_src_addresses_reply) \
5584 _(dns_enable_disable_reply) \
5585 _(dns_name_server_add_del_reply) \
5586 _(session_rule_add_del_reply) \
5587 _(ip_container_proxy_add_del_reply) \
5588 _(output_acl_set_interface_reply) \
5589 _(qos_record_enable_disable_reply)
5592 static void vl_api_##n##_t_handler \
5593 (vl_api_##n##_t * mp) \
5595 vat_main_t * vam = &vat_main; \
5596 i32 retval = ntohl(mp->retval); \
5597 if (vam->async_mode) { \
5598 vam->async_errors += (retval < 0); \
5600 vam->retval = retval; \
5601 vam->result_ready = 1; \
5604 foreach_standard_reply_retval_handler;
5608 static void vl_api_##n##_t_handler_json \
5609 (vl_api_##n##_t * mp) \
5611 vat_main_t * vam = &vat_main; \
5612 vat_json_node_t node; \
5613 vat_json_init_object(&node); \
5614 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5615 vat_json_print(vam->ofp, &node); \
5616 vam->retval = ntohl(mp->retval); \
5617 vam->result_ready = 1; \
5619 foreach_standard_reply_retval_handler;
5623 * Table of message reply handlers, must include boilerplate handlers
5627 #define foreach_vpe_api_reply_msg \
5628 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5629 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5630 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5631 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5632 _(CONTROL_PING_REPLY, control_ping_reply) \
5633 _(CLI_REPLY, cli_reply) \
5634 _(CLI_INBAND_REPLY, cli_inband_reply) \
5635 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5636 sw_interface_add_del_address_reply) \
5637 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5638 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5639 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5640 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5641 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5642 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5643 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5644 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5645 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5646 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5647 sw_interface_set_l2_xconnect_reply) \
5648 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5649 sw_interface_set_l2_bridge_reply) \
5650 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5651 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5652 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5653 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5654 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5655 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5656 _(L2_FLAGS_REPLY, l2_flags_reply) \
5657 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5658 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5659 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5660 _(TAP_DELETE_REPLY, tap_delete_reply) \
5661 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5662 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5663 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5664 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5665 _(BOND_CREATE_REPLY, bond_create_reply) \
5666 _(BOND_DELETE_REPLY, bond_delete_reply) \
5667 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5668 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5669 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5670 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5671 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5672 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5673 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5674 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5675 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5676 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5677 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5678 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5679 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5680 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5681 proxy_arp_intfc_enable_disable_reply) \
5682 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5683 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5684 sw_interface_set_unnumbered_reply) \
5685 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5686 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5687 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5688 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5689 _(RESET_FIB_REPLY, reset_fib_reply) \
5690 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5691 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5692 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5693 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5694 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5695 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5696 sw_interface_ip6_enable_disable_reply) \
5697 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5698 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5699 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5700 sw_interface_ip6nd_ra_prefix_reply) \
5701 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5702 sw_interface_ip6nd_ra_config_reply) \
5703 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5704 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5705 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5706 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5707 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5708 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5709 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5710 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5711 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5712 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5713 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5714 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5715 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5716 classify_set_interface_ip_table_reply) \
5717 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5718 classify_set_interface_l2_tables_reply) \
5719 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5720 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5721 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5722 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5723 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5724 l2tpv3_interface_enable_disable_reply) \
5725 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5726 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5727 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5728 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5729 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5730 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5731 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5732 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5733 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5734 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5735 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5736 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5737 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5738 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5739 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5740 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5741 _(SHOW_VERSION_REPLY, show_version_reply) \
5742 _(SHOW_THREADS_REPLY, show_threads_reply) \
5743 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5744 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5745 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5746 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5747 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5748 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5749 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5750 _(IP4_ARP_EVENT, ip4_arp_event) \
5751 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5752 _(IP6_ND_EVENT, ip6_nd_event) \
5753 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5754 _(L2_MACS_EVENT, l2_macs_event) \
5755 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5756 _(IP_ADDRESS_DETAILS, ip_address_details) \
5757 _(IP_DETAILS, ip_details) \
5758 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5759 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5760 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5761 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5762 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5763 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5764 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5765 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5766 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5767 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5768 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5769 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5770 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5771 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5772 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5773 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5774 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5775 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5776 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5777 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5778 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5779 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5780 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5781 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5782 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5783 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5784 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5785 _(WANT_STATS_REPLY, want_stats_reply) \
5786 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5787 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5788 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5789 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5790 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5791 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5792 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5793 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5794 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5795 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5796 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5797 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5798 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5799 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5800 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5801 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5802 one_map_register_enable_disable_reply) \
5803 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5804 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5805 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5806 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5807 one_map_register_fallback_threshold_reply) \
5808 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5809 one_rloc_probe_enable_disable_reply) \
5810 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5811 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5812 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5813 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5814 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5815 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5816 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5817 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5818 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5819 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5820 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5821 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5822 _(ONE_STATS_DETAILS, one_stats_details) \
5823 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5824 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5825 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5826 show_one_stats_enable_disable_reply) \
5827 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5828 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5829 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5830 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5831 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5832 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5833 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5834 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5835 one_enable_disable_pitr_mode_reply) \
5836 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5837 one_enable_disable_petr_mode_reply) \
5838 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5839 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5840 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5841 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5842 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5843 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5844 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5845 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5846 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5847 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5848 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5849 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5850 gpe_add_del_native_fwd_rpath_reply) \
5851 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5852 gpe_fwd_entry_path_details) \
5853 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5854 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5855 one_add_del_map_request_itr_rlocs_reply) \
5856 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5857 one_get_map_request_itr_rlocs_reply) \
5858 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5859 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5860 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5861 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5862 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5863 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5864 show_one_map_register_state_reply) \
5865 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5866 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5867 show_one_map_register_fallback_threshold_reply) \
5868 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5869 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5870 _(AF_PACKET_DETAILS, af_packet_details) \
5871 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5872 _(POLICER_DETAILS, policer_details) \
5873 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5874 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5875 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5876 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5877 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5878 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5879 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5880 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5881 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5882 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5883 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5884 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5885 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5886 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5887 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5888 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5889 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5890 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5891 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5892 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5893 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5894 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5895 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5896 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5897 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5898 ip_source_and_port_range_check_add_del_reply) \
5899 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5900 ip_source_and_port_range_check_interface_add_del_reply) \
5901 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5902 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5903 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5904 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5905 _(PUNT_REPLY, punt_reply) \
5906 _(IP_FIB_DETAILS, ip_fib_details) \
5907 _(IP6_FIB_DETAILS, ip6_fib_details) \
5908 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5909 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5910 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5911 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5912 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5913 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5914 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5915 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5916 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5917 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5918 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5919 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5920 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5921 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5922 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5923 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5924 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5925 _(SESSION_RULES_DETAILS, session_rules_details) \
5926 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5927 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5928 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5930 #define foreach_standalone_reply_msg \
5931 _(SW_INTERFACE_EVENT, sw_interface_event) \
5932 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5933 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5934 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5935 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5936 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5937 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
5945 #define STR_VTR_OP_CASE(op) \
5946 case L2_VTR_ ## op: \
5950 str_vtr_op (u32 vtr_op)
5954 STR_VTR_OP_CASE (DISABLED);
5955 STR_VTR_OP_CASE (PUSH_1);
5956 STR_VTR_OP_CASE (PUSH_2);
5957 STR_VTR_OP_CASE (POP_1);
5958 STR_VTR_OP_CASE (POP_2);
5959 STR_VTR_OP_CASE (TRANSLATE_1_1);
5960 STR_VTR_OP_CASE (TRANSLATE_1_2);
5961 STR_VTR_OP_CASE (TRANSLATE_2_1);
5962 STR_VTR_OP_CASE (TRANSLATE_2_2);
5969 dump_sub_interface_table (vat_main_t * vam)
5971 const sw_interface_subif_t *sub = NULL;
5973 if (vam->json_output)
5976 ("JSON output supported only for VPE API calls and dump_stats_table");
5981 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5982 "Interface", "sw_if_index",
5983 "sub id", "dot1ad", "tags", "outer id",
5984 "inner id", "exact", "default", "outer any", "inner any");
5986 vec_foreach (sub, vam->sw_if_subif_table)
5989 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5990 sub->interface_name,
5992 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5993 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5994 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5995 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5996 if (sub->vtr_op != L2_VTR_DISABLED)
5999 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
6000 "tag1: %d tag2: %d ]",
6001 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
6002 sub->vtr_tag1, sub->vtr_tag2);
6010 name_sort_cmp (void *a1, void *a2)
6012 name_sort_t *n1 = a1;
6013 name_sort_t *n2 = a2;
6015 return strcmp ((char *) n1->name, (char *) n2->name);
6019 dump_interface_table (vat_main_t * vam)
6022 name_sort_t *nses = 0, *ns;
6024 if (vam->json_output)
6027 ("JSON output supported only for VPE API calls and dump_stats_table");
6032 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6034 vec_add2 (nses, ns, 1);
6035 ns->name = (u8 *)(p->key);
6036 ns->value = (u32) p->value[0];
6040 vec_sort_with_function (nses, name_sort_cmp);
6042 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
6043 vec_foreach (ns, nses)
6045 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
6052 dump_ip_table (vat_main_t * vam, int is_ipv6)
6054 const ip_details_t *det = NULL;
6055 const ip_address_details_t *address = NULL;
6058 print (vam->ofp, "%-12s", "sw_if_index");
6060 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
6067 print (vam->ofp, "%-12d", i);
6068 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
6073 vec_foreach (address, det->addr)
6077 is_ipv6 ? format_ip6_address : format_ip4_address,
6078 address->ip, address->prefix_length);
6086 dump_ipv4_table (vat_main_t * vam)
6088 if (vam->json_output)
6091 ("JSON output supported only for VPE API calls and dump_stats_table");
6095 return dump_ip_table (vam, 0);
6099 dump_ipv6_table (vat_main_t * vam)
6101 if (vam->json_output)
6104 ("JSON output supported only for VPE API calls and dump_stats_table");
6108 return dump_ip_table (vam, 1);
6112 counter_type_to_str (u8 counter_type, u8 is_combined)
6116 switch (counter_type)
6118 case VNET_INTERFACE_COUNTER_DROP:
6120 case VNET_INTERFACE_COUNTER_PUNT:
6122 case VNET_INTERFACE_COUNTER_IP4:
6124 case VNET_INTERFACE_COUNTER_IP6:
6126 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
6128 case VNET_INTERFACE_COUNTER_RX_MISS:
6130 case VNET_INTERFACE_COUNTER_RX_ERROR:
6132 case VNET_INTERFACE_COUNTER_TX_ERROR:
6135 return "INVALID-COUNTER-TYPE";
6140 switch (counter_type)
6142 case VNET_INTERFACE_COUNTER_RX:
6144 case VNET_INTERFACE_COUNTER_TX:
6147 return "INVALID-COUNTER-TYPE";
6153 dump_stats_table (vat_main_t * vam)
6155 vat_json_node_t node;
6156 vat_json_node_t *msg_array;
6157 vat_json_node_t *msg;
6158 vat_json_node_t *counter_array;
6159 vat_json_node_t *counter;
6160 interface_counter_t c;
6162 ip4_fib_counter_t *c4;
6163 ip6_fib_counter_t *c6;
6164 ip4_nbr_counter_t *n4;
6165 ip6_nbr_counter_t *n6;
6168 if (!vam->json_output)
6170 clib_warning ("dump_stats_table supported only in JSON format");
6174 vat_json_init_object (&node);
6176 /* interface counters */
6177 msg_array = vat_json_object_add (&node, "interface_counters");
6178 vat_json_init_array (msg_array);
6179 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
6181 msg = vat_json_array_add (msg_array);
6182 vat_json_init_object (msg);
6183 vat_json_object_add_string_copy (msg, "vnet_counter_type",
6184 (u8 *) counter_type_to_str (i, 0));
6185 vat_json_object_add_int (msg, "is_combined", 0);
6186 counter_array = vat_json_object_add (msg, "data");
6187 vat_json_init_array (counter_array);
6188 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
6190 packets = vam->simple_interface_counters[i][j];
6191 vat_json_array_add_uint (counter_array, packets);
6194 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
6196 msg = vat_json_array_add (msg_array);
6197 vat_json_init_object (msg);
6198 vat_json_object_add_string_copy (msg, "vnet_counter_type",
6199 (u8 *) counter_type_to_str (i, 1));
6200 vat_json_object_add_int (msg, "is_combined", 1);
6201 counter_array = vat_json_object_add (msg, "data");
6202 vat_json_init_array (counter_array);
6203 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
6205 c = vam->combined_interface_counters[i][j];
6206 counter = vat_json_array_add (counter_array);
6207 vat_json_init_object (counter);
6208 vat_json_object_add_uint (counter, "packets", c.packets);
6209 vat_json_object_add_uint (counter, "bytes", c.bytes);
6213 /* ip4 fib counters */
6214 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
6215 vat_json_init_array (msg_array);
6216 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
6218 msg = vat_json_array_add (msg_array);
6219 vat_json_init_object (msg);
6220 vat_json_object_add_uint (msg, "vrf_id",
6221 vam->ip4_fib_counters_vrf_id_by_index[i]);
6222 counter_array = vat_json_object_add (msg, "c");
6223 vat_json_init_array (counter_array);
6224 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
6226 counter = vat_json_array_add (counter_array);
6227 vat_json_init_object (counter);
6228 c4 = &vam->ip4_fib_counters[i][j];
6229 vat_json_object_add_ip4 (counter, "address", c4->address);
6230 vat_json_object_add_uint (counter, "address_length",
6231 c4->address_length);
6232 vat_json_object_add_uint (counter, "packets", c4->packets);
6233 vat_json_object_add_uint (counter, "bytes", c4->bytes);
6237 /* ip6 fib counters */
6238 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
6239 vat_json_init_array (msg_array);
6240 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
6242 msg = vat_json_array_add (msg_array);
6243 vat_json_init_object (msg);
6244 vat_json_object_add_uint (msg, "vrf_id",
6245 vam->ip6_fib_counters_vrf_id_by_index[i]);
6246 counter_array = vat_json_object_add (msg, "c");
6247 vat_json_init_array (counter_array);
6248 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
6250 counter = vat_json_array_add (counter_array);
6251 vat_json_init_object (counter);
6252 c6 = &vam->ip6_fib_counters[i][j];
6253 vat_json_object_add_ip6 (counter, "address", c6->address);
6254 vat_json_object_add_uint (counter, "address_length",
6255 c6->address_length);
6256 vat_json_object_add_uint (counter, "packets", c6->packets);
6257 vat_json_object_add_uint (counter, "bytes", c6->bytes);
6261 /* ip4 nbr counters */
6262 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
6263 vat_json_init_array (msg_array);
6264 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
6266 msg = vat_json_array_add (msg_array);
6267 vat_json_init_object (msg);
6268 vat_json_object_add_uint (msg, "sw_if_index", i);
6269 counter_array = vat_json_object_add (msg, "c");
6270 vat_json_init_array (counter_array);
6271 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
6273 counter = vat_json_array_add (counter_array);
6274 vat_json_init_object (counter);
6275 n4 = &vam->ip4_nbr_counters[i][j];
6276 vat_json_object_add_ip4 (counter, "address", n4->address);
6277 vat_json_object_add_uint (counter, "link-type", n4->linkt);
6278 vat_json_object_add_uint (counter, "packets", n4->packets);
6279 vat_json_object_add_uint (counter, "bytes", n4->bytes);
6283 /* ip6 nbr counters */
6284 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
6285 vat_json_init_array (msg_array);
6286 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
6288 msg = vat_json_array_add (msg_array);
6289 vat_json_init_object (msg);
6290 vat_json_object_add_uint (msg, "sw_if_index", i);
6291 counter_array = vat_json_object_add (msg, "c");
6292 vat_json_init_array (counter_array);
6293 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
6295 counter = vat_json_array_add (counter_array);
6296 vat_json_init_object (counter);
6297 n6 = &vam->ip6_nbr_counters[i][j];
6298 vat_json_object_add_ip6 (counter, "address", n6->address);
6299 vat_json_object_add_uint (counter, "packets", n6->packets);
6300 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6304 vat_json_print (vam->ofp, &node);
6305 vat_json_free (&node);
6311 * Pass CLI buffers directly in the CLI_INBAND API message,
6312 * instead of an additional shared memory area.
6315 exec_inband (vat_main_t * vam)
6317 vl_api_cli_inband_t *mp;
6318 unformat_input_t *i = vam->input;
6321 if (vec_len (i->buffer) == 0)
6324 if (vam->exec_mode == 0 && unformat (i, "mode"))
6329 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6336 * In order for the CLI command to work, it
6337 * must be a vector ending in \n, not a C-string ending
6340 u32 len = vec_len (vam->input->buffer);
6341 M2 (CLI_INBAND, mp, len);
6342 clib_memcpy (mp->cmd, vam->input->buffer, len);
6343 mp->length = htonl (len);
6347 /* json responses may or may not include a useful reply... */
6348 if (vec_len (vam->cmd_reply))
6349 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6354 exec (vat_main_t * vam)
6356 return exec_inband (vam);
6360 api_create_loopback (vat_main_t * vam)
6362 unformat_input_t *i = vam->input;
6363 vl_api_create_loopback_t *mp;
6364 vl_api_create_loopback_instance_t *mp_lbi;
6367 u8 is_specified = 0;
6368 u32 user_instance = 0;
6371 clib_memset (mac_address, 0, sizeof (mac_address));
6373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6375 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6377 if (unformat (i, "instance %d", &user_instance))
6385 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6386 mp_lbi->is_specified = is_specified;
6388 mp_lbi->user_instance = htonl (user_instance);
6390 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6395 /* Construct the API message */
6396 M (CREATE_LOOPBACK, mp);
6398 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6407 api_delete_loopback (vat_main_t * vam)
6409 unformat_input_t *i = vam->input;
6410 vl_api_delete_loopback_t *mp;
6411 u32 sw_if_index = ~0;
6414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6416 if (unformat (i, "sw_if_index %d", &sw_if_index))
6422 if (sw_if_index == ~0)
6424 errmsg ("missing sw_if_index");
6428 /* Construct the API message */
6429 M (DELETE_LOOPBACK, mp);
6430 mp->sw_if_index = ntohl (sw_if_index);
6438 api_want_stats (vat_main_t * vam)
6440 unformat_input_t *i = vam->input;
6441 vl_api_want_stats_t *mp;
6445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6447 if (unformat (i, "enable"))
6449 else if (unformat (i, "disable"))
6457 errmsg ("missing enable|disable");
6462 mp->enable_disable = enable;
6470 api_want_interface_events (vat_main_t * vam)
6472 unformat_input_t *i = vam->input;
6473 vl_api_want_interface_events_t *mp;
6477 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6479 if (unformat (i, "enable"))
6481 else if (unformat (i, "disable"))
6489 errmsg ("missing enable|disable");
6493 M (WANT_INTERFACE_EVENTS, mp);
6494 mp->enable_disable = enable;
6496 vam->interface_event_display = enable;
6504 /* Note: non-static, called once to set up the initial intfc table */
6506 api_sw_interface_dump (vat_main_t * vam)
6508 vl_api_sw_interface_dump_t *mp;
6509 vl_api_control_ping_t *mp_ping;
6511 name_sort_t *nses = 0, *ns;
6512 sw_interface_subif_t *sub = NULL;
6515 /* Toss the old name table */
6517 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6519 vec_add2 (nses, ns, 1);
6520 ns->name = (u8 *)(p->key);
6521 ns->value = (u32) p->value[0];
6525 hash_free (vam->sw_if_index_by_interface_name);
6527 vec_foreach (ns, nses) vec_free (ns->name);
6531 vec_foreach (sub, vam->sw_if_subif_table)
6533 vec_free (sub->interface_name);
6535 vec_free (vam->sw_if_subif_table);
6537 /* recreate the interface name hash table */
6538 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6541 * Ask for all interface names. Otherwise, the epic catalog of
6542 * name filters becomes ridiculously long, and vat ends up needing
6543 * to be taught about new interface types.
6545 M (SW_INTERFACE_DUMP, mp);
6548 /* Use a control ping for synchronization */
6549 MPING (CONTROL_PING, mp_ping);
6557 api_sw_interface_set_flags (vat_main_t * vam)
6559 unformat_input_t *i = vam->input;
6560 vl_api_sw_interface_set_flags_t *mp;
6562 u8 sw_if_index_set = 0;
6566 /* Parse args required to build the message */
6567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6569 if (unformat (i, "admin-up"))
6571 else if (unformat (i, "admin-down"))
6574 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6575 sw_if_index_set = 1;
6576 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6577 sw_if_index_set = 1;
6582 if (sw_if_index_set == 0)
6584 errmsg ("missing interface name or sw_if_index");
6588 /* Construct the API message */
6589 M (SW_INTERFACE_SET_FLAGS, mp);
6590 mp->sw_if_index = ntohl (sw_if_index);
6591 mp->admin_up_down = admin_up;
6596 /* Wait for a reply, return the good/bad news... */
6602 api_sw_interface_set_rx_mode (vat_main_t * vam)
6604 unformat_input_t *i = vam->input;
6605 vl_api_sw_interface_set_rx_mode_t *mp;
6607 u8 sw_if_index_set = 0;
6609 u8 queue_id_valid = 0;
6611 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6613 /* Parse args required to build the message */
6614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6616 if (unformat (i, "queue %d", &queue_id))
6618 else if (unformat (i, "polling"))
6619 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6620 else if (unformat (i, "interrupt"))
6621 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6622 else if (unformat (i, "adaptive"))
6623 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6625 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6626 sw_if_index_set = 1;
6627 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6628 sw_if_index_set = 1;
6633 if (sw_if_index_set == 0)
6635 errmsg ("missing interface name or sw_if_index");
6638 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6640 errmsg ("missing rx-mode");
6644 /* Construct the API message */
6645 M (SW_INTERFACE_SET_RX_MODE, mp);
6646 mp->sw_if_index = ntohl (sw_if_index);
6648 mp->queue_id_valid = queue_id_valid;
6649 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6654 /* Wait for a reply, return the good/bad news... */
6660 api_sw_interface_set_rx_placement (vat_main_t * vam)
6662 unformat_input_t *i = vam->input;
6663 vl_api_sw_interface_set_rx_placement_t *mp;
6665 u8 sw_if_index_set = 0;
6668 u32 queue_id, thread_index;
6670 /* Parse args required to build the message */
6671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6673 if (unformat (i, "queue %d", &queue_id))
6675 else if (unformat (i, "main"))
6677 else if (unformat (i, "worker %d", &thread_index))
6680 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6681 sw_if_index_set = 1;
6682 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6683 sw_if_index_set = 1;
6688 if (sw_if_index_set == 0)
6690 errmsg ("missing interface name or sw_if_index");
6696 /* Construct the API message */
6697 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6698 mp->sw_if_index = ntohl (sw_if_index);
6699 mp->worker_id = ntohl (thread_index);
6700 mp->queue_id = ntohl (queue_id);
6701 mp->is_main = is_main;
6705 /* Wait for a reply, return the good/bad news... */
6710 static void vl_api_sw_interface_rx_placement_details_t_handler
6711 (vl_api_sw_interface_rx_placement_details_t * mp)
6713 vat_main_t *vam = &vat_main;
6714 u32 worker_id = ntohl (mp->worker_id);
6717 "\n%-11d %-11s %-6d %-5d %-9s",
6718 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6719 worker_id, ntohl (mp->queue_id),
6721 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6724 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6725 (vl_api_sw_interface_rx_placement_details_t * mp)
6727 vat_main_t *vam = &vat_main;
6728 vat_json_node_t *node = NULL;
6730 if (VAT_JSON_ARRAY != vam->json_tree.type)
6732 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6733 vat_json_init_array (&vam->json_tree);
6735 node = vat_json_array_add (&vam->json_tree);
6737 vat_json_init_object (node);
6738 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6739 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6740 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6741 vat_json_object_add_uint (node, "mode", mp->mode);
6745 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6747 unformat_input_t *i = vam->input;
6748 vl_api_sw_interface_rx_placement_dump_t *mp;
6749 vl_api_control_ping_t *mp_ping;
6752 u8 sw_if_index_set = 0;
6754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6756 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6758 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6765 "\n%-11s %-11s %-6s %-5s %-4s",
6766 "sw_if_index", "main/worker", "thread", "queue", "mode");
6768 /* Dump Interface rx placement */
6769 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6771 if (sw_if_index_set)
6772 mp->sw_if_index = htonl (sw_if_index);
6774 mp->sw_if_index = ~0;
6778 /* Use a control ping for synchronization */
6779 MPING (CONTROL_PING, mp_ping);
6787 api_sw_interface_clear_stats (vat_main_t * vam)
6789 unformat_input_t *i = vam->input;
6790 vl_api_sw_interface_clear_stats_t *mp;
6792 u8 sw_if_index_set = 0;
6795 /* Parse args required to build the message */
6796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6798 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6799 sw_if_index_set = 1;
6800 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6801 sw_if_index_set = 1;
6806 /* Construct the API message */
6807 M (SW_INTERFACE_CLEAR_STATS, mp);
6809 if (sw_if_index_set == 1)
6810 mp->sw_if_index = ntohl (sw_if_index);
6812 mp->sw_if_index = ~0;
6817 /* Wait for a reply, return the good/bad news... */
6823 api_sw_interface_add_del_address (vat_main_t * vam)
6825 unformat_input_t *i = vam->input;
6826 vl_api_sw_interface_add_del_address_t *mp;
6828 u8 sw_if_index_set = 0;
6829 u8 is_add = 1, del_all = 0;
6830 u32 address_length = 0;
6831 u8 v4_address_set = 0;
6832 u8 v6_address_set = 0;
6833 ip4_address_t v4address;
6834 ip6_address_t v6address;
6837 /* Parse args required to build the message */
6838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6840 if (unformat (i, "del-all"))
6842 else if (unformat (i, "del"))
6845 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6846 sw_if_index_set = 1;
6847 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6848 sw_if_index_set = 1;
6849 else if (unformat (i, "%U/%d",
6850 unformat_ip4_address, &v4address, &address_length))
6852 else if (unformat (i, "%U/%d",
6853 unformat_ip6_address, &v6address, &address_length))
6859 if (sw_if_index_set == 0)
6861 errmsg ("missing interface name or sw_if_index");
6864 if (v4_address_set && v6_address_set)
6866 errmsg ("both v4 and v6 addresses set");
6869 if (!v4_address_set && !v6_address_set && !del_all)
6871 errmsg ("no addresses set");
6875 /* Construct the API message */
6876 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6878 mp->sw_if_index = ntohl (sw_if_index);
6879 mp->is_add = is_add;
6880 mp->del_all = del_all;
6884 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6888 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6890 mp->address_length = address_length;
6895 /* Wait for a reply, return good/bad news */
6901 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6903 unformat_input_t *i = vam->input;
6904 vl_api_sw_interface_set_mpls_enable_t *mp;
6906 u8 sw_if_index_set = 0;
6910 /* Parse args required to build the message */
6911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6913 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6914 sw_if_index_set = 1;
6915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6916 sw_if_index_set = 1;
6917 else if (unformat (i, "disable"))
6919 else if (unformat (i, "dis"))
6925 if (sw_if_index_set == 0)
6927 errmsg ("missing interface name or sw_if_index");
6931 /* Construct the API message */
6932 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6934 mp->sw_if_index = ntohl (sw_if_index);
6935 mp->enable = enable;
6940 /* Wait for a reply... */
6946 api_sw_interface_set_table (vat_main_t * vam)
6948 unformat_input_t *i = vam->input;
6949 vl_api_sw_interface_set_table_t *mp;
6950 u32 sw_if_index, vrf_id = 0;
6951 u8 sw_if_index_set = 0;
6955 /* Parse args required to build the message */
6956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6958 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6959 sw_if_index_set = 1;
6960 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6961 sw_if_index_set = 1;
6962 else if (unformat (i, "vrf %d", &vrf_id))
6964 else if (unformat (i, "ipv6"))
6970 if (sw_if_index_set == 0)
6972 errmsg ("missing interface name or sw_if_index");
6976 /* Construct the API message */
6977 M (SW_INTERFACE_SET_TABLE, mp);
6979 mp->sw_if_index = ntohl (sw_if_index);
6980 mp->is_ipv6 = is_ipv6;
6981 mp->vrf_id = ntohl (vrf_id);
6986 /* Wait for a reply... */
6991 static void vl_api_sw_interface_get_table_reply_t_handler
6992 (vl_api_sw_interface_get_table_reply_t * mp)
6994 vat_main_t *vam = &vat_main;
6996 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6998 vam->retval = ntohl (mp->retval);
6999 vam->result_ready = 1;
7003 static void vl_api_sw_interface_get_table_reply_t_handler_json
7004 (vl_api_sw_interface_get_table_reply_t * mp)
7006 vat_main_t *vam = &vat_main;
7007 vat_json_node_t node;
7009 vat_json_init_object (&node);
7010 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
7011 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
7013 vat_json_print (vam->ofp, &node);
7014 vat_json_free (&node);
7016 vam->retval = ntohl (mp->retval);
7017 vam->result_ready = 1;
7021 api_sw_interface_get_table (vat_main_t * vam)
7023 unformat_input_t *i = vam->input;
7024 vl_api_sw_interface_get_table_t *mp;
7026 u8 sw_if_index_set = 0;
7030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7032 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7033 sw_if_index_set = 1;
7034 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7035 sw_if_index_set = 1;
7036 else if (unformat (i, "ipv6"))
7042 if (sw_if_index_set == 0)
7044 errmsg ("missing interface name or sw_if_index");
7048 M (SW_INTERFACE_GET_TABLE, mp);
7049 mp->sw_if_index = htonl (sw_if_index);
7050 mp->is_ipv6 = is_ipv6;
7058 api_sw_interface_set_vpath (vat_main_t * vam)
7060 unformat_input_t *i = vam->input;
7061 vl_api_sw_interface_set_vpath_t *mp;
7062 u32 sw_if_index = 0;
7063 u8 sw_if_index_set = 0;
7067 /* Parse args required to build the message */
7068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7070 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7071 sw_if_index_set = 1;
7072 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7073 sw_if_index_set = 1;
7074 else if (unformat (i, "enable"))
7076 else if (unformat (i, "disable"))
7082 if (sw_if_index_set == 0)
7084 errmsg ("missing interface name or sw_if_index");
7088 /* Construct the API message */
7089 M (SW_INTERFACE_SET_VPATH, mp);
7091 mp->sw_if_index = ntohl (sw_if_index);
7092 mp->enable = is_enable;
7097 /* Wait for a reply... */
7103 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
7105 unformat_input_t *i = vam->input;
7106 vl_api_sw_interface_set_vxlan_bypass_t *mp;
7107 u32 sw_if_index = 0;
7108 u8 sw_if_index_set = 0;
7113 /* Parse args required to build the message */
7114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7116 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7117 sw_if_index_set = 1;
7118 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7119 sw_if_index_set = 1;
7120 else if (unformat (i, "enable"))
7122 else if (unformat (i, "disable"))
7124 else if (unformat (i, "ip4"))
7126 else if (unformat (i, "ip6"))
7132 if (sw_if_index_set == 0)
7134 errmsg ("missing interface name or sw_if_index");
7138 /* Construct the API message */
7139 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
7141 mp->sw_if_index = ntohl (sw_if_index);
7142 mp->enable = is_enable;
7143 mp->is_ipv6 = is_ipv6;
7148 /* Wait for a reply... */
7154 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
7156 unformat_input_t *i = vam->input;
7157 vl_api_sw_interface_set_geneve_bypass_t *mp;
7158 u32 sw_if_index = 0;
7159 u8 sw_if_index_set = 0;
7164 /* Parse args required to build the message */
7165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7167 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7168 sw_if_index_set = 1;
7169 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7170 sw_if_index_set = 1;
7171 else if (unformat (i, "enable"))
7173 else if (unformat (i, "disable"))
7175 else if (unformat (i, "ip4"))
7177 else if (unformat (i, "ip6"))
7183 if (sw_if_index_set == 0)
7185 errmsg ("missing interface name or sw_if_index");
7189 /* Construct the API message */
7190 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
7192 mp->sw_if_index = ntohl (sw_if_index);
7193 mp->enable = is_enable;
7194 mp->is_ipv6 = is_ipv6;
7199 /* Wait for a reply... */
7205 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
7207 unformat_input_t *i = vam->input;
7208 vl_api_sw_interface_set_l2_xconnect_t *mp;
7210 u8 rx_sw_if_index_set = 0;
7212 u8 tx_sw_if_index_set = 0;
7216 /* Parse args required to build the message */
7217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7219 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7220 rx_sw_if_index_set = 1;
7221 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7222 tx_sw_if_index_set = 1;
7223 else if (unformat (i, "rx"))
7225 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7227 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7229 rx_sw_if_index_set = 1;
7234 else if (unformat (i, "tx"))
7236 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7238 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
7240 tx_sw_if_index_set = 1;
7245 else if (unformat (i, "enable"))
7247 else if (unformat (i, "disable"))
7253 if (rx_sw_if_index_set == 0)
7255 errmsg ("missing rx interface name or rx_sw_if_index");
7259 if (enable && (tx_sw_if_index_set == 0))
7261 errmsg ("missing tx interface name or tx_sw_if_index");
7265 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
7267 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7268 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7269 mp->enable = enable;
7277 api_sw_interface_set_l2_bridge (vat_main_t * vam)
7279 unformat_input_t *i = vam->input;
7280 vl_api_sw_interface_set_l2_bridge_t *mp;
7281 vl_api_l2_port_type_t port_type;
7283 u8 rx_sw_if_index_set = 0;
7290 port_type = L2_API_PORT_TYPE_NORMAL;
7292 /* Parse args required to build the message */
7293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7295 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
7296 rx_sw_if_index_set = 1;
7297 else if (unformat (i, "bd_id %d", &bd_id))
7301 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
7302 rx_sw_if_index_set = 1;
7303 else if (unformat (i, "shg %d", &shg))
7305 else if (unformat (i, "bvi"))
7306 port_type = L2_API_PORT_TYPE_BVI;
7307 else if (unformat (i, "uu-fwd"))
7308 port_type = L2_API_PORT_TYPE_UU_FWD;
7309 else if (unformat (i, "enable"))
7311 else if (unformat (i, "disable"))
7317 if (rx_sw_if_index_set == 0)
7319 errmsg ("missing rx interface name or sw_if_index");
7323 if (enable && (bd_id_set == 0))
7325 errmsg ("missing bridge domain");
7329 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
7331 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7332 mp->bd_id = ntohl (bd_id);
7334 mp->port_type = ntohl (port_type);
7335 mp->enable = enable;
7343 api_bridge_domain_dump (vat_main_t * vam)
7345 unformat_input_t *i = vam->input;
7346 vl_api_bridge_domain_dump_t *mp;
7347 vl_api_control_ping_t *mp_ping;
7351 /* Parse args required to build the message */
7352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7354 if (unformat (i, "bd_id %d", &bd_id))
7360 M (BRIDGE_DOMAIN_DUMP, mp);
7361 mp->bd_id = ntohl (bd_id);
7364 /* Use a control ping for synchronization */
7365 MPING (CONTROL_PING, mp_ping);
7373 api_bridge_domain_add_del (vat_main_t * vam)
7375 unformat_input_t *i = vam->input;
7376 vl_api_bridge_domain_add_del_t *mp;
7379 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7384 /* Parse args required to build the message */
7385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7387 if (unformat (i, "bd_id %d", &bd_id))
7389 else if (unformat (i, "flood %d", &flood))
7391 else if (unformat (i, "uu-flood %d", &uu_flood))
7393 else if (unformat (i, "forward %d", &forward))
7395 else if (unformat (i, "learn %d", &learn))
7397 else if (unformat (i, "arp-term %d", &arp_term))
7399 else if (unformat (i, "mac-age %d", &mac_age))
7401 else if (unformat (i, "bd-tag %s", &bd_tag))
7403 else if (unformat (i, "del"))
7406 flood = uu_flood = forward = learn = 0;
7414 errmsg ("missing bridge domain");
7421 errmsg ("mac age must be less than 256 ");
7426 if ((bd_tag) && (vec_len (bd_tag) > 63))
7428 errmsg ("bd-tag cannot be longer than 63");
7433 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7435 mp->bd_id = ntohl (bd_id);
7437 mp->uu_flood = uu_flood;
7438 mp->forward = forward;
7440 mp->arp_term = arp_term;
7441 mp->is_add = is_add;
7442 mp->mac_age = (u8) mac_age;
7445 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
7446 mp->bd_tag[vec_len (bd_tag)] = 0;
7457 api_l2fib_flush_bd (vat_main_t * vam)
7459 unformat_input_t *i = vam->input;
7460 vl_api_l2fib_flush_bd_t *mp;
7464 /* Parse args required to build the message */
7465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7467 if (unformat (i, "bd_id %d", &bd_id));
7474 errmsg ("missing bridge domain");
7478 M (L2FIB_FLUSH_BD, mp);
7480 mp->bd_id = htonl (bd_id);
7488 api_l2fib_flush_int (vat_main_t * vam)
7490 unformat_input_t *i = vam->input;
7491 vl_api_l2fib_flush_int_t *mp;
7492 u32 sw_if_index = ~0;
7495 /* Parse args required to build the message */
7496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7498 if (unformat (i, "sw_if_index %d", &sw_if_index));
7500 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7505 if (sw_if_index == ~0)
7507 errmsg ("missing interface name or sw_if_index");
7511 M (L2FIB_FLUSH_INT, mp);
7513 mp->sw_if_index = ntohl (sw_if_index);
7521 api_l2fib_add_del (vat_main_t * vam)
7523 unformat_input_t *i = vam->input;
7524 vl_api_l2fib_add_del_t *mp;
7530 u32 sw_if_index = 0;
7531 u8 sw_if_index_set = 0;
7540 /* Parse args required to build the message */
7541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7543 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7545 else if (unformat (i, "bd_id %d", &bd_id))
7547 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7548 sw_if_index_set = 1;
7549 else if (unformat (i, "sw_if"))
7551 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7554 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7555 sw_if_index_set = 1;
7560 else if (unformat (i, "static"))
7562 else if (unformat (i, "filter"))
7567 else if (unformat (i, "bvi"))
7572 else if (unformat (i, "del"))
7574 else if (unformat (i, "count %d", &count))
7582 errmsg ("missing mac address");
7588 errmsg ("missing bridge domain");
7592 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7594 errmsg ("missing interface name or sw_if_index");
7600 /* Turn on async mode */
7601 vam->async_mode = 1;
7602 vam->async_errors = 0;
7603 before = vat_time_now (vam);
7606 for (j = 0; j < count; j++)
7608 M (L2FIB_ADD_DEL, mp);
7610 clib_memcpy (mp->mac, mac, 6);
7611 mp->bd_id = ntohl (bd_id);
7612 mp->is_add = is_add;
7613 mp->sw_if_index = ntohl (sw_if_index);
7617 mp->static_mac = static_mac;
7618 mp->filter_mac = filter_mac;
7619 mp->bvi_mac = bvi_mac;
7621 increment_mac_address (mac);
7628 vl_api_control_ping_t *mp_ping;
7631 /* Shut off async mode */
7632 vam->async_mode = 0;
7634 MPING (CONTROL_PING, mp_ping);
7637 timeout = vat_time_now (vam) + 1.0;
7638 while (vat_time_now (vam) < timeout)
7639 if (vam->result_ready == 1)
7644 if (vam->retval == -99)
7647 if (vam->async_errors > 0)
7649 errmsg ("%d asynchronous errors", vam->async_errors);
7652 vam->async_errors = 0;
7653 after = vat_time_now (vam);
7655 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7656 count, after - before, count / (after - before));
7662 /* Wait for a reply... */
7666 /* Return the good/bad news */
7667 return (vam->retval);
7671 api_bridge_domain_set_mac_age (vat_main_t * vam)
7673 unformat_input_t *i = vam->input;
7674 vl_api_bridge_domain_set_mac_age_t *mp;
7679 /* Parse args required to build the message */
7680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7682 if (unformat (i, "bd_id %d", &bd_id));
7683 else if (unformat (i, "mac-age %d", &mac_age));
7690 errmsg ("missing bridge domain");
7696 errmsg ("mac age must be less than 256 ");
7700 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7702 mp->bd_id = htonl (bd_id);
7703 mp->mac_age = (u8) mac_age;
7711 api_l2_flags (vat_main_t * vam)
7713 unformat_input_t *i = vam->input;
7714 vl_api_l2_flags_t *mp;
7717 u8 sw_if_index_set = 0;
7721 /* Parse args required to build the message */
7722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7724 if (unformat (i, "sw_if_index %d", &sw_if_index))
7725 sw_if_index_set = 1;
7726 else if (unformat (i, "sw_if"))
7728 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7731 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7732 sw_if_index_set = 1;
7737 else if (unformat (i, "learn"))
7739 else if (unformat (i, "forward"))
7741 else if (unformat (i, "flood"))
7743 else if (unformat (i, "uu-flood"))
7744 flags |= L2_UU_FLOOD;
7745 else if (unformat (i, "arp-term"))
7746 flags |= L2_ARP_TERM;
7747 else if (unformat (i, "off"))
7749 else if (unformat (i, "disable"))
7755 if (sw_if_index_set == 0)
7757 errmsg ("missing interface name or sw_if_index");
7763 mp->sw_if_index = ntohl (sw_if_index);
7764 mp->feature_bitmap = ntohl (flags);
7765 mp->is_set = is_set;
7773 api_bridge_flags (vat_main_t * vam)
7775 unformat_input_t *i = vam->input;
7776 vl_api_bridge_flags_t *mp;
7780 bd_flags_t flags = 0;
7783 /* Parse args required to build the message */
7784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7786 if (unformat (i, "bd_id %d", &bd_id))
7788 else if (unformat (i, "learn"))
7789 flags |= BRIDGE_API_FLAG_LEARN;
7790 else if (unformat (i, "forward"))
7791 flags |= BRIDGE_API_FLAG_FWD;
7792 else if (unformat (i, "flood"))
7793 flags |= BRIDGE_API_FLAG_FLOOD;
7794 else if (unformat (i, "uu-flood"))
7795 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7796 else if (unformat (i, "arp-term"))
7797 flags |= BRIDGE_API_FLAG_ARP_TERM;
7798 else if (unformat (i, "off"))
7800 else if (unformat (i, "disable"))
7808 errmsg ("missing bridge domain");
7812 M (BRIDGE_FLAGS, mp);
7814 mp->bd_id = ntohl (bd_id);
7815 mp->flags = ntohl (flags);
7816 mp->is_set = is_set;
7824 api_bd_ip_mac_add_del (vat_main_t * vam)
7826 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7827 vl_api_mac_address_t mac = VL_API_ZERO_MAC_ADDRESS;
7828 unformat_input_t *i = vam->input;
7829 vl_api_bd_ip_mac_add_del_t *mp;
7841 /* Parse args required to build the message */
7842 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7844 if (unformat (i, "bd_id %d", &bd_id))
7848 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7852 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7856 else if (unformat (i, "del"))
7864 errmsg ("missing bridge domain");
7867 else if (ip_set == 0)
7869 errmsg ("missing IP address");
7872 else if (mac_set == 0)
7874 errmsg ("missing MAC address");
7878 M (BD_IP_MAC_ADD_DEL, mp);
7880 mp->bd_id = ntohl (bd_id);
7881 mp->is_add = is_add;
7883 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7884 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7891 static void vl_api_bd_ip_mac_details_t_handler
7892 (vl_api_bd_ip_mac_details_t * mp)
7894 vat_main_t *vam = &vat_main;
7899 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7902 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7905 "\n%-5d %-7s %-20U %-30s",
7906 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7907 format_ethernet_address, mp->mac_address, ip);
7912 static void vl_api_bd_ip_mac_details_t_handler_json
7913 (vl_api_bd_ip_mac_details_t * mp)
7915 vat_main_t *vam = &vat_main;
7916 vat_json_node_t *node = NULL;
7918 if (VAT_JSON_ARRAY != vam->json_tree.type)
7920 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7921 vat_json_init_array (&vam->json_tree);
7923 node = vat_json_array_add (&vam->json_tree);
7925 vat_json_init_object (node);
7926 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7927 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7928 vat_json_object_add_string_copy (node, "mac_address",
7929 format (0, "%U", format_ethernet_address,
7935 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7938 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7939 vat_json_object_add_string_copy (node, "ip_address", ip);
7944 api_bd_ip_mac_dump (vat_main_t * vam)
7946 unformat_input_t *i = vam->input;
7947 vl_api_bd_ip_mac_dump_t *mp;
7948 vl_api_control_ping_t *mp_ping;
7953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7955 if (unformat (i, "bd_id %d", &bd_id))
7964 "\n%-5s %-7s %-20s %-30s",
7965 "bd_id", "is_ipv6", "mac_address", "ip_address");
7967 /* Dump Bridge Domain Ip to Mac entries */
7968 M (BD_IP_MAC_DUMP, mp);
7971 mp->bd_id = htonl (bd_id);
7977 /* Use a control ping for synchronization */
7978 MPING (CONTROL_PING, mp_ping);
7986 api_tap_connect (vat_main_t * vam)
7988 unformat_input_t *i = vam->input;
7989 vl_api_tap_connect_t *mp;
7995 ip4_address_t ip4_address;
7997 int ip4_address_set = 0;
7998 ip6_address_t ip6_address;
8000 int ip6_address_set = 0;
8003 clib_memset (mac_address, 0, sizeof (mac_address));
8005 /* Parse args required to build the message */
8006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8008 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8012 else if (unformat (i, "random-mac"))
8014 else if (unformat (i, "tapname %s", &tap_name))
8016 else if (unformat (i, "tag %s", &tag))
8018 else if (unformat (i, "address %U/%d",
8019 unformat_ip4_address, &ip4_address, &ip4_mask_width))
8020 ip4_address_set = 1;
8021 else if (unformat (i, "address %U/%d",
8022 unformat_ip6_address, &ip6_address, &ip6_mask_width))
8023 ip6_address_set = 1;
8030 errmsg ("missing tap name");
8033 if (vec_len (tap_name) > 63)
8035 errmsg ("tap name too long");
8038 vec_add1 (tap_name, 0);
8040 if (vec_len (tag) > 63)
8042 errmsg ("tag too long");
8046 /* Construct the API message */
8047 M (TAP_CONNECT, mp);
8049 mp->use_random_mac = random_mac;
8050 clib_memcpy (mp->mac_address, mac_address, 6);
8051 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
8053 clib_memcpy (mp->tag, tag, vec_len (tag));
8055 if (ip4_address_set)
8057 mp->ip4_address_set = 1;
8058 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
8059 mp->ip4_mask_width = ip4_mask_width;
8061 if (ip6_address_set)
8063 mp->ip6_address_set = 1;
8064 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
8065 mp->ip6_mask_width = ip6_mask_width;
8068 vec_free (tap_name);
8074 /* Wait for a reply... */
8080 api_tap_modify (vat_main_t * vam)
8082 unformat_input_t *i = vam->input;
8083 vl_api_tap_modify_t *mp;
8088 u32 sw_if_index = ~0;
8089 u8 sw_if_index_set = 0;
8092 clib_memset (mac_address, 0, sizeof (mac_address));
8094 /* Parse args required to build the message */
8095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8098 sw_if_index_set = 1;
8099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8100 sw_if_index_set = 1;
8101 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
8105 else if (unformat (i, "random-mac"))
8107 else if (unformat (i, "tapname %s", &tap_name))
8113 if (sw_if_index_set == 0)
8115 errmsg ("missing vpp interface name");
8120 errmsg ("missing tap name");
8123 if (vec_len (tap_name) > 63)
8125 errmsg ("tap name too long");
8127 vec_add1 (tap_name, 0);
8129 /* Construct the API message */
8132 mp->use_random_mac = random_mac;
8133 mp->sw_if_index = ntohl (sw_if_index);
8134 clib_memcpy (mp->mac_address, mac_address, 6);
8135 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
8136 vec_free (tap_name);
8141 /* Wait for a reply... */
8147 api_tap_delete (vat_main_t * vam)
8149 unformat_input_t *i = vam->input;
8150 vl_api_tap_delete_t *mp;
8151 u32 sw_if_index = ~0;
8152 u8 sw_if_index_set = 0;
8155 /* Parse args required to build the message */
8156 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8158 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8159 sw_if_index_set = 1;
8160 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8161 sw_if_index_set = 1;
8166 if (sw_if_index_set == 0)
8168 errmsg ("missing vpp interface name");
8172 /* Construct the API message */
8175 mp->sw_if_index = ntohl (sw_if_index);
8180 /* Wait for a reply... */
8186 api_tap_create_v2 (vat_main_t * vam)
8188 unformat_input_t *i = vam->input;
8189 vl_api_tap_create_v2_t *mp;
8193 u8 *host_if_name = 0;
8195 u8 host_mac_addr[6];
8196 u8 host_mac_addr_set = 0;
8197 u8 *host_bridge = 0;
8198 ip4_address_t host_ip4_addr;
8199 ip4_address_t host_ip4_gw;
8200 u8 host_ip4_gw_set = 0;
8201 u32 host_ip4_prefix_len = 0;
8202 ip6_address_t host_ip6_addr;
8203 ip6_address_t host_ip6_gw;
8204 u8 host_ip6_gw_set = 0;
8205 u32 host_ip6_prefix_len = 0;
8207 u32 rx_ring_sz = 0, tx_ring_sz = 0;
8209 clib_memset (mac_address, 0, sizeof (mac_address));
8211 /* Parse args required to build the message */
8212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8214 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
8218 else if (unformat (i, "id %u", &id))
8220 else if (unformat (i, "host-if-name %s", &host_if_name))
8222 else if (unformat (i, "host-ns %s", &host_ns))
8224 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
8226 host_mac_addr_set = 1;
8227 else if (unformat (i, "host-bridge %s", &host_bridge))
8229 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
8230 &host_ip4_addr, &host_ip4_prefix_len))
8232 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
8233 &host_ip6_addr, &host_ip6_prefix_len))
8235 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
8237 host_ip4_gw_set = 1;
8238 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
8240 host_ip6_gw_set = 1;
8241 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
8243 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
8249 if (vec_len (host_if_name) > 63)
8251 errmsg ("tap name too long. ");
8254 if (vec_len (host_ns) > 63)
8256 errmsg ("host name space too long. ");
8259 if (vec_len (host_bridge) > 63)
8261 errmsg ("host bridge name too long. ");
8264 if (host_ip4_prefix_len > 32)
8266 errmsg ("host ip4 prefix length not valid. ");
8269 if (host_ip6_prefix_len > 128)
8271 errmsg ("host ip6 prefix length not valid. ");
8274 if (!is_pow2 (rx_ring_sz))
8276 errmsg ("rx ring size must be power of 2. ");
8279 if (rx_ring_sz > 32768)
8281 errmsg ("rx ring size must be 32768 or lower. ");
8284 if (!is_pow2 (tx_ring_sz))
8286 errmsg ("tx ring size must be power of 2. ");
8289 if (tx_ring_sz > 32768)
8291 errmsg ("tx ring size must be 32768 or lower. ");
8295 /* Construct the API message */
8296 M (TAP_CREATE_V2, mp);
8298 mp->use_random_mac = random_mac;
8300 mp->id = ntohl (id);
8301 mp->host_namespace_set = host_ns != 0;
8302 mp->host_bridge_set = host_bridge != 0;
8303 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
8304 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
8305 mp->rx_ring_sz = ntohs (rx_ring_sz);
8306 mp->tx_ring_sz = ntohs (tx_ring_sz);
8308 if (random_mac == 0)
8309 clib_memcpy (mp->mac_address, mac_address, 6);
8310 if (host_mac_addr_set)
8311 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
8313 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
8315 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
8317 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
8318 if (host_ip4_prefix_len)
8319 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
8320 if (host_ip6_prefix_len)
8321 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
8322 if (host_ip4_gw_set)
8323 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
8324 if (host_ip6_gw_set)
8325 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
8328 vec_free (host_if_name);
8329 vec_free (host_bridge);
8334 /* Wait for a reply... */
8340 api_tap_delete_v2 (vat_main_t * vam)
8342 unformat_input_t *i = vam->input;
8343 vl_api_tap_delete_v2_t *mp;
8344 u32 sw_if_index = ~0;
8345 u8 sw_if_index_set = 0;
8348 /* Parse args required to build the message */
8349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8351 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8352 sw_if_index_set = 1;
8353 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8354 sw_if_index_set = 1;
8359 if (sw_if_index_set == 0)
8361 errmsg ("missing vpp interface name. ");
8365 /* Construct the API message */
8366 M (TAP_DELETE_V2, mp);
8368 mp->sw_if_index = ntohl (sw_if_index);
8373 /* Wait for a reply... */
8379 api_bond_create (vat_main_t * vam)
8381 unformat_input_t *i = vam->input;
8382 vl_api_bond_create_t *mp;
8390 clib_memset (mac_address, 0, sizeof (mac_address));
8393 /* Parse args required to build the message */
8394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8396 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
8398 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
8399 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
8401 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
8408 if (mode_is_set == 0)
8410 errmsg ("Missing bond mode. ");
8414 /* Construct the API message */
8415 M (BOND_CREATE, mp);
8417 mp->use_custom_mac = custom_mac;
8423 clib_memcpy (mp->mac_address, mac_address, 6);
8428 /* Wait for a reply... */
8434 api_bond_delete (vat_main_t * vam)
8436 unformat_input_t *i = vam->input;
8437 vl_api_bond_delete_t *mp;
8438 u32 sw_if_index = ~0;
8439 u8 sw_if_index_set = 0;
8442 /* Parse args required to build the message */
8443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8445 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8446 sw_if_index_set = 1;
8447 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8448 sw_if_index_set = 1;
8453 if (sw_if_index_set == 0)
8455 errmsg ("missing vpp interface name. ");
8459 /* Construct the API message */
8460 M (BOND_DELETE, mp);
8462 mp->sw_if_index = ntohl (sw_if_index);
8467 /* Wait for a reply... */
8473 api_bond_enslave (vat_main_t * vam)
8475 unformat_input_t *i = vam->input;
8476 vl_api_bond_enslave_t *mp;
8477 u32 bond_sw_if_index;
8481 u32 bond_sw_if_index_is_set = 0;
8483 u8 sw_if_index_is_set = 0;
8485 /* Parse args required to build the message */
8486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8488 if (unformat (i, "sw_if_index %d", &sw_if_index))
8489 sw_if_index_is_set = 1;
8490 else if (unformat (i, "bond %u", &bond_sw_if_index))
8491 bond_sw_if_index_is_set = 1;
8492 else if (unformat (i, "passive %d", &is_passive))
8494 else if (unformat (i, "long-timeout %d", &is_long_timeout))
8500 if (bond_sw_if_index_is_set == 0)
8502 errmsg ("Missing bond sw_if_index. ");
8505 if (sw_if_index_is_set == 0)
8507 errmsg ("Missing slave sw_if_index. ");
8511 /* Construct the API message */
8512 M (BOND_ENSLAVE, mp);
8514 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
8515 mp->sw_if_index = ntohl (sw_if_index);
8516 mp->is_long_timeout = is_long_timeout;
8517 mp->is_passive = is_passive;
8522 /* Wait for a reply... */
8528 api_bond_detach_slave (vat_main_t * vam)
8530 unformat_input_t *i = vam->input;
8531 vl_api_bond_detach_slave_t *mp;
8532 u32 sw_if_index = ~0;
8533 u8 sw_if_index_set = 0;
8536 /* Parse args required to build the message */
8537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8539 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8540 sw_if_index_set = 1;
8541 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8542 sw_if_index_set = 1;
8547 if (sw_if_index_set == 0)
8549 errmsg ("missing vpp interface name. ");
8553 /* Construct the API message */
8554 M (BOND_DETACH_SLAVE, mp);
8556 mp->sw_if_index = ntohl (sw_if_index);
8561 /* Wait for a reply... */
8567 api_ip_table_add_del (vat_main_t * vam)
8569 unformat_input_t *i = vam->input;
8570 vl_api_ip_table_add_del_t *mp;
8576 /* Parse args required to build the message */
8577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8579 if (unformat (i, "ipv6"))
8581 else if (unformat (i, "del"))
8583 else if (unformat (i, "add"))
8585 else if (unformat (i, "table %d", &table_id))
8589 clib_warning ("parse error '%U'", format_unformat_error, i);
8596 errmsg ("missing table-ID");
8600 /* Construct the API message */
8601 M (IP_TABLE_ADD_DEL, mp);
8603 mp->table_id = ntohl (table_id);
8604 mp->is_ipv6 = is_ipv6;
8605 mp->is_add = is_add;
8610 /* Wait for a reply... */
8617 api_ip_add_del_route (vat_main_t * vam)
8619 unformat_input_t *i = vam->input;
8620 vl_api_ip_add_del_route_t *mp;
8621 u32 sw_if_index = ~0, vrf_id = 0;
8623 u8 is_local = 0, is_drop = 0;
8624 u8 is_unreach = 0, is_prohibit = 0;
8626 u32 next_hop_weight = 1;
8627 u8 is_multipath = 0;
8629 u8 address_length_set = 0;
8630 u32 next_hop_table_id = 0;
8631 u32 resolve_attempts = 0;
8632 u32 dst_address_length = 0;
8633 u8 next_hop_set = 0;
8634 ip4_address_t v4_dst_address, v4_next_hop_address;
8635 ip6_address_t v6_dst_address, v6_next_hop_address;
8639 u32 random_add_del = 0;
8640 u32 *random_vector = 0;
8642 u32 random_seed = 0xdeaddabe;
8643 u32 classify_table_index = ~0;
8645 u8 resolve_host = 0, resolve_attached = 0;
8646 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8647 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8648 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8650 clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
8651 clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
8652 /* Parse args required to build the message */
8653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8655 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8657 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8659 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8664 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8669 else if (unformat (i, "/%d", &dst_address_length))
8671 address_length_set = 1;
8674 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8675 &v4_next_hop_address))
8679 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8680 &v6_next_hop_address))
8686 (i, "via %U", api_unformat_sw_if_index, vam, &sw_if_index))
8690 else if (unformat (i, "via sw_if_index %d", &sw_if_index))
8694 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8696 else if (unformat (i, "weight %d", &next_hop_weight))
8698 else if (unformat (i, "drop"))
8702 else if (unformat (i, "null-send-unreach"))
8706 else if (unformat (i, "null-send-prohibit"))
8710 else if (unformat (i, "local"))
8714 else if (unformat (i, "classify %d", &classify_table_index))
8718 else if (unformat (i, "del"))
8720 else if (unformat (i, "add"))
8722 else if (unformat (i, "resolve-via-host"))
8724 else if (unformat (i, "resolve-via-attached"))
8725 resolve_attached = 1;
8726 else if (unformat (i, "multipath"))
8728 else if (unformat (i, "vrf %d", &vrf_id))
8730 else if (unformat (i, "count %d", &count))
8732 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8734 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8736 else if (unformat (i, "out-label %d", &next_hop_out_label))
8738 vl_api_fib_mpls_label_t fib_label = {
8739 .label = ntohl (next_hop_out_label),
8743 vec_add1 (next_hop_out_label_stack, fib_label);
8745 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8747 else if (unformat (i, "random"))
8749 else if (unformat (i, "seed %d", &random_seed))
8753 clib_warning ("parse error '%U'", format_unformat_error, i);
8758 if (!next_hop_set && !is_drop && !is_local &&
8759 !is_classify && !is_unreach && !is_prohibit &&
8760 MPLS_LABEL_INVALID == next_hop_via_label)
8763 ("next hop / local / drop / unreach / prohibit / classify not set");
8767 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8769 errmsg ("next hop and next-hop via label set");
8772 if (address_set == 0)
8774 errmsg ("missing addresses");
8778 if (address_length_set == 0)
8780 errmsg ("missing address length");
8784 /* Generate a pile of unique, random routes */
8787 u32 this_random_address;
8788 random_hash = hash_create (count, sizeof (uword));
8790 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8791 for (j = 0; j <= count; j++)
8795 this_random_address = random_u32 (&random_seed);
8796 this_random_address =
8797 clib_host_to_net_u32 (this_random_address);
8799 while (hash_get (random_hash, this_random_address));
8800 vec_add1 (random_vector, this_random_address);
8801 hash_set (random_hash, this_random_address, 1);
8803 hash_free (random_hash);
8804 v4_dst_address.as_u32 = random_vector[0];
8809 /* Turn on async mode */
8810 vam->async_mode = 1;
8811 vam->async_errors = 0;
8812 before = vat_time_now (vam);
8815 for (j = 0; j < count; j++)
8817 /* Construct the API message */
8818 M2 (IP_ADD_DEL_ROUTE, mp, sizeof (vl_api_fib_mpls_label_t) *
8819 vec_len (next_hop_out_label_stack));
8821 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8822 mp->table_id = ntohl (vrf_id);
8824 mp->is_add = is_add;
8825 mp->is_drop = is_drop;
8826 mp->is_unreach = is_unreach;
8827 mp->is_prohibit = is_prohibit;
8828 mp->is_ipv6 = is_ipv6;
8829 mp->is_local = is_local;
8830 mp->is_classify = is_classify;
8831 mp->is_multipath = is_multipath;
8832 mp->is_resolve_host = resolve_host;
8833 mp->is_resolve_attached = resolve_attached;
8834 mp->next_hop_weight = next_hop_weight;
8835 mp->next_hop_preference = 0;
8836 mp->dst_address_length = dst_address_length;
8837 mp->next_hop_table_id = ntohl (next_hop_table_id);
8838 mp->classify_table_index = ntohl (classify_table_index);
8839 mp->next_hop_via_label = ntohl (next_hop_via_label);
8840 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8841 if (0 != mp->next_hop_n_out_labels)
8843 memcpy (mp->next_hop_out_label_stack,
8844 next_hop_out_label_stack,
8845 (vec_len (next_hop_out_label_stack) *
8846 sizeof (vl_api_fib_mpls_label_t)));
8847 vec_free (next_hop_out_label_stack);
8852 clib_memcpy (mp->dst_address, &v6_dst_address,
8853 sizeof (v6_dst_address));
8855 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8856 sizeof (v6_next_hop_address));
8857 increment_v6_address (&v6_dst_address);
8861 clib_memcpy (mp->dst_address, &v4_dst_address,
8862 sizeof (v4_dst_address));
8864 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8865 sizeof (v4_next_hop_address));
8867 v4_dst_address.as_u32 = random_vector[j + 1];
8869 increment_v4_address (&v4_dst_address);
8873 /* If we receive SIGTERM, stop now... */
8878 /* When testing multiple add/del ops, use a control-ping to sync */
8881 vl_api_control_ping_t *mp_ping;
8885 /* Shut off async mode */
8886 vam->async_mode = 0;
8888 MPING (CONTROL_PING, mp_ping);
8891 timeout = vat_time_now (vam) + 1.0;
8892 while (vat_time_now (vam) < timeout)
8893 if (vam->result_ready == 1)
8898 if (vam->retval == -99)
8901 if (vam->async_errors > 0)
8903 errmsg ("%d asynchronous errors", vam->async_errors);
8906 vam->async_errors = 0;
8907 after = vat_time_now (vam);
8909 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8913 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8914 count, after - before, count / (after - before));
8920 /* Wait for a reply... */
8925 /* Return the good/bad news */
8926 return (vam->retval);
8930 api_ip_mroute_add_del (vat_main_t * vam)
8932 unformat_input_t *i = vam->input;
8933 vl_api_ip_mroute_add_del_t *mp;
8934 u32 sw_if_index = ~0, vrf_id = 0;
8939 u32 grp_address_length = 0;
8940 ip4_address_t v4_grp_address, v4_src_address;
8941 ip6_address_t v6_grp_address, v6_src_address;
8942 mfib_itf_flags_t iflags = 0;
8943 mfib_entry_flags_t eflags = 0;
8946 /* Parse args required to build the message */
8947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8949 if (unformat (i, "sw_if_index %d", &sw_if_index))
8951 else if (unformat (i, "%U %U",
8952 unformat_ip4_address, &v4_src_address,
8953 unformat_ip4_address, &v4_grp_address))
8955 grp_address_length = 64;
8959 else if (unformat (i, "%U %U",
8960 unformat_ip6_address, &v6_src_address,
8961 unformat_ip6_address, &v6_grp_address))
8963 grp_address_length = 256;
8967 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8969 clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
8970 grp_address_length = 32;
8974 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8976 clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
8977 grp_address_length = 128;
8981 else if (unformat (i, "/%d", &grp_address_length))
8983 else if (unformat (i, "local"))
8987 else if (unformat (i, "del"))
8989 else if (unformat (i, "add"))
8991 else if (unformat (i, "vrf %d", &vrf_id))
8993 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8995 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8999 clib_warning ("parse error '%U'", format_unformat_error, i);
9004 if (address_set == 0)
9006 errmsg ("missing addresses\n");
9010 /* Construct the API message */
9011 M (IP_MROUTE_ADD_DEL, mp);
9013 mp->next_hop_sw_if_index = ntohl (sw_if_index);
9014 mp->table_id = ntohl (vrf_id);
9016 mp->is_add = is_add;
9017 mp->is_ipv6 = is_ipv6;
9018 mp->is_local = is_local;
9019 mp->itf_flags = ntohl (iflags);
9020 mp->entry_flags = ntohl (eflags);
9021 mp->grp_address_length = grp_address_length;
9022 mp->grp_address_length = ntohs (mp->grp_address_length);
9026 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
9027 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
9031 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
9032 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
9038 /* Wait for a reply... */
9044 api_mpls_table_add_del (vat_main_t * vam)
9046 unformat_input_t *i = vam->input;
9047 vl_api_mpls_table_add_del_t *mp;
9052 /* Parse args required to build the message */
9053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9055 if (unformat (i, "table %d", &table_id))
9057 else if (unformat (i, "del"))
9059 else if (unformat (i, "add"))
9063 clib_warning ("parse error '%U'", format_unformat_error, i);
9070 errmsg ("missing table-ID");
9074 /* Construct the API message */
9075 M (MPLS_TABLE_ADD_DEL, mp);
9077 mp->mt_table_id = ntohl (table_id);
9078 mp->mt_is_add = is_add;
9083 /* Wait for a reply... */
9090 api_mpls_route_add_del (vat_main_t * vam)
9092 unformat_input_t *i = vam->input;
9093 vl_api_mpls_route_add_del_t *mp;
9094 u32 sw_if_index = ~0, table_id = 0;
9096 u32 next_hop_weight = 1;
9097 u8 is_multipath = 0;
9098 u32 next_hop_table_id = 0;
9099 u8 next_hop_set = 0;
9100 ip4_address_t v4_next_hop_address = {
9103 ip6_address_t v6_next_hop_address = { {0} };
9107 u32 classify_table_index = ~0;
9109 u8 resolve_host = 0, resolve_attached = 0;
9110 u8 is_interface_rx = 0;
9111 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9112 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9113 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9114 mpls_label_t local_label = MPLS_LABEL_INVALID;
9116 dpo_proto_t next_hop_proto = DPO_PROTO_MPLS;
9118 /* Parse args required to build the message */
9119 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9121 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9123 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9125 else if (unformat (i, "%d", &local_label))
9127 else if (unformat (i, "eos"))
9129 else if (unformat (i, "non-eos"))
9131 else if (unformat (i, "via %U", unformat_ip4_address,
9132 &v4_next_hop_address))
9135 next_hop_proto = DPO_PROTO_IP4;
9137 else if (unformat (i, "via %U", unformat_ip6_address,
9138 &v6_next_hop_address))
9141 next_hop_proto = DPO_PROTO_IP6;
9143 else if (unformat (i, "weight %d", &next_hop_weight))
9145 else if (unformat (i, "classify %d", &classify_table_index))
9149 else if (unformat (i, "del"))
9151 else if (unformat (i, "add"))
9153 else if (unformat (i, "resolve-via-host"))
9155 else if (unformat (i, "resolve-via-attached"))
9156 resolve_attached = 1;
9157 else if (unformat (i, "multipath"))
9159 else if (unformat (i, "count %d", &count))
9161 else if (unformat (i, "via lookup-in-ip4-table %d", &next_hop_table_id))
9164 next_hop_proto = DPO_PROTO_IP4;
9166 else if (unformat (i, "via lookup-in-ip6-table %d", &next_hop_table_id))
9169 next_hop_proto = DPO_PROTO_IP6;
9173 (i, "via l2-input-on %U", api_unformat_sw_if_index, vam,
9177 next_hop_proto = DPO_PROTO_ETHERNET;
9178 is_interface_rx = 1;
9180 else if (unformat (i, "via l2-input-on sw_if_index %d", &sw_if_index))
9183 next_hop_proto = DPO_PROTO_ETHERNET;
9184 is_interface_rx = 1;
9186 else if (unformat (i, "via next-hop-table %d", &next_hop_table_id))
9188 else if (unformat (i, "via via-label %d", &next_hop_via_label))
9190 else if (unformat (i, "out-label %d", &next_hop_out_label))
9192 vl_api_fib_mpls_label_t fib_label = {
9193 .label = ntohl (next_hop_out_label),
9197 vec_add1 (next_hop_out_label_stack, fib_label);
9201 clib_warning ("parse error '%U'", format_unformat_error, i);
9206 if (!next_hop_set && !is_classify)
9208 errmsg ("next hop / classify not set");
9212 if (MPLS_LABEL_INVALID == local_label)
9214 errmsg ("missing label");
9220 /* Turn on async mode */
9221 vam->async_mode = 1;
9222 vam->async_errors = 0;
9223 before = vat_time_now (vam);
9226 for (j = 0; j < count; j++)
9228 /* Construct the API message */
9229 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9230 vec_len (next_hop_out_label_stack));
9232 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
9233 mp->mr_table_id = ntohl (table_id);
9235 mp->mr_is_add = is_add;
9236 mp->mr_next_hop_proto = next_hop_proto;
9237 mp->mr_is_classify = is_classify;
9238 mp->mr_is_multipath = is_multipath;
9239 mp->mr_is_resolve_host = resolve_host;
9240 mp->mr_is_resolve_attached = resolve_attached;
9241 mp->mr_is_interface_rx = is_interface_rx;
9242 mp->mr_next_hop_weight = next_hop_weight;
9243 mp->mr_next_hop_preference = 0;
9244 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
9245 mp->mr_classify_table_index = ntohl (classify_table_index);
9246 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
9247 mp->mr_label = ntohl (local_label);
9248 mp->mr_eos = is_eos;
9250 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9251 if (0 != mp->mr_next_hop_n_out_labels)
9253 memcpy (mp->mr_next_hop_out_label_stack,
9254 next_hop_out_label_stack,
9255 vec_len (next_hop_out_label_stack) *
9256 sizeof (vl_api_fib_mpls_label_t));
9257 vec_free (next_hop_out_label_stack);
9262 if (DPO_PROTO_IP4 == next_hop_proto)
9264 clib_memcpy (mp->mr_next_hop,
9265 &v4_next_hop_address,
9266 sizeof (v4_next_hop_address));
9268 else if (DPO_PROTO_IP6 == next_hop_proto)
9271 clib_memcpy (mp->mr_next_hop,
9272 &v6_next_hop_address,
9273 sizeof (v6_next_hop_address));
9280 /* If we receive SIGTERM, stop now... */
9285 /* When testing multiple add/del ops, use a control-ping to sync */
9288 vl_api_control_ping_t *mp_ping;
9292 /* Shut off async mode */
9293 vam->async_mode = 0;
9295 MPING (CONTROL_PING, mp_ping);
9298 timeout = vat_time_now (vam) + 1.0;
9299 while (vat_time_now (vam) < timeout)
9300 if (vam->result_ready == 1)
9305 if (vam->retval == -99)
9308 if (vam->async_errors > 0)
9310 errmsg ("%d asynchronous errors", vam->async_errors);
9313 vam->async_errors = 0;
9314 after = vat_time_now (vam);
9316 /* slim chance, but we might have eaten SIGTERM on the first iteration */
9320 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
9321 count, after - before, count / (after - before));
9327 /* Wait for a reply... */
9332 /* Return the good/bad news */
9333 return (vam->retval);
9337 api_mpls_ip_bind_unbind (vat_main_t * vam)
9339 unformat_input_t *i = vam->input;
9340 vl_api_mpls_ip_bind_unbind_t *mp;
9341 u32 ip_table_id = 0;
9344 ip4_address_t v4_address;
9345 ip6_address_t v6_address;
9348 mpls_label_t local_label = MPLS_LABEL_INVALID;
9351 /* Parse args required to build the message */
9352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9354 if (unformat (i, "%U/%d", unformat_ip4_address,
9355 &v4_address, &address_length))
9360 else if (unformat (i, "%U/%d", unformat_ip6_address,
9361 &v6_address, &address_length))
9366 else if (unformat (i, "%d", &local_label))
9368 else if (unformat (i, "table-id %d", &ip_table_id))
9370 else if (unformat (i, "unbind"))
9372 else if (unformat (i, "bind"))
9376 clib_warning ("parse error '%U'", format_unformat_error, i);
9383 errmsg ("IP address not set");
9387 if (MPLS_LABEL_INVALID == local_label)
9389 errmsg ("missing label");
9393 /* Construct the API message */
9394 M (MPLS_IP_BIND_UNBIND, mp);
9396 mp->mb_is_bind = is_bind;
9397 mp->mb_is_ip4 = is_ip4;
9398 mp->mb_ip_table_id = ntohl (ip_table_id);
9399 mp->mb_mpls_table_id = 0;
9400 mp->mb_label = ntohl (local_label);
9401 mp->mb_address_length = address_length;
9404 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
9406 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
9411 /* Wait for a reply... */
9417 api_sr_mpls_policy_add (vat_main_t * vam)
9419 unformat_input_t *i = vam->input;
9420 vl_api_sr_mpls_policy_add_t *mp;
9426 u32 *segments = NULL;
9429 /* Parse args required to build the message */
9430 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9432 if (unformat (i, "bsid %d", &bsid))
9434 else if (unformat (i, "weight %d", &weight))
9436 else if (unformat (i, "spray"))
9438 else if (unformat (i, "next %d", &sid))
9441 vec_add1 (segments, htonl (sid));
9445 clib_warning ("parse error '%U'", format_unformat_error, i);
9452 errmsg ("bsid not set");
9456 if (n_segments == 0)
9458 errmsg ("no sid in segment stack");
9462 /* Construct the API message */
9463 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
9465 mp->bsid = htonl (bsid);
9466 mp->weight = htonl (weight);
9468 mp->n_segments = n_segments;
9469 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
9470 vec_free (segments);
9475 /* Wait for a reply... */
9481 api_sr_mpls_policy_del (vat_main_t * vam)
9483 unformat_input_t *i = vam->input;
9484 vl_api_sr_mpls_policy_del_t *mp;
9488 /* Parse args required to build the message */
9489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9491 if (unformat (i, "bsid %d", &bsid))
9495 clib_warning ("parse error '%U'", format_unformat_error, i);
9502 errmsg ("bsid not set");
9506 /* Construct the API message */
9507 M (SR_MPLS_POLICY_DEL, mp);
9509 mp->bsid = htonl (bsid);
9514 /* Wait for a reply... */
9520 api_bier_table_add_del (vat_main_t * vam)
9522 unformat_input_t *i = vam->input;
9523 vl_api_bier_table_add_del_t *mp;
9525 u32 set = 0, sub_domain = 0, hdr_len = 3;
9526 mpls_label_t local_label = MPLS_LABEL_INVALID;
9529 /* Parse args required to build the message */
9530 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9532 if (unformat (i, "sub-domain %d", &sub_domain))
9534 else if (unformat (i, "set %d", &set))
9536 else if (unformat (i, "label %d", &local_label))
9538 else if (unformat (i, "hdr-len %d", &hdr_len))
9540 else if (unformat (i, "add"))
9542 else if (unformat (i, "del"))
9546 clib_warning ("parse error '%U'", format_unformat_error, i);
9551 if (MPLS_LABEL_INVALID == local_label)
9553 errmsg ("missing label\n");
9557 /* Construct the API message */
9558 M (BIER_TABLE_ADD_DEL, mp);
9560 mp->bt_is_add = is_add;
9561 mp->bt_label = ntohl (local_label);
9562 mp->bt_tbl_id.bt_set = set;
9563 mp->bt_tbl_id.bt_sub_domain = sub_domain;
9564 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
9569 /* Wait for a reply... */
9576 api_bier_route_add_del (vat_main_t * vam)
9578 unformat_input_t *i = vam->input;
9579 vl_api_bier_route_add_del_t *mp;
9581 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
9582 ip4_address_t v4_next_hop_address;
9583 ip6_address_t v6_next_hop_address;
9584 u8 next_hop_set = 0;
9585 u8 next_hop_proto_is_ip4 = 1;
9586 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9589 /* Parse args required to build the message */
9590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9592 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
9594 next_hop_proto_is_ip4 = 1;
9597 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
9599 next_hop_proto_is_ip4 = 0;
9602 if (unformat (i, "sub-domain %d", &sub_domain))
9604 else if (unformat (i, "set %d", &set))
9606 else if (unformat (i, "hdr-len %d", &hdr_len))
9608 else if (unformat (i, "bp %d", &bp))
9610 else if (unformat (i, "add"))
9612 else if (unformat (i, "del"))
9614 else if (unformat (i, "out-label %d", &next_hop_out_label))
9618 clib_warning ("parse error '%U'", format_unformat_error, i);
9623 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9625 errmsg ("next hop / label set\n");
9630 errmsg ("bit=position not set\n");
9634 /* Construct the API message */
9635 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9637 mp->br_is_add = is_add;
9638 mp->br_tbl_id.bt_set = set;
9639 mp->br_tbl_id.bt_sub_domain = sub_domain;
9640 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9641 mp->br_bp = ntohs (bp);
9643 mp->br_paths[0].n_labels = 1;
9644 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9645 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9647 if (next_hop_proto_is_ip4)
9649 clib_memcpy (mp->br_paths[0].next_hop,
9650 &v4_next_hop_address, sizeof (v4_next_hop_address));
9654 clib_memcpy (mp->br_paths[0].next_hop,
9655 &v6_next_hop_address, sizeof (v6_next_hop_address));
9661 /* Wait for a reply... */
9668 api_proxy_arp_add_del (vat_main_t * vam)
9670 unformat_input_t *i = vam->input;
9671 vl_api_proxy_arp_add_del_t *mp;
9674 ip4_address_t lo, hi;
9678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9680 if (unformat (i, "vrf %d", &vrf_id))
9682 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
9683 unformat_ip4_address, &hi))
9685 else if (unformat (i, "del"))
9689 clib_warning ("parse error '%U'", format_unformat_error, i);
9696 errmsg ("address range not set");
9700 M (PROXY_ARP_ADD_DEL, mp);
9702 mp->proxy.vrf_id = ntohl (vrf_id);
9703 mp->is_add = is_add;
9704 clib_memcpy (mp->proxy.low_address, &lo, sizeof (mp->proxy.low_address));
9705 clib_memcpy (mp->proxy.hi_address, &hi, sizeof (mp->proxy.hi_address));
9713 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9715 unformat_input_t *i = vam->input;
9716 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9719 u8 sw_if_index_set = 0;
9722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9724 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9725 sw_if_index_set = 1;
9726 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9727 sw_if_index_set = 1;
9728 else if (unformat (i, "enable"))
9730 else if (unformat (i, "disable"))
9734 clib_warning ("parse error '%U'", format_unformat_error, i);
9739 if (sw_if_index_set == 0)
9741 errmsg ("missing interface name or sw_if_index");
9745 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9747 mp->sw_if_index = ntohl (sw_if_index);
9748 mp->enable_disable = enable;
9756 api_mpls_tunnel_add_del (vat_main_t * vam)
9758 unformat_input_t *i = vam->input;
9759 vl_api_mpls_tunnel_add_del_t *mp;
9763 u32 sw_if_index = ~0;
9764 u32 next_hop_sw_if_index = ~0;
9765 u32 next_hop_proto_is_ip4 = 1;
9767 u32 next_hop_table_id = 0;
9768 ip4_address_t v4_next_hop_address = {
9771 ip6_address_t v6_next_hop_address = { {0} };
9772 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9773 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9774 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9777 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9779 if (unformat (i, "add"))
9783 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9785 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9787 else if (unformat (i, "via %U",
9788 unformat_ip4_address, &v4_next_hop_address))
9790 next_hop_proto_is_ip4 = 1;
9792 else if (unformat (i, "via %U",
9793 unformat_ip6_address, &v6_next_hop_address))
9795 next_hop_proto_is_ip4 = 0;
9797 else if (unformat (i, "via-label %d", &next_hop_via_label))
9801 (i, "%U", api_unformat_sw_if_index, vam, &next_hop_sw_if_index))
9803 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9805 else if (unformat (i, "l2-only"))
9807 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9809 else if (unformat (i, "out-label %d", &next_hop_out_label))
9811 vl_api_fib_mpls_label_t fib_label = {
9812 .label = ntohl (next_hop_out_label),
9816 vec_add1 (next_hop_out_label_stack, fib_label);
9820 clib_warning ("parse error '%U'", format_unformat_error, i);
9825 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9826 vec_len (next_hop_out_label_stack));
9828 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9829 mp->mt_sw_if_index = ntohl (sw_if_index);
9830 mp->mt_is_add = is_add;
9831 mp->mt_l2_only = l2_only;
9832 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9833 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9834 mp->mt_next_hop_via_label = ntohl (next_hop_via_label);
9835 mp->mt_next_hop_weight = 1;
9836 mp->mt_next_hop_preference = 0;
9838 mp->mt_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9840 if (0 != mp->mt_next_hop_n_out_labels)
9842 clib_memcpy (mp->mt_next_hop_out_label_stack,
9843 next_hop_out_label_stack,
9844 (vec_len (next_hop_out_label_stack) *
9845 sizeof (vl_api_fib_mpls_label_t)));
9846 vec_free (next_hop_out_label_stack);
9849 if (next_hop_proto_is_ip4)
9851 clib_memcpy (mp->mt_next_hop,
9852 &v4_next_hop_address, sizeof (v4_next_hop_address));
9856 clib_memcpy (mp->mt_next_hop,
9857 &v6_next_hop_address, sizeof (v6_next_hop_address));
9866 api_sw_interface_set_unnumbered (vat_main_t * vam)
9868 unformat_input_t *i = vam->input;
9869 vl_api_sw_interface_set_unnumbered_t *mp;
9871 u32 unnum_sw_index = ~0;
9873 u8 sw_if_index_set = 0;
9876 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9878 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9879 sw_if_index_set = 1;
9880 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9881 sw_if_index_set = 1;
9882 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9884 else if (unformat (i, "del"))
9888 clib_warning ("parse error '%U'", format_unformat_error, i);
9893 if (sw_if_index_set == 0)
9895 errmsg ("missing interface name or sw_if_index");
9899 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9901 mp->sw_if_index = ntohl (sw_if_index);
9902 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9903 mp->is_add = is_add;
9911 api_ip_neighbor_add_del (vat_main_t * vam)
9913 unformat_input_t *i = vam->input;
9914 vl_api_ip_neighbor_add_del_t *mp;
9916 u8 sw_if_index_set = 0;
9919 u8 is_no_fib_entry = 0;
9922 u8 v4_address_set = 0;
9923 u8 v6_address_set = 0;
9924 ip4_address_t v4address;
9925 ip6_address_t v6address;
9928 clib_memset (mac_address, 0, sizeof (mac_address));
9930 /* Parse args required to build the message */
9931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9933 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9937 else if (unformat (i, "del"))
9940 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9941 sw_if_index_set = 1;
9942 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9943 sw_if_index_set = 1;
9944 else if (unformat (i, "is_static"))
9946 else if (unformat (i, "no-fib-entry"))
9947 is_no_fib_entry = 1;
9948 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9950 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9954 clib_warning ("parse error '%U'", format_unformat_error, i);
9959 if (sw_if_index_set == 0)
9961 errmsg ("missing interface name or sw_if_index");
9964 if (v4_address_set && v6_address_set)
9966 errmsg ("both v4 and v6 addresses set");
9969 if (!v4_address_set && !v6_address_set)
9971 errmsg ("no address set");
9975 /* Construct the API message */
9976 M (IP_NEIGHBOR_ADD_DEL, mp);
9978 mp->sw_if_index = ntohl (sw_if_index);
9979 mp->is_add = is_add;
9980 mp->is_static = is_static;
9981 mp->is_no_adj_fib = is_no_fib_entry;
9983 clib_memcpy (mp->mac_address, mac_address, 6);
9987 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9991 /* mp->is_ipv6 = 0; via clib_memset in M macro above */
9992 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9998 /* Wait for a reply, return good/bad news */
10004 api_create_vlan_subif (vat_main_t * vam)
10006 unformat_input_t *i = vam->input;
10007 vl_api_create_vlan_subif_t *mp;
10009 u8 sw_if_index_set = 0;
10011 u8 vlan_id_set = 0;
10014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10016 if (unformat (i, "sw_if_index %d", &sw_if_index))
10017 sw_if_index_set = 1;
10019 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10020 sw_if_index_set = 1;
10021 else if (unformat (i, "vlan %d", &vlan_id))
10025 clib_warning ("parse error '%U'", format_unformat_error, i);
10030 if (sw_if_index_set == 0)
10032 errmsg ("missing interface name or sw_if_index");
10036 if (vlan_id_set == 0)
10038 errmsg ("missing vlan_id");
10041 M (CREATE_VLAN_SUBIF, mp);
10043 mp->sw_if_index = ntohl (sw_if_index);
10044 mp->vlan_id = ntohl (vlan_id);
10051 #define foreach_create_subif_bit \
10058 _(outer_vlan_id_any) \
10059 _(inner_vlan_id_any)
10062 api_create_subif (vat_main_t * vam)
10064 unformat_input_t *i = vam->input;
10065 vl_api_create_subif_t *mp;
10067 u8 sw_if_index_set = 0;
10074 u32 exact_match = 0;
10075 u32 default_sub = 0;
10076 u32 outer_vlan_id_any = 0;
10077 u32 inner_vlan_id_any = 0;
10079 u16 outer_vlan_id = 0;
10080 u16 inner_vlan_id = 0;
10083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10085 if (unformat (i, "sw_if_index %d", &sw_if_index))
10086 sw_if_index_set = 1;
10088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10089 sw_if_index_set = 1;
10090 else if (unformat (i, "sub_id %d", &sub_id))
10092 else if (unformat (i, "outer_vlan_id %d", &tmp))
10093 outer_vlan_id = tmp;
10094 else if (unformat (i, "inner_vlan_id %d", &tmp))
10095 inner_vlan_id = tmp;
10097 #define _(a) else if (unformat (i, #a)) a = 1 ;
10098 foreach_create_subif_bit
10102 clib_warning ("parse error '%U'", format_unformat_error, i);
10107 if (sw_if_index_set == 0)
10109 errmsg ("missing interface name or sw_if_index");
10113 if (sub_id_set == 0)
10115 errmsg ("missing sub_id");
10118 M (CREATE_SUBIF, mp);
10120 mp->sw_if_index = ntohl (sw_if_index);
10121 mp->sub_id = ntohl (sub_id);
10123 #define _(a) mp->a = a;
10124 foreach_create_subif_bit;
10127 mp->outer_vlan_id = ntohs (outer_vlan_id);
10128 mp->inner_vlan_id = ntohs (inner_vlan_id);
10136 api_oam_add_del (vat_main_t * vam)
10138 unformat_input_t *i = vam->input;
10139 vl_api_oam_add_del_t *mp;
10142 ip4_address_t src, dst;
10147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10149 if (unformat (i, "vrf %d", &vrf_id))
10151 else if (unformat (i, "src %U", unformat_ip4_address, &src))
10153 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
10155 else if (unformat (i, "del"))
10159 clib_warning ("parse error '%U'", format_unformat_error, i);
10166 errmsg ("missing src addr");
10172 errmsg ("missing dst addr");
10176 M (OAM_ADD_DEL, mp);
10178 mp->vrf_id = ntohl (vrf_id);
10179 mp->is_add = is_add;
10180 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
10181 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
10189 api_reset_fib (vat_main_t * vam)
10191 unformat_input_t *i = vam->input;
10192 vl_api_reset_fib_t *mp;
10198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10200 if (unformat (i, "vrf %d", &vrf_id))
10202 else if (unformat (i, "ipv6"))
10206 clib_warning ("parse error '%U'", format_unformat_error, i);
10211 if (vrf_id_set == 0)
10213 errmsg ("missing vrf id");
10219 mp->vrf_id = ntohl (vrf_id);
10220 mp->is_ipv6 = is_ipv6;
10228 api_dhcp_proxy_config (vat_main_t * vam)
10230 unformat_input_t *i = vam->input;
10231 vl_api_dhcp_proxy_config_t *mp;
10233 u32 server_vrf_id = 0;
10235 u8 v4_address_set = 0;
10236 u8 v6_address_set = 0;
10237 ip4_address_t v4address;
10238 ip6_address_t v6address;
10239 u8 v4_src_address_set = 0;
10240 u8 v6_src_address_set = 0;
10241 ip4_address_t v4srcaddress;
10242 ip6_address_t v6srcaddress;
10245 /* Parse args required to build the message */
10246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10248 if (unformat (i, "del"))
10250 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
10252 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
10254 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
10255 v4_address_set = 1;
10256 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
10257 v6_address_set = 1;
10258 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
10259 v4_src_address_set = 1;
10260 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
10261 v6_src_address_set = 1;
10266 if (v4_address_set && v6_address_set)
10268 errmsg ("both v4 and v6 server addresses set");
10271 if (!v4_address_set && !v6_address_set)
10273 errmsg ("no server addresses set");
10277 if (v4_src_address_set && v6_src_address_set)
10279 errmsg ("both v4 and v6 src addresses set");
10282 if (!v4_src_address_set && !v6_src_address_set)
10284 errmsg ("no src addresses set");
10288 if (!(v4_src_address_set && v4_address_set) &&
10289 !(v6_src_address_set && v6_address_set))
10291 errmsg ("no matching server and src addresses set");
10295 /* Construct the API message */
10296 M (DHCP_PROXY_CONFIG, mp);
10298 mp->is_add = is_add;
10299 mp->rx_vrf_id = ntohl (rx_vrf_id);
10300 mp->server_vrf_id = ntohl (server_vrf_id);
10301 if (v6_address_set)
10304 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
10305 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
10309 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
10310 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
10316 /* Wait for a reply, return good/bad news */
10321 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
10322 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
10325 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
10327 vat_main_t *vam = &vat_main;
10328 u32 i, count = mp->count;
10329 vl_api_dhcp_server_t *s;
10333 "RX Table-ID %d, Source Address %U, VSS Type %d, "
10334 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
10335 ntohl (mp->rx_vrf_id),
10336 format_ip6_address, mp->dhcp_src_address,
10337 mp->vss_type, mp->vss_vpn_ascii_id,
10338 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
10341 "RX Table-ID %d, Source Address %U, VSS Type %d, "
10342 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
10343 ntohl (mp->rx_vrf_id),
10344 format_ip4_address, mp->dhcp_src_address,
10345 mp->vss_type, mp->vss_vpn_ascii_id,
10346 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
10348 for (i = 0; i < count; i++)
10350 s = &mp->servers[i];
10354 " Server Table-ID %d, Server Address %U",
10355 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
10358 " Server Table-ID %d, Server Address %U",
10359 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
10363 static void vl_api_dhcp_proxy_details_t_handler_json
10364 (vl_api_dhcp_proxy_details_t * mp)
10366 vat_main_t *vam = &vat_main;
10367 vat_json_node_t *node = NULL;
10368 u32 i, count = mp->count;
10369 struct in_addr ip4;
10370 struct in6_addr ip6;
10371 vl_api_dhcp_server_t *s;
10373 if (VAT_JSON_ARRAY != vam->json_tree.type)
10375 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10376 vat_json_init_array (&vam->json_tree);
10378 node = vat_json_array_add (&vam->json_tree);
10380 vat_json_init_object (node);
10381 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
10382 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
10383 sizeof (mp->vss_type));
10384 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
10385 mp->vss_vpn_ascii_id);
10386 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
10387 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
10391 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
10392 vat_json_object_add_ip6 (node, "src_address", ip6);
10396 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
10397 vat_json_object_add_ip4 (node, "src_address", ip4);
10400 for (i = 0; i < count; i++)
10402 s = &mp->servers[i];
10404 vat_json_object_add_uint (node, "server-table-id",
10405 ntohl (s->server_vrf_id));
10409 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
10410 vat_json_object_add_ip4 (node, "src_address", ip4);
10414 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
10415 vat_json_object_add_ip6 (node, "server_address", ip6);
10421 api_dhcp_proxy_dump (vat_main_t * vam)
10423 unformat_input_t *i = vam->input;
10424 vl_api_control_ping_t *mp_ping;
10425 vl_api_dhcp_proxy_dump_t *mp;
10429 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10431 if (unformat (i, "ipv6"))
10435 clib_warning ("parse error '%U'", format_unformat_error, i);
10440 M (DHCP_PROXY_DUMP, mp);
10442 mp->is_ip6 = is_ipv6;
10445 /* Use a control ping for synchronization */
10446 MPING (CONTROL_PING, mp_ping);
10454 api_dhcp_proxy_set_vss (vat_main_t * vam)
10456 unformat_input_t *i = vam->input;
10457 vl_api_dhcp_proxy_set_vss_t *mp;
10461 u8 vss_type = VSS_TYPE_DEFAULT;
10462 u8 *vpn_ascii_id = 0;
10467 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10469 if (unformat (i, "tbl_id %d", &tbl_id))
10471 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
10472 vss_type = VSS_TYPE_ASCII;
10473 else if (unformat (i, "fib_id %d", &fib_id))
10474 vss_type = VSS_TYPE_VPN_ID;
10475 else if (unformat (i, "oui %d", &oui))
10476 vss_type = VSS_TYPE_VPN_ID;
10477 else if (unformat (i, "ipv6"))
10479 else if (unformat (i, "del"))
10487 errmsg ("missing tbl_id ");
10488 vec_free (vpn_ascii_id);
10492 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
10494 errmsg ("vpn_ascii_id cannot be longer than 128 ");
10495 vec_free (vpn_ascii_id);
10499 M (DHCP_PROXY_SET_VSS, mp);
10500 mp->tbl_id = ntohl (tbl_id);
10501 mp->vss_type = vss_type;
10504 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
10505 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
10507 mp->vpn_index = ntohl (fib_id);
10508 mp->oui = ntohl (oui);
10509 mp->is_ipv6 = is_ipv6;
10510 mp->is_add = is_add;
10515 vec_free (vpn_ascii_id);
10520 api_dhcp_client_config (vat_main_t * vam)
10522 unformat_input_t *i = vam->input;
10523 vl_api_dhcp_client_config_t *mp;
10525 u8 sw_if_index_set = 0;
10528 u8 disable_event = 0;
10531 /* Parse args required to build the message */
10532 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10534 if (unformat (i, "del"))
10537 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10538 sw_if_index_set = 1;
10539 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10540 sw_if_index_set = 1;
10541 else if (unformat (i, "hostname %s", &hostname))
10543 else if (unformat (i, "disable_event"))
10549 if (sw_if_index_set == 0)
10551 errmsg ("missing interface name or sw_if_index");
10555 if (vec_len (hostname) > 63)
10557 errmsg ("hostname too long");
10559 vec_add1 (hostname, 0);
10561 /* Construct the API message */
10562 M (DHCP_CLIENT_CONFIG, mp);
10564 mp->is_add = is_add;
10565 mp->client.sw_if_index = htonl (sw_if_index);
10566 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
10567 vec_free (hostname);
10568 mp->client.want_dhcp_event = disable_event ? 0 : 1;
10569 mp->client.pid = htonl (getpid ());
10574 /* Wait for a reply, return good/bad news */
10580 api_set_ip_flow_hash (vat_main_t * vam)
10582 unformat_input_t *i = vam->input;
10583 vl_api_set_ip_flow_hash_t *mp;
10595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10597 if (unformat (i, "vrf %d", &vrf_id))
10599 else if (unformat (i, "ipv6"))
10601 else if (unformat (i, "src"))
10603 else if (unformat (i, "dst"))
10605 else if (unformat (i, "sport"))
10607 else if (unformat (i, "dport"))
10609 else if (unformat (i, "proto"))
10611 else if (unformat (i, "reverse"))
10616 clib_warning ("parse error '%U'", format_unformat_error, i);
10621 if (vrf_id_set == 0)
10623 errmsg ("missing vrf id");
10627 M (SET_IP_FLOW_HASH, mp);
10633 mp->reverse = reverse;
10634 mp->vrf_id = ntohl (vrf_id);
10635 mp->is_ipv6 = is_ipv6;
10643 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
10645 unformat_input_t *i = vam->input;
10646 vl_api_sw_interface_ip6_enable_disable_t *mp;
10648 u8 sw_if_index_set = 0;
10652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10654 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10655 sw_if_index_set = 1;
10656 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10657 sw_if_index_set = 1;
10658 else if (unformat (i, "enable"))
10660 else if (unformat (i, "disable"))
10664 clib_warning ("parse error '%U'", format_unformat_error, i);
10669 if (sw_if_index_set == 0)
10671 errmsg ("missing interface name or sw_if_index");
10675 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10677 mp->sw_if_index = ntohl (sw_if_index);
10678 mp->enable = enable;
10686 api_ip6nd_proxy_add_del (vat_main_t * vam)
10688 unformat_input_t *i = vam->input;
10689 vl_api_ip6nd_proxy_add_del_t *mp;
10690 u32 sw_if_index = ~0;
10691 u8 v6_address_set = 0;
10692 ip6_address_t v6address;
10696 /* Parse args required to build the message */
10697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10699 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10701 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10703 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
10704 v6_address_set = 1;
10705 if (unformat (i, "del"))
10709 clib_warning ("parse error '%U'", format_unformat_error, i);
10714 if (sw_if_index == ~0)
10716 errmsg ("missing interface name or sw_if_index");
10719 if (!v6_address_set)
10721 errmsg ("no address set");
10725 /* Construct the API message */
10726 M (IP6ND_PROXY_ADD_DEL, mp);
10728 mp->is_del = is_del;
10729 mp->sw_if_index = ntohl (sw_if_index);
10730 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10735 /* Wait for a reply, return good/bad news */
10741 api_ip6nd_proxy_dump (vat_main_t * vam)
10743 vl_api_ip6nd_proxy_dump_t *mp;
10744 vl_api_control_ping_t *mp_ping;
10747 M (IP6ND_PROXY_DUMP, mp);
10751 /* Use a control ping for synchronization */
10752 MPING (CONTROL_PING, mp_ping);
10759 static void vl_api_ip6nd_proxy_details_t_handler
10760 (vl_api_ip6nd_proxy_details_t * mp)
10762 vat_main_t *vam = &vat_main;
10764 print (vam->ofp, "host %U sw_if_index %d",
10765 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10768 static void vl_api_ip6nd_proxy_details_t_handler_json
10769 (vl_api_ip6nd_proxy_details_t * mp)
10771 vat_main_t *vam = &vat_main;
10772 struct in6_addr ip6;
10773 vat_json_node_t *node = NULL;
10775 if (VAT_JSON_ARRAY != vam->json_tree.type)
10777 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10778 vat_json_init_array (&vam->json_tree);
10780 node = vat_json_array_add (&vam->json_tree);
10782 vat_json_init_object (node);
10783 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10785 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10786 vat_json_object_add_ip6 (node, "host", ip6);
10790 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10792 unformat_input_t *i = vam->input;
10793 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10795 u8 sw_if_index_set = 0;
10796 u32 address_length = 0;
10797 u8 v6_address_set = 0;
10798 ip6_address_t v6address;
10799 u8 use_default = 0;
10800 u8 no_advertise = 0;
10802 u8 no_autoconfig = 0;
10805 u32 val_lifetime = 0;
10806 u32 pref_lifetime = 0;
10809 /* Parse args required to build the message */
10810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10812 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10813 sw_if_index_set = 1;
10814 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10815 sw_if_index_set = 1;
10816 else if (unformat (i, "%U/%d",
10817 unformat_ip6_address, &v6address, &address_length))
10818 v6_address_set = 1;
10819 else if (unformat (i, "val_life %d", &val_lifetime))
10821 else if (unformat (i, "pref_life %d", &pref_lifetime))
10823 else if (unformat (i, "def"))
10825 else if (unformat (i, "noadv"))
10827 else if (unformat (i, "offl"))
10829 else if (unformat (i, "noauto"))
10831 else if (unformat (i, "nolink"))
10833 else if (unformat (i, "isno"))
10837 clib_warning ("parse error '%U'", format_unformat_error, i);
10842 if (sw_if_index_set == 0)
10844 errmsg ("missing interface name or sw_if_index");
10847 if (!v6_address_set)
10849 errmsg ("no address set");
10853 /* Construct the API message */
10854 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10856 mp->sw_if_index = ntohl (sw_if_index);
10857 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10858 mp->address_length = address_length;
10859 mp->use_default = use_default;
10860 mp->no_advertise = no_advertise;
10861 mp->off_link = off_link;
10862 mp->no_autoconfig = no_autoconfig;
10863 mp->no_onlink = no_onlink;
10865 mp->val_lifetime = ntohl (val_lifetime);
10866 mp->pref_lifetime = ntohl (pref_lifetime);
10871 /* Wait for a reply, return good/bad news */
10877 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10879 unformat_input_t *i = vam->input;
10880 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10882 u8 sw_if_index_set = 0;
10887 u8 send_unicast = 0;
10890 u8 default_router = 0;
10891 u32 max_interval = 0;
10892 u32 min_interval = 0;
10894 u32 initial_count = 0;
10895 u32 initial_interval = 0;
10899 /* Parse args required to build the message */
10900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10902 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10903 sw_if_index_set = 1;
10904 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10905 sw_if_index_set = 1;
10906 else if (unformat (i, "maxint %d", &max_interval))
10908 else if (unformat (i, "minint %d", &min_interval))
10910 else if (unformat (i, "life %d", &lifetime))
10912 else if (unformat (i, "count %d", &initial_count))
10914 else if (unformat (i, "interval %d", &initial_interval))
10916 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10918 else if (unformat (i, "managed"))
10920 else if (unformat (i, "other"))
10922 else if (unformat (i, "ll"))
10924 else if (unformat (i, "send"))
10926 else if (unformat (i, "cease"))
10928 else if (unformat (i, "isno"))
10930 else if (unformat (i, "def"))
10931 default_router = 1;
10934 clib_warning ("parse error '%U'", format_unformat_error, i);
10939 if (sw_if_index_set == 0)
10941 errmsg ("missing interface name or sw_if_index");
10945 /* Construct the API message */
10946 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10948 mp->sw_if_index = ntohl (sw_if_index);
10949 mp->max_interval = ntohl (max_interval);
10950 mp->min_interval = ntohl (min_interval);
10951 mp->lifetime = ntohl (lifetime);
10952 mp->initial_count = ntohl (initial_count);
10953 mp->initial_interval = ntohl (initial_interval);
10954 mp->suppress = suppress;
10955 mp->managed = managed;
10957 mp->ll_option = ll_option;
10958 mp->send_unicast = send_unicast;
10961 mp->default_router = default_router;
10966 /* Wait for a reply, return good/bad news */
10972 api_set_arp_neighbor_limit (vat_main_t * vam)
10974 unformat_input_t *i = vam->input;
10975 vl_api_set_arp_neighbor_limit_t *mp;
10981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10983 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10985 else if (unformat (i, "ipv6"))
10989 clib_warning ("parse error '%U'", format_unformat_error, i);
10994 if (limit_set == 0)
10996 errmsg ("missing limit value");
11000 M (SET_ARP_NEIGHBOR_LIMIT, mp);
11002 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
11003 mp->is_ipv6 = is_ipv6;
11011 api_l2_patch_add_del (vat_main_t * vam)
11013 unformat_input_t *i = vam->input;
11014 vl_api_l2_patch_add_del_t *mp;
11015 u32 rx_sw_if_index;
11016 u8 rx_sw_if_index_set = 0;
11017 u32 tx_sw_if_index;
11018 u8 tx_sw_if_index_set = 0;
11022 /* Parse args required to build the message */
11023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11025 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
11026 rx_sw_if_index_set = 1;
11027 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
11028 tx_sw_if_index_set = 1;
11029 else if (unformat (i, "rx"))
11031 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11033 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
11035 rx_sw_if_index_set = 1;
11040 else if (unformat (i, "tx"))
11042 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11044 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
11046 tx_sw_if_index_set = 1;
11051 else if (unformat (i, "del"))
11057 if (rx_sw_if_index_set == 0)
11059 errmsg ("missing rx interface name or rx_sw_if_index");
11063 if (tx_sw_if_index_set == 0)
11065 errmsg ("missing tx interface name or tx_sw_if_index");
11069 M (L2_PATCH_ADD_DEL, mp);
11071 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
11072 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
11073 mp->is_add = is_add;
11081 u8 localsid_addr[16];
11090 api_sr_localsid_add_del (vat_main_t * vam)
11092 unformat_input_t *i = vam->input;
11093 vl_api_sr_localsid_add_del_t *mp;
11096 ip6_address_t localsid;
11100 u32 fib_table = ~(u32) 0;
11101 ip6_address_t nh_addr6;
11102 ip4_address_t nh_addr4;
11103 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
11104 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
11106 bool nexthop_set = 0;
11110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11112 if (unformat (i, "del"))
11114 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
11115 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
11117 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
11119 else if (unformat (i, "behavior %u", &behavior));
11120 else if (unformat (i, "sw_if_index %u", &sw_if_index));
11121 else if (unformat (i, "fib-table %u", &fib_table));
11122 else if (unformat (i, "end.psp %u", &behavior));
11127 M (SR_LOCALSID_ADD_DEL, mp);
11129 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
11132 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
11133 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
11135 mp->behavior = behavior;
11136 mp->sw_if_index = ntohl (sw_if_index);
11137 mp->fib_table = ntohl (fib_table);
11138 mp->end_psp = end_psp;
11139 mp->is_del = is_del;
11147 api_ioam_enable (vat_main_t * vam)
11149 unformat_input_t *input = vam->input;
11150 vl_api_ioam_enable_t *mp;
11152 int has_trace_option = 0;
11153 int has_pot_option = 0;
11154 int has_seqno_option = 0;
11155 int has_analyse_option = 0;
11158 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11160 if (unformat (input, "trace"))
11161 has_trace_option = 1;
11162 else if (unformat (input, "pot"))
11163 has_pot_option = 1;
11164 else if (unformat (input, "seqno"))
11165 has_seqno_option = 1;
11166 else if (unformat (input, "analyse"))
11167 has_analyse_option = 1;
11171 M (IOAM_ENABLE, mp);
11172 mp->id = htons (id);
11173 mp->seqno = has_seqno_option;
11174 mp->analyse = has_analyse_option;
11175 mp->pot_enable = has_pot_option;
11176 mp->trace_enable = has_trace_option;
11185 api_ioam_disable (vat_main_t * vam)
11187 vl_api_ioam_disable_t *mp;
11190 M (IOAM_DISABLE, mp);
11196 #define foreach_tcp_proto_field \
11200 #define foreach_udp_proto_field \
11204 #define foreach_ip4_proto_field \
11216 u16 src_port, dst_port;
11219 #if VPP_API_TEST_BUILTIN == 0
11221 unformat_tcp_mask (unformat_input_t * input, va_list * args)
11223 u8 **maskp = va_arg (*args, u8 **);
11225 u8 found_something = 0;
11228 #define _(a) u8 a=0;
11229 foreach_tcp_proto_field;
11232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11235 #define _(a) else if (unformat (input, #a)) a=1;
11236 foreach_tcp_proto_field
11242 #define _(a) found_something += a;
11243 foreach_tcp_proto_field;
11246 if (found_something == 0)
11249 vec_validate (mask, sizeof (*tcp) - 1);
11251 tcp = (tcp_header_t *) mask;
11253 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
11254 foreach_tcp_proto_field;
11262 unformat_udp_mask (unformat_input_t * input, va_list * args)
11264 u8 **maskp = va_arg (*args, u8 **);
11266 u8 found_something = 0;
11269 #define _(a) u8 a=0;
11270 foreach_udp_proto_field;
11273 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11276 #define _(a) else if (unformat (input, #a)) a=1;
11277 foreach_udp_proto_field
11283 #define _(a) found_something += a;
11284 foreach_udp_proto_field;
11287 if (found_something == 0)
11290 vec_validate (mask, sizeof (*udp) - 1);
11292 udp = (udp_header_t *) mask;
11294 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
11295 foreach_udp_proto_field;
11303 unformat_l4_mask (unformat_input_t * input, va_list * args)
11305 u8 **maskp = va_arg (*args, u8 **);
11306 u16 src_port = 0, dst_port = 0;
11307 tcpudp_header_t *tcpudp;
11309 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11311 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
11313 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
11315 else if (unformat (input, "src_port"))
11317 else if (unformat (input, "dst_port"))
11323 if (!src_port && !dst_port)
11327 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
11329 tcpudp = (tcpudp_header_t *) mask;
11330 tcpudp->src_port = src_port;
11331 tcpudp->dst_port = dst_port;
11339 unformat_ip4_mask (unformat_input_t * input, va_list * args)
11341 u8 **maskp = va_arg (*args, u8 **);
11343 u8 found_something = 0;
11346 #define _(a) u8 a=0;
11347 foreach_ip4_proto_field;
11353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11355 if (unformat (input, "version"))
11357 else if (unformat (input, "hdr_length"))
11359 else if (unformat (input, "src"))
11361 else if (unformat (input, "dst"))
11363 else if (unformat (input, "proto"))
11366 #define _(a) else if (unformat (input, #a)) a=1;
11367 foreach_ip4_proto_field
11373 #define _(a) found_something += a;
11374 foreach_ip4_proto_field;
11377 if (found_something == 0)
11380 vec_validate (mask, sizeof (*ip) - 1);
11382 ip = (ip4_header_t *) mask;
11384 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
11385 foreach_ip4_proto_field;
11388 ip->ip_version_and_header_length = 0;
11391 ip->ip_version_and_header_length |= 0xF0;
11394 ip->ip_version_and_header_length |= 0x0F;
11400 #define foreach_ip6_proto_field \
11403 _(payload_length) \
11408 unformat_ip6_mask (unformat_input_t * input, va_list * args)
11410 u8 **maskp = va_arg (*args, u8 **);
11412 u8 found_something = 0;
11414 u32 ip_version_traffic_class_and_flow_label;
11416 #define _(a) u8 a=0;
11417 foreach_ip6_proto_field;
11420 u8 traffic_class = 0;
11423 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11425 if (unformat (input, "version"))
11427 else if (unformat (input, "traffic-class"))
11429 else if (unformat (input, "flow-label"))
11431 else if (unformat (input, "src"))
11433 else if (unformat (input, "dst"))
11435 else if (unformat (input, "proto"))
11438 #define _(a) else if (unformat (input, #a)) a=1;
11439 foreach_ip6_proto_field
11445 #define _(a) found_something += a;
11446 foreach_ip6_proto_field;
11449 if (found_something == 0)
11452 vec_validate (mask, sizeof (*ip) - 1);
11454 ip = (ip6_header_t *) mask;
11456 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
11457 foreach_ip6_proto_field;
11460 ip_version_traffic_class_and_flow_label = 0;
11463 ip_version_traffic_class_and_flow_label |= 0xF0000000;
11466 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
11469 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
11471 ip->ip_version_traffic_class_and_flow_label =
11472 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11479 unformat_l3_mask (unformat_input_t * input, va_list * args)
11481 u8 **maskp = va_arg (*args, u8 **);
11483 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11485 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
11487 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
11496 unformat_l2_mask (unformat_input_t * input, va_list * args)
11498 u8 **maskp = va_arg (*args, u8 **);
11505 u8 ignore_tag1 = 0;
11506 u8 ignore_tag2 = 0;
11513 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11515 if (unformat (input, "src"))
11517 else if (unformat (input, "dst"))
11519 else if (unformat (input, "proto"))
11521 else if (unformat (input, "tag1"))
11523 else if (unformat (input, "tag2"))
11525 else if (unformat (input, "ignore-tag1"))
11527 else if (unformat (input, "ignore-tag2"))
11529 else if (unformat (input, "cos1"))
11531 else if (unformat (input, "cos2"))
11533 else if (unformat (input, "dot1q"))
11535 else if (unformat (input, "dot1ad"))
11540 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
11541 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11544 if (tag1 || ignore_tag1 || cos1 || dot1q)
11546 if (tag2 || ignore_tag2 || cos2 || dot1ad)
11549 vec_validate (mask, len - 1);
11552 clib_memset (mask, 0xff, 6);
11555 clib_memset (mask + 6, 0xff, 6);
11557 if (tag2 || dot1ad)
11559 /* inner vlan tag */
11568 mask[21] = mask[20] = 0xff;
11589 mask[16] = mask[17] = 0xff;
11599 mask[12] = mask[13] = 0xff;
11606 unformat_classify_mask (unformat_input_t * input, va_list * args)
11608 u8 **maskp = va_arg (*args, u8 **);
11609 u32 *skipp = va_arg (*args, u32 *);
11610 u32 *matchp = va_arg (*args, u32 *);
11618 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11620 if (unformat (input, "hex %U", unformat_hex_string, &mask))
11622 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
11624 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
11626 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
11640 if (mask || l2 || l3 || l4)
11642 if (l2 || l3 || l4)
11644 /* "With a free Ethernet header in every package" */
11646 vec_validate (l2, 13);
11650 vec_append (mask, l3);
11655 vec_append (mask, l4);
11660 /* Scan forward looking for the first significant mask octet */
11661 for (i = 0; i < vec_len (mask); i++)
11665 /* compute (skip, match) params */
11666 *skipp = i / sizeof (u32x4);
11667 vec_delete (mask, *skipp * sizeof (u32x4), 0);
11669 /* Pad mask to an even multiple of the vector size */
11670 while (vec_len (mask) % sizeof (u32x4))
11671 vec_add1 (mask, 0);
11673 match = vec_len (mask) / sizeof (u32x4);
11675 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11677 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11678 if (*tmp || *(tmp + 1))
11683 clib_warning ("BUG: match 0");
11685 _vec_len (mask) = match * sizeof (u32x4);
11695 #endif /* VPP_API_TEST_BUILTIN */
11697 #define foreach_l2_next \
11699 _(ethernet, ETHERNET_INPUT) \
11700 _(ip4, IP4_INPUT) \
11704 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11706 u32 *miss_next_indexp = va_arg (*args, u32 *);
11707 u32 next_index = 0;
11711 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11715 if (unformat (input, "%d", &tmp))
11724 *miss_next_indexp = next_index;
11728 #define foreach_ip_next \
11731 _(rewrite, REWRITE)
11734 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11736 u32 *miss_next_indexp = va_arg (*args, u32 *);
11737 u32 next_index = 0;
11741 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11745 if (unformat (input, "%d", &tmp))
11754 *miss_next_indexp = next_index;
11758 #define foreach_acl_next \
11762 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11764 u32 *miss_next_indexp = va_arg (*args, u32 *);
11765 u32 next_index = 0;
11769 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11773 if (unformat (input, "permit"))
11778 else if (unformat (input, "%d", &tmp))
11787 *miss_next_indexp = next_index;
11792 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11794 u32 *r = va_arg (*args, u32 *);
11796 if (unformat (input, "conform-color"))
11797 *r = POLICE_CONFORM;
11798 else if (unformat (input, "exceed-color"))
11799 *r = POLICE_EXCEED;
11807 api_classify_add_del_table (vat_main_t * vam)
11809 unformat_input_t *i = vam->input;
11810 vl_api_classify_add_del_table_t *mp;
11817 u32 table_index = ~0;
11818 u32 next_table_index = ~0;
11819 u32 miss_next_index = ~0;
11820 u32 memory_size = 32 << 20;
11822 u32 current_data_flag = 0;
11823 int current_data_offset = 0;
11826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11828 if (unformat (i, "del"))
11830 else if (unformat (i, "del-chain"))
11835 else if (unformat (i, "buckets %d", &nbuckets))
11837 else if (unformat (i, "memory_size %d", &memory_size))
11839 else if (unformat (i, "skip %d", &skip))
11841 else if (unformat (i, "match %d", &match))
11843 else if (unformat (i, "table %d", &table_index))
11845 else if (unformat (i, "mask %U", unformat_classify_mask,
11846 &mask, &skip, &match))
11848 else if (unformat (i, "next-table %d", &next_table_index))
11850 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11853 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11856 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11859 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11861 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11867 if (is_add && mask == 0)
11869 errmsg ("Mask required");
11873 if (is_add && skip == ~0)
11875 errmsg ("skip count required");
11879 if (is_add && match == ~0)
11881 errmsg ("match count required");
11885 if (!is_add && table_index == ~0)
11887 errmsg ("table index required for delete");
11891 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11893 mp->is_add = is_add;
11894 mp->del_chain = del_chain;
11895 mp->table_index = ntohl (table_index);
11896 mp->nbuckets = ntohl (nbuckets);
11897 mp->memory_size = ntohl (memory_size);
11898 mp->skip_n_vectors = ntohl (skip);
11899 mp->match_n_vectors = ntohl (match);
11900 mp->next_table_index = ntohl (next_table_index);
11901 mp->miss_next_index = ntohl (miss_next_index);
11902 mp->current_data_flag = ntohl (current_data_flag);
11903 mp->current_data_offset = ntohl (current_data_offset);
11904 mp->mask_len = ntohl (vec_len (mask));
11905 clib_memcpy (mp->mask, mask, vec_len (mask));
11914 #if VPP_API_TEST_BUILTIN == 0
11916 unformat_l4_match (unformat_input_t * input, va_list * args)
11918 u8 **matchp = va_arg (*args, u8 **);
11920 u8 *proto_header = 0;
11926 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11928 if (unformat (input, "src_port %d", &src_port))
11930 else if (unformat (input, "dst_port %d", &dst_port))
11936 h.src_port = clib_host_to_net_u16 (src_port);
11937 h.dst_port = clib_host_to_net_u16 (dst_port);
11938 vec_validate (proto_header, sizeof (h) - 1);
11939 memcpy (proto_header, &h, sizeof (h));
11941 *matchp = proto_header;
11947 unformat_ip4_match (unformat_input_t * input, va_list * args)
11949 u8 **matchp = va_arg (*args, u8 **);
11954 int hdr_length = 0;
11955 u32 hdr_length_val;
11956 int src = 0, dst = 0;
11957 ip4_address_t src_val, dst_val;
11964 int fragment_id = 0;
11965 u32 fragment_id_val;
11971 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11973 if (unformat (input, "version %d", &version_val))
11975 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11977 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11979 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11981 else if (unformat (input, "proto %d", &proto_val))
11983 else if (unformat (input, "tos %d", &tos_val))
11985 else if (unformat (input, "length %d", &length_val))
11987 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11989 else if (unformat (input, "ttl %d", &ttl_val))
11991 else if (unformat (input, "checksum %d", &checksum_val))
11997 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11998 + ttl + checksum == 0)
12002 * Aligned because we use the real comparison functions
12004 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
12006 ip = (ip4_header_t *) match;
12008 /* These are realistically matched in practice */
12010 ip->src_address.as_u32 = src_val.as_u32;
12013 ip->dst_address.as_u32 = dst_val.as_u32;
12016 ip->protocol = proto_val;
12019 /* These are not, but they're included for completeness */
12021 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
12024 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
12030 ip->length = clib_host_to_net_u16 (length_val);
12036 ip->checksum = clib_host_to_net_u16 (checksum_val);
12043 unformat_ip6_match (unformat_input_t * input, va_list * args)
12045 u8 **matchp = va_arg (*args, u8 **);
12050 u8 traffic_class = 0;
12051 u32 traffic_class_val = 0;
12054 int src = 0, dst = 0;
12055 ip6_address_t src_val, dst_val;
12058 int payload_length = 0;
12059 u32 payload_length_val;
12062 u32 ip_version_traffic_class_and_flow_label;
12064 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12066 if (unformat (input, "version %d", &version_val))
12068 else if (unformat (input, "traffic_class %d", &traffic_class_val))
12070 else if (unformat (input, "flow_label %d", &flow_label_val))
12072 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
12074 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
12076 else if (unformat (input, "proto %d", &proto_val))
12078 else if (unformat (input, "payload_length %d", &payload_length_val))
12079 payload_length = 1;
12080 else if (unformat (input, "hop_limit %d", &hop_limit_val))
12086 if (version + traffic_class + flow_label + src + dst + proto +
12087 payload_length + hop_limit == 0)
12091 * Aligned because we use the real comparison functions
12093 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
12095 ip = (ip6_header_t *) match;
12098 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
12101 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
12104 ip->protocol = proto_val;
12106 ip_version_traffic_class_and_flow_label = 0;
12109 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
12112 ip_version_traffic_class_and_flow_label |=
12113 (traffic_class_val & 0xFF) << 20;
12116 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
12118 ip->ip_version_traffic_class_and_flow_label =
12119 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
12121 if (payload_length)
12122 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
12125 ip->hop_limit = hop_limit_val;
12132 unformat_l3_match (unformat_input_t * input, va_list * args)
12134 u8 **matchp = va_arg (*args, u8 **);
12136 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12138 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
12140 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
12149 unformat_vlan_tag (unformat_input_t * input, va_list * args)
12151 u8 *tagp = va_arg (*args, u8 *);
12154 if (unformat (input, "%d", &tag))
12156 tagp[0] = (tag >> 8) & 0x0F;
12157 tagp[1] = tag & 0xFF;
12165 unformat_l2_match (unformat_input_t * input, va_list * args)
12167 u8 **matchp = va_arg (*args, u8 **);
12180 u8 ignore_tag1 = 0;
12181 u8 ignore_tag2 = 0;
12187 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12189 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
12192 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
12194 else if (unformat (input, "proto %U",
12195 unformat_ethernet_type_host_byte_order, &proto_val))
12197 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
12199 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
12201 else if (unformat (input, "ignore-tag1"))
12203 else if (unformat (input, "ignore-tag2"))
12205 else if (unformat (input, "cos1 %d", &cos1_val))
12207 else if (unformat (input, "cos2 %d", &cos2_val))
12212 if ((src + dst + proto + tag1 + tag2 +
12213 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
12216 if (tag1 || ignore_tag1 || cos1)
12218 if (tag2 || ignore_tag2 || cos2)
12221 vec_validate_aligned (match, len - 1, sizeof (u32x4));
12224 clib_memcpy (match, dst_val, 6);
12227 clib_memcpy (match + 6, src_val, 6);
12231 /* inner vlan tag */
12232 match[19] = tag2_val[1];
12233 match[18] = tag2_val[0];
12235 match[18] |= (cos2_val & 0x7) << 5;
12238 match[21] = proto_val & 0xff;
12239 match[20] = proto_val >> 8;
12243 match[15] = tag1_val[1];
12244 match[14] = tag1_val[0];
12247 match[14] |= (cos1_val & 0x7) << 5;
12253 match[15] = tag1_val[1];
12254 match[14] = tag1_val[0];
12257 match[17] = proto_val & 0xff;
12258 match[16] = proto_val >> 8;
12261 match[14] |= (cos1_val & 0x7) << 5;
12267 match[18] |= (cos2_val & 0x7) << 5;
12269 match[14] |= (cos1_val & 0x7) << 5;
12272 match[13] = proto_val & 0xff;
12273 match[12] = proto_val >> 8;
12281 unformat_qos_source (unformat_input_t * input, va_list * args)
12283 int *qs = va_arg (*args, int *);
12285 if (unformat (input, "ip"))
12286 *qs = QOS_SOURCE_IP;
12287 else if (unformat (input, "mpls"))
12288 *qs = QOS_SOURCE_MPLS;
12289 else if (unformat (input, "ext"))
12290 *qs = QOS_SOURCE_EXT;
12291 else if (unformat (input, "vlan"))
12292 *qs = QOS_SOURCE_VLAN;
12301 api_unformat_classify_match (unformat_input_t * input, va_list * args)
12303 u8 **matchp = va_arg (*args, u8 **);
12304 u32 skip_n_vectors = va_arg (*args, u32);
12305 u32 match_n_vectors = va_arg (*args, u32);
12312 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12314 if (unformat (input, "hex %U", unformat_hex_string, &match))
12316 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
12318 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
12320 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
12334 if (match || l2 || l3 || l4)
12336 if (l2 || l3 || l4)
12338 /* "Win a free Ethernet header in every packet" */
12340 vec_validate_aligned (l2, 13, sizeof (u32x4));
12344 vec_append_aligned (match, l3, sizeof (u32x4));
12349 vec_append_aligned (match, l4, sizeof (u32x4));
12354 /* Make sure the vector is big enough even if key is all 0's */
12355 vec_validate_aligned
12356 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
12359 /* Set size, include skipped vectors */
12360 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
12371 api_classify_add_del_session (vat_main_t * vam)
12373 unformat_input_t *i = vam->input;
12374 vl_api_classify_add_del_session_t *mp;
12376 u32 table_index = ~0;
12377 u32 hit_next_index = ~0;
12378 u32 opaque_index = ~0;
12381 u32 skip_n_vectors = 0;
12382 u32 match_n_vectors = 0;
12388 * Warning: you have to supply skip_n and match_n
12389 * because the API client cant simply look at the classify
12393 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12395 if (unformat (i, "del"))
12397 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
12400 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
12403 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
12406 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
12408 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
12410 else if (unformat (i, "opaque-index %d", &opaque_index))
12412 else if (unformat (i, "skip_n %d", &skip_n_vectors))
12414 else if (unformat (i, "match_n %d", &match_n_vectors))
12416 else if (unformat (i, "match %U", api_unformat_classify_match,
12417 &match, skip_n_vectors, match_n_vectors))
12419 else if (unformat (i, "advance %d", &advance))
12421 else if (unformat (i, "table-index %d", &table_index))
12423 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
12425 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
12427 else if (unformat (i, "action %d", &action))
12429 else if (unformat (i, "metadata %d", &metadata))
12435 if (table_index == ~0)
12437 errmsg ("Table index required");
12441 if (is_add && match == 0)
12443 errmsg ("Match value required");
12447 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
12449 mp->is_add = is_add;
12450 mp->table_index = ntohl (table_index);
12451 mp->hit_next_index = ntohl (hit_next_index);
12452 mp->opaque_index = ntohl (opaque_index);
12453 mp->advance = ntohl (advance);
12454 mp->action = action;
12455 mp->metadata = ntohl (metadata);
12456 mp->match_len = ntohl (vec_len (match));
12457 clib_memcpy (mp->match, match, vec_len (match));
12466 api_classify_set_interface_ip_table (vat_main_t * vam)
12468 unformat_input_t *i = vam->input;
12469 vl_api_classify_set_interface_ip_table_t *mp;
12471 int sw_if_index_set;
12472 u32 table_index = ~0;
12476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12478 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12479 sw_if_index_set = 1;
12480 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12481 sw_if_index_set = 1;
12482 else if (unformat (i, "table %d", &table_index))
12486 clib_warning ("parse error '%U'", format_unformat_error, i);
12491 if (sw_if_index_set == 0)
12493 errmsg ("missing interface name or sw_if_index");
12498 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
12500 mp->sw_if_index = ntohl (sw_if_index);
12501 mp->table_index = ntohl (table_index);
12502 mp->is_ipv6 = is_ipv6;
12510 api_classify_set_interface_l2_tables (vat_main_t * vam)
12512 unformat_input_t *i = vam->input;
12513 vl_api_classify_set_interface_l2_tables_t *mp;
12515 int sw_if_index_set;
12516 u32 ip4_table_index = ~0;
12517 u32 ip6_table_index = ~0;
12518 u32 other_table_index = ~0;
12522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12524 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12525 sw_if_index_set = 1;
12526 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12527 sw_if_index_set = 1;
12528 else if (unformat (i, "ip4-table %d", &ip4_table_index))
12530 else if (unformat (i, "ip6-table %d", &ip6_table_index))
12532 else if (unformat (i, "other-table %d", &other_table_index))
12534 else if (unformat (i, "is-input %d", &is_input))
12538 clib_warning ("parse error '%U'", format_unformat_error, i);
12543 if (sw_if_index_set == 0)
12545 errmsg ("missing interface name or sw_if_index");
12550 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
12552 mp->sw_if_index = ntohl (sw_if_index);
12553 mp->ip4_table_index = ntohl (ip4_table_index);
12554 mp->ip6_table_index = ntohl (ip6_table_index);
12555 mp->other_table_index = ntohl (other_table_index);
12556 mp->is_input = (u8) is_input;
12564 api_set_ipfix_exporter (vat_main_t * vam)
12566 unformat_input_t *i = vam->input;
12567 vl_api_set_ipfix_exporter_t *mp;
12568 ip4_address_t collector_address;
12569 u8 collector_address_set = 0;
12570 u32 collector_port = ~0;
12571 ip4_address_t src_address;
12572 u8 src_address_set = 0;
12575 u32 template_interval = ~0;
12576 u8 udp_checksum = 0;
12579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12581 if (unformat (i, "collector_address %U", unformat_ip4_address,
12582 &collector_address))
12583 collector_address_set = 1;
12584 else if (unformat (i, "collector_port %d", &collector_port))
12586 else if (unformat (i, "src_address %U", unformat_ip4_address,
12588 src_address_set = 1;
12589 else if (unformat (i, "vrf_id %d", &vrf_id))
12591 else if (unformat (i, "path_mtu %d", &path_mtu))
12593 else if (unformat (i, "template_interval %d", &template_interval))
12595 else if (unformat (i, "udp_checksum"))
12601 if (collector_address_set == 0)
12603 errmsg ("collector_address required");
12607 if (src_address_set == 0)
12609 errmsg ("src_address required");
12613 M (SET_IPFIX_EXPORTER, mp);
12615 memcpy (mp->collector_address, collector_address.data,
12616 sizeof (collector_address.data));
12617 mp->collector_port = htons ((u16) collector_port);
12618 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
12619 mp->vrf_id = htonl (vrf_id);
12620 mp->path_mtu = htonl (path_mtu);
12621 mp->template_interval = htonl (template_interval);
12622 mp->udp_checksum = udp_checksum;
12630 api_set_ipfix_classify_stream (vat_main_t * vam)
12632 unformat_input_t *i = vam->input;
12633 vl_api_set_ipfix_classify_stream_t *mp;
12635 u32 src_port = UDP_DST_PORT_ipfix;
12638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12640 if (unformat (i, "domain %d", &domain_id))
12642 else if (unformat (i, "src_port %d", &src_port))
12646 errmsg ("unknown input `%U'", format_unformat_error, i);
12651 M (SET_IPFIX_CLASSIFY_STREAM, mp);
12653 mp->domain_id = htonl (domain_id);
12654 mp->src_port = htons ((u16) src_port);
12662 api_ipfix_classify_table_add_del (vat_main_t * vam)
12664 unformat_input_t *i = vam->input;
12665 vl_api_ipfix_classify_table_add_del_t *mp;
12667 u32 classify_table_index = ~0;
12669 u8 transport_protocol = 255;
12672 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12674 if (unformat (i, "add"))
12676 else if (unformat (i, "del"))
12678 else if (unformat (i, "table %d", &classify_table_index))
12680 else if (unformat (i, "ip4"))
12682 else if (unformat (i, "ip6"))
12684 else if (unformat (i, "tcp"))
12685 transport_protocol = 6;
12686 else if (unformat (i, "udp"))
12687 transport_protocol = 17;
12690 errmsg ("unknown input `%U'", format_unformat_error, i);
12697 errmsg ("expecting: add|del");
12700 if (classify_table_index == ~0)
12702 errmsg ("classifier table not specified");
12705 if (ip_version == 0)
12707 errmsg ("IP version not specified");
12711 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12713 mp->is_add = is_add;
12714 mp->table_id = htonl (classify_table_index);
12715 mp->ip_version = ip_version;
12716 mp->transport_protocol = transport_protocol;
12724 api_get_node_index (vat_main_t * vam)
12726 unformat_input_t *i = vam->input;
12727 vl_api_get_node_index_t *mp;
12731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12733 if (unformat (i, "node %s", &name))
12740 errmsg ("node name required");
12743 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12745 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12749 M (GET_NODE_INDEX, mp);
12750 clib_memcpy (mp->node_name, name, vec_len (name));
12759 api_get_next_index (vat_main_t * vam)
12761 unformat_input_t *i = vam->input;
12762 vl_api_get_next_index_t *mp;
12763 u8 *node_name = 0, *next_node_name = 0;
12766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12768 if (unformat (i, "node-name %s", &node_name))
12770 else if (unformat (i, "next-node-name %s", &next_node_name))
12774 if (node_name == 0)
12776 errmsg ("node name required");
12779 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12781 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12785 if (next_node_name == 0)
12787 errmsg ("next node name required");
12790 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12792 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12796 M (GET_NEXT_INDEX, mp);
12797 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12798 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12799 vec_free (node_name);
12800 vec_free (next_node_name);
12808 api_add_node_next (vat_main_t * vam)
12810 unformat_input_t *i = vam->input;
12811 vl_api_add_node_next_t *mp;
12816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12818 if (unformat (i, "node %s", &name))
12820 else if (unformat (i, "next %s", &next))
12827 errmsg ("node name required");
12830 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12832 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12837 errmsg ("next node required");
12840 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12842 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12846 M (ADD_NODE_NEXT, mp);
12847 clib_memcpy (mp->node_name, name, vec_len (name));
12848 clib_memcpy (mp->next_name, next, vec_len (next));
12858 api_l2tpv3_create_tunnel (vat_main_t * vam)
12860 unformat_input_t *i = vam->input;
12861 ip6_address_t client_address, our_address;
12862 int client_address_set = 0;
12863 int our_address_set = 0;
12864 u32 local_session_id = 0;
12865 u32 remote_session_id = 0;
12866 u64 local_cookie = 0;
12867 u64 remote_cookie = 0;
12868 u8 l2_sublayer_present = 0;
12869 vl_api_l2tpv3_create_tunnel_t *mp;
12872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12874 if (unformat (i, "client_address %U", unformat_ip6_address,
12876 client_address_set = 1;
12877 else if (unformat (i, "our_address %U", unformat_ip6_address,
12879 our_address_set = 1;
12880 else if (unformat (i, "local_session_id %d", &local_session_id))
12882 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12884 else if (unformat (i, "local_cookie %lld", &local_cookie))
12886 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12888 else if (unformat (i, "l2-sublayer-present"))
12889 l2_sublayer_present = 1;
12894 if (client_address_set == 0)
12896 errmsg ("client_address required");
12900 if (our_address_set == 0)
12902 errmsg ("our_address required");
12906 M (L2TPV3_CREATE_TUNNEL, mp);
12908 clib_memcpy (mp->client_address, client_address.as_u8,
12909 sizeof (mp->client_address));
12911 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12913 mp->local_session_id = ntohl (local_session_id);
12914 mp->remote_session_id = ntohl (remote_session_id);
12915 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12916 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12917 mp->l2_sublayer_present = l2_sublayer_present;
12926 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12928 unformat_input_t *i = vam->input;
12930 u8 sw_if_index_set = 0;
12931 u64 new_local_cookie = 0;
12932 u64 new_remote_cookie = 0;
12933 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12938 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12939 sw_if_index_set = 1;
12940 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12941 sw_if_index_set = 1;
12942 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12944 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12950 if (sw_if_index_set == 0)
12952 errmsg ("missing interface name or sw_if_index");
12956 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12958 mp->sw_if_index = ntohl (sw_if_index);
12959 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12960 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12968 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12970 unformat_input_t *i = vam->input;
12971 vl_api_l2tpv3_interface_enable_disable_t *mp;
12973 u8 sw_if_index_set = 0;
12974 u8 enable_disable = 1;
12977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12979 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12980 sw_if_index_set = 1;
12981 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12982 sw_if_index_set = 1;
12983 else if (unformat (i, "enable"))
12984 enable_disable = 1;
12985 else if (unformat (i, "disable"))
12986 enable_disable = 0;
12991 if (sw_if_index_set == 0)
12993 errmsg ("missing interface name or sw_if_index");
12997 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12999 mp->sw_if_index = ntohl (sw_if_index);
13000 mp->enable_disable = enable_disable;
13008 api_l2tpv3_set_lookup_key (vat_main_t * vam)
13010 unformat_input_t *i = vam->input;
13011 vl_api_l2tpv3_set_lookup_key_t *mp;
13015 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13017 if (unformat (i, "lookup_v6_src"))
13018 key = L2T_LOOKUP_SRC_ADDRESS;
13019 else if (unformat (i, "lookup_v6_dst"))
13020 key = L2T_LOOKUP_DST_ADDRESS;
13021 else if (unformat (i, "lookup_session_id"))
13022 key = L2T_LOOKUP_SESSION_ID;
13027 if (key == (u8) ~ 0)
13029 errmsg ("l2tp session lookup key unset");
13033 M (L2TPV3_SET_LOOKUP_KEY, mp);
13042 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
13043 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
13045 vat_main_t *vam = &vat_main;
13047 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
13048 format_ip6_address, mp->our_address,
13049 format_ip6_address, mp->client_address,
13050 clib_net_to_host_u32 (mp->sw_if_index));
13053 " local cookies %016llx %016llx remote cookie %016llx",
13054 clib_net_to_host_u64 (mp->local_cookie[0]),
13055 clib_net_to_host_u64 (mp->local_cookie[1]),
13056 clib_net_to_host_u64 (mp->remote_cookie));
13058 print (vam->ofp, " local session-id %d remote session-id %d",
13059 clib_net_to_host_u32 (mp->local_session_id),
13060 clib_net_to_host_u32 (mp->remote_session_id));
13062 print (vam->ofp, " l2 specific sublayer %s\n",
13063 mp->l2_sublayer_present ? "preset" : "absent");
13067 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
13068 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
13070 vat_main_t *vam = &vat_main;
13071 vat_json_node_t *node = NULL;
13072 struct in6_addr addr;
13074 if (VAT_JSON_ARRAY != vam->json_tree.type)
13076 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13077 vat_json_init_array (&vam->json_tree);
13079 node = vat_json_array_add (&vam->json_tree);
13081 vat_json_init_object (node);
13083 clib_memcpy (&addr, mp->our_address, sizeof (addr));
13084 vat_json_object_add_ip6 (node, "our_address", addr);
13085 clib_memcpy (&addr, mp->client_address, sizeof (addr));
13086 vat_json_object_add_ip6 (node, "client_address", addr);
13088 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
13089 vat_json_init_array (lc);
13090 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
13091 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
13092 vat_json_object_add_uint (node, "remote_cookie",
13093 clib_net_to_host_u64 (mp->remote_cookie));
13095 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
13096 vat_json_object_add_uint (node, "local_session_id",
13097 clib_net_to_host_u32 (mp->local_session_id));
13098 vat_json_object_add_uint (node, "remote_session_id",
13099 clib_net_to_host_u32 (mp->remote_session_id));
13100 vat_json_object_add_string_copy (node, "l2_sublayer",
13101 mp->l2_sublayer_present ? (u8 *) "present"
13102 : (u8 *) "absent");
13106 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
13108 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
13109 vl_api_control_ping_t *mp_ping;
13112 /* Get list of l2tpv3-tunnel interfaces */
13113 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
13116 /* Use a control ping for synchronization */
13117 MPING (CONTROL_PING, mp_ping);
13125 static void vl_api_sw_interface_tap_details_t_handler
13126 (vl_api_sw_interface_tap_details_t * mp)
13128 vat_main_t *vam = &vat_main;
13130 print (vam->ofp, "%-16s %d",
13131 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
13134 static void vl_api_sw_interface_tap_details_t_handler_json
13135 (vl_api_sw_interface_tap_details_t * mp)
13137 vat_main_t *vam = &vat_main;
13138 vat_json_node_t *node = NULL;
13140 if (VAT_JSON_ARRAY != vam->json_tree.type)
13142 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13143 vat_json_init_array (&vam->json_tree);
13145 node = vat_json_array_add (&vam->json_tree);
13147 vat_json_init_object (node);
13148 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13149 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
13153 api_sw_interface_tap_dump (vat_main_t * vam)
13155 vl_api_sw_interface_tap_dump_t *mp;
13156 vl_api_control_ping_t *mp_ping;
13159 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
13160 /* Get list of tap interfaces */
13161 M (SW_INTERFACE_TAP_DUMP, mp);
13164 /* Use a control ping for synchronization */
13165 MPING (CONTROL_PING, mp_ping);
13172 static void vl_api_sw_interface_tap_v2_details_t_handler
13173 (vl_api_sw_interface_tap_v2_details_t * mp)
13175 vat_main_t *vam = &vat_main;
13177 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
13178 mp->host_ip4_prefix_len);
13179 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
13180 mp->host_ip6_prefix_len);
13183 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s",
13184 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
13185 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
13186 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
13187 mp->host_bridge, ip4, ip6);
13193 static void vl_api_sw_interface_tap_v2_details_t_handler_json
13194 (vl_api_sw_interface_tap_v2_details_t * mp)
13196 vat_main_t *vam = &vat_main;
13197 vat_json_node_t *node = NULL;
13199 if (VAT_JSON_ARRAY != vam->json_tree.type)
13201 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13202 vat_json_init_array (&vam->json_tree);
13204 node = vat_json_array_add (&vam->json_tree);
13206 vat_json_init_object (node);
13207 vat_json_object_add_uint (node, "id", ntohl (mp->id));
13208 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13209 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
13210 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
13211 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
13212 vat_json_object_add_string_copy (node, "host_mac_addr",
13213 format (0, "%U", format_ethernet_address,
13214 &mp->host_mac_addr));
13215 vat_json_object_add_string_copy (node, "host_namespace",
13216 mp->host_namespace);
13217 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
13218 vat_json_object_add_string_copy (node, "host_ip4_addr",
13219 format (0, "%U/%d", format_ip4_address,
13221 mp->host_ip4_prefix_len));
13222 vat_json_object_add_string_copy (node, "host_ip6_addr",
13223 format (0, "%U/%d", format_ip6_address,
13225 mp->host_ip6_prefix_len));
13230 api_sw_interface_tap_v2_dump (vat_main_t * vam)
13232 vl_api_sw_interface_tap_v2_dump_t *mp;
13233 vl_api_control_ping_t *mp_ping;
13237 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
13238 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
13239 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
13242 /* Get list of tap interfaces */
13243 M (SW_INTERFACE_TAP_V2_DUMP, mp);
13246 /* Use a control ping for synchronization */
13247 MPING (CONTROL_PING, mp_ping);
13255 api_vxlan_offload_rx (vat_main_t * vam)
13257 unformat_input_t *line_input = vam->input;
13258 vl_api_vxlan_offload_rx_t *mp;
13259 u32 hw_if_index = ~0, rx_if_index = ~0;
13263 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13265 if (unformat (line_input, "del"))
13267 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
13270 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
13272 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
13275 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
13279 errmsg ("parse error '%U'", format_unformat_error, line_input);
13284 if (hw_if_index == ~0)
13286 errmsg ("no hw interface");
13290 if (rx_if_index == ~0)
13292 errmsg ("no rx tunnel");
13296 M (VXLAN_OFFLOAD_RX, mp);
13298 mp->hw_if_index = ntohl (hw_if_index);
13299 mp->sw_if_index = ntohl (rx_if_index);
13300 mp->enable = is_add;
13307 static uword unformat_vxlan_decap_next
13308 (unformat_input_t * input, va_list * args)
13310 u32 *result = va_arg (*args, u32 *);
13313 if (unformat (input, "l2"))
13314 *result = VXLAN_INPUT_NEXT_L2_INPUT;
13315 else if (unformat (input, "%d", &tmp))
13323 api_vxlan_add_del_tunnel (vat_main_t * vam)
13325 unformat_input_t *line_input = vam->input;
13326 vl_api_vxlan_add_del_tunnel_t *mp;
13327 ip46_address_t src, dst;
13329 u8 ipv4_set = 0, ipv6_set = 0;
13334 u32 mcast_sw_if_index = ~0;
13335 u32 encap_vrf_id = 0;
13336 u32 decap_next_index = ~0;
13340 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13341 clib_memset (&src, 0, sizeof src);
13342 clib_memset (&dst, 0, sizeof dst);
13344 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13346 if (unformat (line_input, "del"))
13348 else if (unformat (line_input, "instance %d", &instance))
13351 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13357 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13363 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13369 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13374 else if (unformat (line_input, "group %U %U",
13375 unformat_ip4_address, &dst.ip4,
13376 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13378 grp_set = dst_set = 1;
13381 else if (unformat (line_input, "group %U",
13382 unformat_ip4_address, &dst.ip4))
13384 grp_set = dst_set = 1;
13387 else if (unformat (line_input, "group %U %U",
13388 unformat_ip6_address, &dst.ip6,
13389 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13391 grp_set = dst_set = 1;
13394 else if (unformat (line_input, "group %U",
13395 unformat_ip6_address, &dst.ip6))
13397 grp_set = dst_set = 1;
13401 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13403 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13405 else if (unformat (line_input, "decap-next %U",
13406 unformat_vxlan_decap_next, &decap_next_index))
13408 else if (unformat (line_input, "vni %d", &vni))
13412 errmsg ("parse error '%U'", format_unformat_error, line_input);
13419 errmsg ("tunnel src address not specified");
13424 errmsg ("tunnel dst address not specified");
13428 if (grp_set && !ip46_address_is_multicast (&dst))
13430 errmsg ("tunnel group address not multicast");
13433 if (grp_set && mcast_sw_if_index == ~0)
13435 errmsg ("tunnel nonexistent multicast device");
13438 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13440 errmsg ("tunnel dst address must be unicast");
13445 if (ipv4_set && ipv6_set)
13447 errmsg ("both IPv4 and IPv6 addresses specified");
13451 if ((vni == 0) || (vni >> 24))
13453 errmsg ("vni not specified or out of range");
13457 M (VXLAN_ADD_DEL_TUNNEL, mp);
13461 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
13462 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
13466 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
13467 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
13470 mp->instance = htonl (instance);
13471 mp->encap_vrf_id = ntohl (encap_vrf_id);
13472 mp->decap_next_index = ntohl (decap_next_index);
13473 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13474 mp->vni = ntohl (vni);
13475 mp->is_add = is_add;
13476 mp->is_ipv6 = ipv6_set;
13483 static void vl_api_vxlan_tunnel_details_t_handler
13484 (vl_api_vxlan_tunnel_details_t * mp)
13486 vat_main_t *vam = &vat_main;
13487 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13488 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13490 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
13491 ntohl (mp->sw_if_index),
13492 ntohl (mp->instance),
13493 format_ip46_address, &src, IP46_TYPE_ANY,
13494 format_ip46_address, &dst, IP46_TYPE_ANY,
13495 ntohl (mp->encap_vrf_id),
13496 ntohl (mp->decap_next_index), ntohl (mp->vni),
13497 ntohl (mp->mcast_sw_if_index));
13500 static void vl_api_vxlan_tunnel_details_t_handler_json
13501 (vl_api_vxlan_tunnel_details_t * mp)
13503 vat_main_t *vam = &vat_main;
13504 vat_json_node_t *node = NULL;
13506 if (VAT_JSON_ARRAY != vam->json_tree.type)
13508 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13509 vat_json_init_array (&vam->json_tree);
13511 node = vat_json_array_add (&vam->json_tree);
13513 vat_json_init_object (node);
13514 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13516 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
13520 struct in6_addr ip6;
13522 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13523 vat_json_object_add_ip6 (node, "src_address", ip6);
13524 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13525 vat_json_object_add_ip6 (node, "dst_address", ip6);
13529 struct in_addr ip4;
13531 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13532 vat_json_object_add_ip4 (node, "src_address", ip4);
13533 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13534 vat_json_object_add_ip4 (node, "dst_address", ip4);
13536 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13537 vat_json_object_add_uint (node, "decap_next_index",
13538 ntohl (mp->decap_next_index));
13539 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13540 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13541 vat_json_object_add_uint (node, "mcast_sw_if_index",
13542 ntohl (mp->mcast_sw_if_index));
13546 api_vxlan_tunnel_dump (vat_main_t * vam)
13548 unformat_input_t *i = vam->input;
13549 vl_api_vxlan_tunnel_dump_t *mp;
13550 vl_api_control_ping_t *mp_ping;
13552 u8 sw_if_index_set = 0;
13555 /* Parse args required to build the message */
13556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13558 if (unformat (i, "sw_if_index %d", &sw_if_index))
13559 sw_if_index_set = 1;
13564 if (sw_if_index_set == 0)
13569 if (!vam->json_output)
13571 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
13572 "sw_if_index", "instance", "src_address", "dst_address",
13573 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13576 /* Get list of vxlan-tunnel interfaces */
13577 M (VXLAN_TUNNEL_DUMP, mp);
13579 mp->sw_if_index = htonl (sw_if_index);
13583 /* Use a control ping for synchronization */
13584 MPING (CONTROL_PING, mp_ping);
13591 static uword unformat_geneve_decap_next
13592 (unformat_input_t * input, va_list * args)
13594 u32 *result = va_arg (*args, u32 *);
13597 if (unformat (input, "l2"))
13598 *result = GENEVE_INPUT_NEXT_L2_INPUT;
13599 else if (unformat (input, "%d", &tmp))
13607 api_geneve_add_del_tunnel (vat_main_t * vam)
13609 unformat_input_t *line_input = vam->input;
13610 vl_api_geneve_add_del_tunnel_t *mp;
13611 ip46_address_t src, dst;
13613 u8 ipv4_set = 0, ipv6_set = 0;
13617 u32 mcast_sw_if_index = ~0;
13618 u32 encap_vrf_id = 0;
13619 u32 decap_next_index = ~0;
13623 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13624 clib_memset (&src, 0, sizeof src);
13625 clib_memset (&dst, 0, sizeof dst);
13627 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13629 if (unformat (line_input, "del"))
13632 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13638 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13644 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13650 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13655 else if (unformat (line_input, "group %U %U",
13656 unformat_ip4_address, &dst.ip4,
13657 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13659 grp_set = dst_set = 1;
13662 else if (unformat (line_input, "group %U",
13663 unformat_ip4_address, &dst.ip4))
13665 grp_set = dst_set = 1;
13668 else if (unformat (line_input, "group %U %U",
13669 unformat_ip6_address, &dst.ip6,
13670 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13672 grp_set = dst_set = 1;
13675 else if (unformat (line_input, "group %U",
13676 unformat_ip6_address, &dst.ip6))
13678 grp_set = dst_set = 1;
13682 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13684 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13686 else if (unformat (line_input, "decap-next %U",
13687 unformat_geneve_decap_next, &decap_next_index))
13689 else if (unformat (line_input, "vni %d", &vni))
13693 errmsg ("parse error '%U'", format_unformat_error, line_input);
13700 errmsg ("tunnel src address not specified");
13705 errmsg ("tunnel dst address not specified");
13709 if (grp_set && !ip46_address_is_multicast (&dst))
13711 errmsg ("tunnel group address not multicast");
13714 if (grp_set && mcast_sw_if_index == ~0)
13716 errmsg ("tunnel nonexistent multicast device");
13719 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13721 errmsg ("tunnel dst address must be unicast");
13726 if (ipv4_set && ipv6_set)
13728 errmsg ("both IPv4 and IPv6 addresses specified");
13732 if ((vni == 0) || (vni >> 24))
13734 errmsg ("vni not specified or out of range");
13738 M (GENEVE_ADD_DEL_TUNNEL, mp);
13742 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13743 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13747 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13748 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13750 mp->encap_vrf_id = ntohl (encap_vrf_id);
13751 mp->decap_next_index = ntohl (decap_next_index);
13752 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13753 mp->vni = ntohl (vni);
13754 mp->is_add = is_add;
13755 mp->is_ipv6 = ipv6_set;
13762 static void vl_api_geneve_tunnel_details_t_handler
13763 (vl_api_geneve_tunnel_details_t * mp)
13765 vat_main_t *vam = &vat_main;
13766 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13767 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13769 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13770 ntohl (mp->sw_if_index),
13771 format_ip46_address, &src, IP46_TYPE_ANY,
13772 format_ip46_address, &dst, IP46_TYPE_ANY,
13773 ntohl (mp->encap_vrf_id),
13774 ntohl (mp->decap_next_index), ntohl (mp->vni),
13775 ntohl (mp->mcast_sw_if_index));
13778 static void vl_api_geneve_tunnel_details_t_handler_json
13779 (vl_api_geneve_tunnel_details_t * mp)
13781 vat_main_t *vam = &vat_main;
13782 vat_json_node_t *node = NULL;
13784 if (VAT_JSON_ARRAY != vam->json_tree.type)
13786 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13787 vat_json_init_array (&vam->json_tree);
13789 node = vat_json_array_add (&vam->json_tree);
13791 vat_json_init_object (node);
13792 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13795 struct in6_addr ip6;
13797 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13798 vat_json_object_add_ip6 (node, "src_address", ip6);
13799 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13800 vat_json_object_add_ip6 (node, "dst_address", ip6);
13804 struct in_addr ip4;
13806 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13807 vat_json_object_add_ip4 (node, "src_address", ip4);
13808 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13809 vat_json_object_add_ip4 (node, "dst_address", ip4);
13811 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13812 vat_json_object_add_uint (node, "decap_next_index",
13813 ntohl (mp->decap_next_index));
13814 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13815 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13816 vat_json_object_add_uint (node, "mcast_sw_if_index",
13817 ntohl (mp->mcast_sw_if_index));
13821 api_geneve_tunnel_dump (vat_main_t * vam)
13823 unformat_input_t *i = vam->input;
13824 vl_api_geneve_tunnel_dump_t *mp;
13825 vl_api_control_ping_t *mp_ping;
13827 u8 sw_if_index_set = 0;
13830 /* Parse args required to build the message */
13831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13833 if (unformat (i, "sw_if_index %d", &sw_if_index))
13834 sw_if_index_set = 1;
13839 if (sw_if_index_set == 0)
13844 if (!vam->json_output)
13846 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13847 "sw_if_index", "local_address", "remote_address",
13848 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13851 /* Get list of geneve-tunnel interfaces */
13852 M (GENEVE_TUNNEL_DUMP, mp);
13854 mp->sw_if_index = htonl (sw_if_index);
13858 /* Use a control ping for synchronization */
13859 M (CONTROL_PING, mp_ping);
13867 api_gre_add_del_tunnel (vat_main_t * vam)
13869 unformat_input_t *line_input = vam->input;
13870 vl_api_gre_add_del_tunnel_t *mp;
13871 ip4_address_t src4, dst4;
13872 ip6_address_t src6, dst6;
13876 u8 t_type = GRE_TUNNEL_TYPE_L3;
13879 u32 outer_fib_id = 0;
13880 u32 session_id = 0;
13884 clib_memset (&src4, 0, sizeof src4);
13885 clib_memset (&dst4, 0, sizeof dst4);
13886 clib_memset (&src6, 0, sizeof src6);
13887 clib_memset (&dst6, 0, sizeof dst6);
13889 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13891 if (unformat (line_input, "del"))
13893 else if (unformat (line_input, "instance %d", &instance))
13895 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13900 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13905 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13910 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13915 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13917 else if (unformat (line_input, "teb"))
13918 t_type = GRE_TUNNEL_TYPE_TEB;
13919 else if (unformat (line_input, "erspan %d", &session_id))
13920 t_type = GRE_TUNNEL_TYPE_ERSPAN;
13923 errmsg ("parse error '%U'", format_unformat_error, line_input);
13930 errmsg ("tunnel src address not specified");
13935 errmsg ("tunnel dst address not specified");
13938 if (ipv4_set && ipv6_set)
13940 errmsg ("both IPv4 and IPv6 addresses specified");
13945 M (GRE_ADD_DEL_TUNNEL, mp);
13949 clib_memcpy (&mp->src_address, &src4, 4);
13950 clib_memcpy (&mp->dst_address, &dst4, 4);
13954 clib_memcpy (&mp->src_address, &src6, 16);
13955 clib_memcpy (&mp->dst_address, &dst6, 16);
13957 mp->instance = htonl (instance);
13958 mp->outer_fib_id = htonl (outer_fib_id);
13959 mp->is_add = is_add;
13960 mp->session_id = htons ((u16) session_id);
13961 mp->tunnel_type = t_type;
13962 mp->is_ipv6 = ipv6_set;
13969 static void vl_api_gre_tunnel_details_t_handler
13970 (vl_api_gre_tunnel_details_t * mp)
13972 vat_main_t *vam = &vat_main;
13973 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13974 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13976 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13977 ntohl (mp->sw_if_index),
13978 ntohl (mp->instance),
13979 format_ip46_address, &src, IP46_TYPE_ANY,
13980 format_ip46_address, &dst, IP46_TYPE_ANY,
13981 mp->tunnel_type, ntohl (mp->outer_fib_id), ntohl (mp->session_id));
13984 static void vl_api_gre_tunnel_details_t_handler_json
13985 (vl_api_gre_tunnel_details_t * mp)
13987 vat_main_t *vam = &vat_main;
13988 vat_json_node_t *node = NULL;
13989 struct in_addr ip4;
13990 struct in6_addr ip6;
13992 if (VAT_JSON_ARRAY != vam->json_tree.type)
13994 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13995 vat_json_init_array (&vam->json_tree);
13997 node = vat_json_array_add (&vam->json_tree);
13999 vat_json_init_object (node);
14000 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14001 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
14004 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
14005 vat_json_object_add_ip4 (node, "src_address", ip4);
14006 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
14007 vat_json_object_add_ip4 (node, "dst_address", ip4);
14011 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
14012 vat_json_object_add_ip6 (node, "src_address", ip6);
14013 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
14014 vat_json_object_add_ip6 (node, "dst_address", ip6);
14016 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel_type);
14017 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
14018 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
14019 vat_json_object_add_uint (node, "session_id", mp->session_id);
14023 api_gre_tunnel_dump (vat_main_t * vam)
14025 unformat_input_t *i = vam->input;
14026 vl_api_gre_tunnel_dump_t *mp;
14027 vl_api_control_ping_t *mp_ping;
14029 u8 sw_if_index_set = 0;
14032 /* Parse args required to build the message */
14033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14035 if (unformat (i, "sw_if_index %d", &sw_if_index))
14036 sw_if_index_set = 1;
14041 if (sw_if_index_set == 0)
14046 if (!vam->json_output)
14048 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
14049 "sw_if_index", "instance", "src_address", "dst_address",
14050 "tunnel_type", "outer_fib_id", "session_id");
14053 /* Get list of gre-tunnel interfaces */
14054 M (GRE_TUNNEL_DUMP, mp);
14056 mp->sw_if_index = htonl (sw_if_index);
14060 /* Use a control ping for synchronization */
14061 MPING (CONTROL_PING, mp_ping);
14069 api_l2_fib_clear_table (vat_main_t * vam)
14071 // unformat_input_t * i = vam->input;
14072 vl_api_l2_fib_clear_table_t *mp;
14075 M (L2_FIB_CLEAR_TABLE, mp);
14083 api_l2_interface_efp_filter (vat_main_t * vam)
14085 unformat_input_t *i = vam->input;
14086 vl_api_l2_interface_efp_filter_t *mp;
14089 u8 sw_if_index_set = 0;
14092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14094 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14095 sw_if_index_set = 1;
14096 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14097 sw_if_index_set = 1;
14098 else if (unformat (i, "enable"))
14100 else if (unformat (i, "disable"))
14104 clib_warning ("parse error '%U'", format_unformat_error, i);
14109 if (sw_if_index_set == 0)
14111 errmsg ("missing sw_if_index");
14115 M (L2_INTERFACE_EFP_FILTER, mp);
14117 mp->sw_if_index = ntohl (sw_if_index);
14118 mp->enable_disable = enable;
14125 #define foreach_vtr_op \
14126 _("disable", L2_VTR_DISABLED) \
14127 _("push-1", L2_VTR_PUSH_1) \
14128 _("push-2", L2_VTR_PUSH_2) \
14129 _("pop-1", L2_VTR_POP_1) \
14130 _("pop-2", L2_VTR_POP_2) \
14131 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
14132 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
14133 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
14134 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
14137 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
14139 unformat_input_t *i = vam->input;
14140 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
14142 u8 sw_if_index_set = 0;
14145 u32 push_dot1q = 1;
14150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14152 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14153 sw_if_index_set = 1;
14154 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14155 sw_if_index_set = 1;
14156 else if (unformat (i, "vtr_op %d", &vtr_op))
14158 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
14161 else if (unformat (i, "push_dot1q %d", &push_dot1q))
14163 else if (unformat (i, "tag1 %d", &tag1))
14165 else if (unformat (i, "tag2 %d", &tag2))
14169 clib_warning ("parse error '%U'", format_unformat_error, i);
14174 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
14176 errmsg ("missing vtr operation or sw_if_index");
14180 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
14181 mp->sw_if_index = ntohl (sw_if_index);
14182 mp->vtr_op = ntohl (vtr_op);
14183 mp->push_dot1q = ntohl (push_dot1q);
14184 mp->tag1 = ntohl (tag1);
14185 mp->tag2 = ntohl (tag2);
14193 api_create_vhost_user_if (vat_main_t * vam)
14195 unformat_input_t *i = vam->input;
14196 vl_api_create_vhost_user_if_t *mp;
14199 u8 file_name_set = 0;
14200 u32 custom_dev_instance = ~0;
14202 u8 use_custom_mac = 0;
14203 u8 disable_mrg_rxbuf = 0;
14204 u8 disable_indirect_desc = 0;
14208 /* Shut up coverity */
14209 clib_memset (hwaddr, 0, sizeof (hwaddr));
14211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14213 if (unformat (i, "socket %s", &file_name))
14217 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
14219 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
14220 use_custom_mac = 1;
14221 else if (unformat (i, "server"))
14223 else if (unformat (i, "disable_mrg_rxbuf"))
14224 disable_mrg_rxbuf = 1;
14225 else if (unformat (i, "disable_indirect_desc"))
14226 disable_indirect_desc = 1;
14227 else if (unformat (i, "tag %s", &tag))
14233 if (file_name_set == 0)
14235 errmsg ("missing socket file name");
14239 if (vec_len (file_name) > 255)
14241 errmsg ("socket file name too long");
14244 vec_add1 (file_name, 0);
14246 M (CREATE_VHOST_USER_IF, mp);
14248 mp->is_server = is_server;
14249 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
14250 mp->disable_indirect_desc = disable_indirect_desc;
14251 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
14252 vec_free (file_name);
14253 if (custom_dev_instance != ~0)
14256 mp->custom_dev_instance = ntohl (custom_dev_instance);
14259 mp->use_custom_mac = use_custom_mac;
14260 clib_memcpy (mp->mac_address, hwaddr, 6);
14262 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
14271 api_modify_vhost_user_if (vat_main_t * vam)
14273 unformat_input_t *i = vam->input;
14274 vl_api_modify_vhost_user_if_t *mp;
14277 u8 file_name_set = 0;
14278 u32 custom_dev_instance = ~0;
14279 u8 sw_if_index_set = 0;
14280 u32 sw_if_index = (u32) ~ 0;
14283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14285 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14286 sw_if_index_set = 1;
14287 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14288 sw_if_index_set = 1;
14289 else if (unformat (i, "socket %s", &file_name))
14293 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
14295 else if (unformat (i, "server"))
14301 if (sw_if_index_set == 0)
14303 errmsg ("missing sw_if_index or interface name");
14307 if (file_name_set == 0)
14309 errmsg ("missing socket file name");
14313 if (vec_len (file_name) > 255)
14315 errmsg ("socket file name too long");
14318 vec_add1 (file_name, 0);
14320 M (MODIFY_VHOST_USER_IF, mp);
14322 mp->sw_if_index = ntohl (sw_if_index);
14323 mp->is_server = is_server;
14324 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
14325 vec_free (file_name);
14326 if (custom_dev_instance != ~0)
14329 mp->custom_dev_instance = ntohl (custom_dev_instance);
14338 api_delete_vhost_user_if (vat_main_t * vam)
14340 unformat_input_t *i = vam->input;
14341 vl_api_delete_vhost_user_if_t *mp;
14342 u32 sw_if_index = ~0;
14343 u8 sw_if_index_set = 0;
14346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14348 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14349 sw_if_index_set = 1;
14350 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14351 sw_if_index_set = 1;
14356 if (sw_if_index_set == 0)
14358 errmsg ("missing sw_if_index or interface name");
14363 M (DELETE_VHOST_USER_IF, mp);
14365 mp->sw_if_index = ntohl (sw_if_index);
14372 static void vl_api_sw_interface_vhost_user_details_t_handler
14373 (vl_api_sw_interface_vhost_user_details_t * mp)
14375 vat_main_t *vam = &vat_main;
14377 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
14378 (char *) mp->interface_name,
14379 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
14380 clib_net_to_host_u64 (mp->features), mp->is_server,
14381 ntohl (mp->num_regions), (char *) mp->sock_filename);
14382 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
14385 static void vl_api_sw_interface_vhost_user_details_t_handler_json
14386 (vl_api_sw_interface_vhost_user_details_t * mp)
14388 vat_main_t *vam = &vat_main;
14389 vat_json_node_t *node = NULL;
14391 if (VAT_JSON_ARRAY != vam->json_tree.type)
14393 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14394 vat_json_init_array (&vam->json_tree);
14396 node = vat_json_array_add (&vam->json_tree);
14398 vat_json_init_object (node);
14399 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14400 vat_json_object_add_string_copy (node, "interface_name",
14401 mp->interface_name);
14402 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
14403 ntohl (mp->virtio_net_hdr_sz));
14404 vat_json_object_add_uint (node, "features",
14405 clib_net_to_host_u64 (mp->features));
14406 vat_json_object_add_uint (node, "is_server", mp->is_server);
14407 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
14408 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
14409 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
14413 api_sw_interface_vhost_user_dump (vat_main_t * vam)
14415 vl_api_sw_interface_vhost_user_dump_t *mp;
14416 vl_api_control_ping_t *mp_ping;
14419 "Interface name idx hdr_sz features server regions filename");
14421 /* Get list of vhost-user interfaces */
14422 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
14425 /* Use a control ping for synchronization */
14426 MPING (CONTROL_PING, mp_ping);
14434 api_show_version (vat_main_t * vam)
14436 vl_api_show_version_t *mp;
14439 M (SHOW_VERSION, mp);
14448 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
14450 unformat_input_t *line_input = vam->input;
14451 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
14452 ip4_address_t local4, remote4;
14453 ip6_address_t local6, remote6;
14455 u8 ipv4_set = 0, ipv6_set = 0;
14459 u32 mcast_sw_if_index = ~0;
14460 u32 encap_vrf_id = 0;
14461 u32 decap_vrf_id = 0;
14467 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
14468 clib_memset (&local4, 0, sizeof local4);
14469 clib_memset (&remote4, 0, sizeof remote4);
14470 clib_memset (&local6, 0, sizeof local6);
14471 clib_memset (&remote6, 0, sizeof remote6);
14473 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14475 if (unformat (line_input, "del"))
14477 else if (unformat (line_input, "local %U",
14478 unformat_ip4_address, &local4))
14483 else if (unformat (line_input, "remote %U",
14484 unformat_ip4_address, &remote4))
14489 else if (unformat (line_input, "local %U",
14490 unformat_ip6_address, &local6))
14495 else if (unformat (line_input, "remote %U",
14496 unformat_ip6_address, &remote6))
14501 else if (unformat (line_input, "group %U %U",
14502 unformat_ip4_address, &remote4,
14503 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
14505 grp_set = remote_set = 1;
14508 else if (unformat (line_input, "group %U",
14509 unformat_ip4_address, &remote4))
14511 grp_set = remote_set = 1;
14514 else if (unformat (line_input, "group %U %U",
14515 unformat_ip6_address, &remote6,
14516 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
14518 grp_set = remote_set = 1;
14521 else if (unformat (line_input, "group %U",
14522 unformat_ip6_address, &remote6))
14524 grp_set = remote_set = 1;
14528 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
14530 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
14532 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
14534 else if (unformat (line_input, "vni %d", &vni))
14536 else if (unformat (line_input, "next-ip4"))
14538 else if (unformat (line_input, "next-ip6"))
14540 else if (unformat (line_input, "next-ethernet"))
14542 else if (unformat (line_input, "next-nsh"))
14546 errmsg ("parse error '%U'", format_unformat_error, line_input);
14551 if (local_set == 0)
14553 errmsg ("tunnel local address not specified");
14556 if (remote_set == 0)
14558 errmsg ("tunnel remote address not specified");
14561 if (grp_set && mcast_sw_if_index == ~0)
14563 errmsg ("tunnel nonexistent multicast device");
14566 if (ipv4_set && ipv6_set)
14568 errmsg ("both IPv4 and IPv6 addresses specified");
14574 errmsg ("vni not specified");
14578 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
14583 clib_memcpy (&mp->local, &local6, sizeof (local6));
14584 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
14588 clib_memcpy (&mp->local, &local4, sizeof (local4));
14589 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
14592 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
14593 mp->encap_vrf_id = ntohl (encap_vrf_id);
14594 mp->decap_vrf_id = ntohl (decap_vrf_id);
14595 mp->protocol = protocol;
14596 mp->vni = ntohl (vni);
14597 mp->is_add = is_add;
14598 mp->is_ipv6 = ipv6_set;
14605 static void vl_api_vxlan_gpe_tunnel_details_t_handler
14606 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14608 vat_main_t *vam = &vat_main;
14609 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
14610 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
14612 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
14613 ntohl (mp->sw_if_index),
14614 format_ip46_address, &local, IP46_TYPE_ANY,
14615 format_ip46_address, &remote, IP46_TYPE_ANY,
14616 ntohl (mp->vni), mp->protocol,
14617 ntohl (mp->mcast_sw_if_index),
14618 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
14622 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
14623 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14625 vat_main_t *vam = &vat_main;
14626 vat_json_node_t *node = NULL;
14627 struct in_addr ip4;
14628 struct in6_addr ip6;
14630 if (VAT_JSON_ARRAY != vam->json_tree.type)
14632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14633 vat_json_init_array (&vam->json_tree);
14635 node = vat_json_array_add (&vam->json_tree);
14637 vat_json_init_object (node);
14638 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14641 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
14642 vat_json_object_add_ip6 (node, "local", ip6);
14643 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
14644 vat_json_object_add_ip6 (node, "remote", ip6);
14648 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
14649 vat_json_object_add_ip4 (node, "local", ip4);
14650 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
14651 vat_json_object_add_ip4 (node, "remote", ip4);
14653 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
14654 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
14655 vat_json_object_add_uint (node, "mcast_sw_if_index",
14656 ntohl (mp->mcast_sw_if_index));
14657 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
14658 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
14659 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14663 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14665 unformat_input_t *i = vam->input;
14666 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14667 vl_api_control_ping_t *mp_ping;
14669 u8 sw_if_index_set = 0;
14672 /* Parse args required to build the message */
14673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14675 if (unformat (i, "sw_if_index %d", &sw_if_index))
14676 sw_if_index_set = 1;
14681 if (sw_if_index_set == 0)
14686 if (!vam->json_output)
14688 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14689 "sw_if_index", "local", "remote", "vni",
14690 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14693 /* Get list of vxlan-tunnel interfaces */
14694 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14696 mp->sw_if_index = htonl (sw_if_index);
14700 /* Use a control ping for synchronization */
14701 MPING (CONTROL_PING, mp_ping);
14708 static void vl_api_l2_fib_table_details_t_handler
14709 (vl_api_l2_fib_table_details_t * mp)
14711 vat_main_t *vam = &vat_main;
14713 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14715 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14716 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14720 static void vl_api_l2_fib_table_details_t_handler_json
14721 (vl_api_l2_fib_table_details_t * mp)
14723 vat_main_t *vam = &vat_main;
14724 vat_json_node_t *node = NULL;
14726 if (VAT_JSON_ARRAY != vam->json_tree.type)
14728 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14729 vat_json_init_array (&vam->json_tree);
14731 node = vat_json_array_add (&vam->json_tree);
14733 vat_json_init_object (node);
14734 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14735 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14736 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14737 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14738 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14739 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14743 api_l2_fib_table_dump (vat_main_t * vam)
14745 unformat_input_t *i = vam->input;
14746 vl_api_l2_fib_table_dump_t *mp;
14747 vl_api_control_ping_t *mp_ping;
14752 /* Parse args required to build the message */
14753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14755 if (unformat (i, "bd_id %d", &bd_id))
14761 if (bd_id_set == 0)
14763 errmsg ("missing bridge domain");
14767 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14769 /* Get list of l2 fib entries */
14770 M (L2_FIB_TABLE_DUMP, mp);
14772 mp->bd_id = ntohl (bd_id);
14775 /* Use a control ping for synchronization */
14776 MPING (CONTROL_PING, mp_ping);
14785 api_interface_name_renumber (vat_main_t * vam)
14787 unformat_input_t *line_input = vam->input;
14788 vl_api_interface_name_renumber_t *mp;
14789 u32 sw_if_index = ~0;
14790 u32 new_show_dev_instance = ~0;
14793 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14795 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14798 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14800 else if (unformat (line_input, "new_show_dev_instance %d",
14801 &new_show_dev_instance))
14807 if (sw_if_index == ~0)
14809 errmsg ("missing interface name or sw_if_index");
14813 if (new_show_dev_instance == ~0)
14815 errmsg ("missing new_show_dev_instance");
14819 M (INTERFACE_NAME_RENUMBER, mp);
14821 mp->sw_if_index = ntohl (sw_if_index);
14822 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14830 api_ip_probe_neighbor (vat_main_t * vam)
14832 unformat_input_t *i = vam->input;
14833 vl_api_ip_probe_neighbor_t *mp;
14841 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14843 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14845 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14847 else if (unformat (i, "address %U", unformat_ip4_address, dst_adr))
14849 else if (unformat (i, "address %U", unformat_ip6_address, dst_adr))
14860 errmsg ("missing interface");
14866 errmsg ("missing addresses");
14870 M (IP_PROBE_NEIGHBOR, mp);
14872 mp->sw_if_index = ntohl (sw_if_index);
14873 mp->is_ipv6 = is_ipv6;
14874 clib_memcpy (mp->dst_address, dst_adr, sizeof (dst_adr));
14882 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14884 unformat_input_t *i = vam->input;
14885 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14886 u8 mode = IP_SCAN_V46_NEIGHBORS;
14887 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14892 if (unformat (i, "ip4"))
14893 mode = IP_SCAN_V4_NEIGHBORS;
14894 else if (unformat (i, "ip6"))
14895 mode = IP_SCAN_V6_NEIGHBORS;
14896 if (unformat (i, "both"))
14897 mode = IP_SCAN_V46_NEIGHBORS;
14898 else if (unformat (i, "disable"))
14899 mode = IP_SCAN_DISABLED;
14900 else if (unformat (i, "interval %d", &interval))
14902 else if (unformat (i, "max-time %d", &time))
14904 else if (unformat (i, "max-update %d", &update))
14906 else if (unformat (i, "delay %d", &delay))
14908 else if (unformat (i, "stale %d", &stale))
14914 if (interval > 255)
14916 errmsg ("interval cannot exceed 255 minutes.");
14921 errmsg ("max-time cannot exceed 255 usec.");
14926 errmsg ("max-update cannot exceed 255.");
14931 errmsg ("delay cannot exceed 255 msec.");
14936 errmsg ("stale cannot exceed 255 minutes.");
14940 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14942 mp->scan_interval = interval;
14943 mp->max_proc_time = time;
14944 mp->max_update = update;
14945 mp->scan_int_delay = delay;
14946 mp->stale_threshold = stale;
14954 api_want_ip4_arp_events (vat_main_t * vam)
14956 unformat_input_t *line_input = vam->input;
14957 vl_api_want_ip4_arp_events_t *mp;
14958 ip4_address_t address;
14959 int address_set = 0;
14960 u32 enable_disable = 1;
14963 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14965 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14967 else if (unformat (line_input, "del"))
14968 enable_disable = 0;
14973 if (address_set == 0)
14975 errmsg ("missing addresses");
14979 M (WANT_IP4_ARP_EVENTS, mp);
14980 mp->enable_disable = enable_disable;
14981 mp->pid = htonl (getpid ());
14982 mp->address = address.as_u32;
14990 api_want_ip6_nd_events (vat_main_t * vam)
14992 unformat_input_t *line_input = vam->input;
14993 vl_api_want_ip6_nd_events_t *mp;
14994 ip6_address_t address;
14995 int address_set = 0;
14996 u32 enable_disable = 1;
14999 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15001 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
15003 else if (unformat (line_input, "del"))
15004 enable_disable = 0;
15009 if (address_set == 0)
15011 errmsg ("missing addresses");
15015 M (WANT_IP6_ND_EVENTS, mp);
15016 mp->enable_disable = enable_disable;
15017 mp->pid = htonl (getpid ());
15018 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
15026 api_want_l2_macs_events (vat_main_t * vam)
15028 unformat_input_t *line_input = vam->input;
15029 vl_api_want_l2_macs_events_t *mp;
15030 u8 enable_disable = 1;
15031 u32 scan_delay = 0;
15032 u32 max_macs_in_event = 0;
15033 u32 learn_limit = 0;
15036 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15038 if (unformat (line_input, "learn-limit %d", &learn_limit))
15040 else if (unformat (line_input, "scan-delay %d", &scan_delay))
15042 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
15044 else if (unformat (line_input, "disable"))
15045 enable_disable = 0;
15050 M (WANT_L2_MACS_EVENTS, mp);
15051 mp->enable_disable = enable_disable;
15052 mp->pid = htonl (getpid ());
15053 mp->learn_limit = htonl (learn_limit);
15054 mp->scan_delay = (u8) scan_delay;
15055 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
15062 api_input_acl_set_interface (vat_main_t * vam)
15064 unformat_input_t *i = vam->input;
15065 vl_api_input_acl_set_interface_t *mp;
15067 int sw_if_index_set;
15068 u32 ip4_table_index = ~0;
15069 u32 ip6_table_index = ~0;
15070 u32 l2_table_index = ~0;
15074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15076 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15077 sw_if_index_set = 1;
15078 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15079 sw_if_index_set = 1;
15080 else if (unformat (i, "del"))
15082 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15084 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15086 else if (unformat (i, "l2-table %d", &l2_table_index))
15090 clib_warning ("parse error '%U'", format_unformat_error, i);
15095 if (sw_if_index_set == 0)
15097 errmsg ("missing interface name or sw_if_index");
15101 M (INPUT_ACL_SET_INTERFACE, mp);
15103 mp->sw_if_index = ntohl (sw_if_index);
15104 mp->ip4_table_index = ntohl (ip4_table_index);
15105 mp->ip6_table_index = ntohl (ip6_table_index);
15106 mp->l2_table_index = ntohl (l2_table_index);
15107 mp->is_add = is_add;
15115 api_output_acl_set_interface (vat_main_t * vam)
15117 unformat_input_t *i = vam->input;
15118 vl_api_output_acl_set_interface_t *mp;
15120 int sw_if_index_set;
15121 u32 ip4_table_index = ~0;
15122 u32 ip6_table_index = ~0;
15123 u32 l2_table_index = ~0;
15127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15129 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15130 sw_if_index_set = 1;
15131 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15132 sw_if_index_set = 1;
15133 else if (unformat (i, "del"))
15135 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15137 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15139 else if (unformat (i, "l2-table %d", &l2_table_index))
15143 clib_warning ("parse error '%U'", format_unformat_error, i);
15148 if (sw_if_index_set == 0)
15150 errmsg ("missing interface name or sw_if_index");
15154 M (OUTPUT_ACL_SET_INTERFACE, mp);
15156 mp->sw_if_index = ntohl (sw_if_index);
15157 mp->ip4_table_index = ntohl (ip4_table_index);
15158 mp->ip6_table_index = ntohl (ip6_table_index);
15159 mp->l2_table_index = ntohl (l2_table_index);
15160 mp->is_add = is_add;
15168 api_ip_address_dump (vat_main_t * vam)
15170 unformat_input_t *i = vam->input;
15171 vl_api_ip_address_dump_t *mp;
15172 vl_api_control_ping_t *mp_ping;
15173 u32 sw_if_index = ~0;
15174 u8 sw_if_index_set = 0;
15179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15181 if (unformat (i, "sw_if_index %d", &sw_if_index))
15182 sw_if_index_set = 1;
15184 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15185 sw_if_index_set = 1;
15186 else if (unformat (i, "ipv4"))
15188 else if (unformat (i, "ipv6"))
15194 if (ipv4_set && ipv6_set)
15196 errmsg ("ipv4 and ipv6 flags cannot be both set");
15200 if ((!ipv4_set) && (!ipv6_set))
15202 errmsg ("no ipv4 nor ipv6 flag set");
15206 if (sw_if_index_set == 0)
15208 errmsg ("missing interface name or sw_if_index");
15212 vam->current_sw_if_index = sw_if_index;
15213 vam->is_ipv6 = ipv6_set;
15215 M (IP_ADDRESS_DUMP, mp);
15216 mp->sw_if_index = ntohl (sw_if_index);
15217 mp->is_ipv6 = ipv6_set;
15220 /* Use a control ping for synchronization */
15221 MPING (CONTROL_PING, mp_ping);
15229 api_ip_dump (vat_main_t * vam)
15231 vl_api_ip_dump_t *mp;
15232 vl_api_control_ping_t *mp_ping;
15233 unformat_input_t *in = vam->input;
15240 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
15242 if (unformat (in, "ipv4"))
15244 else if (unformat (in, "ipv6"))
15250 if (ipv4_set && ipv6_set)
15252 errmsg ("ipv4 and ipv6 flags cannot be both set");
15256 if ((!ipv4_set) && (!ipv6_set))
15258 errmsg ("no ipv4 nor ipv6 flag set");
15262 is_ipv6 = ipv6_set;
15263 vam->is_ipv6 = is_ipv6;
15265 /* free old data */
15266 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
15268 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
15270 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
15273 mp->is_ipv6 = ipv6_set;
15276 /* Use a control ping for synchronization */
15277 MPING (CONTROL_PING, mp_ping);
15285 api_ipsec_spd_add_del (vat_main_t * vam)
15287 unformat_input_t *i = vam->input;
15288 vl_api_ipsec_spd_add_del_t *mp;
15293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15295 if (unformat (i, "spd_id %d", &spd_id))
15297 else if (unformat (i, "del"))
15301 clib_warning ("parse error '%U'", format_unformat_error, i);
15307 errmsg ("spd_id must be set");
15311 M (IPSEC_SPD_ADD_DEL, mp);
15313 mp->spd_id = ntohl (spd_id);
15314 mp->is_add = is_add;
15322 api_ipsec_interface_add_del_spd (vat_main_t * vam)
15324 unformat_input_t *i = vam->input;
15325 vl_api_ipsec_interface_add_del_spd_t *mp;
15327 u8 sw_if_index_set = 0;
15328 u32 spd_id = (u32) ~ 0;
15332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15334 if (unformat (i, "del"))
15336 else if (unformat (i, "spd_id %d", &spd_id))
15339 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15340 sw_if_index_set = 1;
15341 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15342 sw_if_index_set = 1;
15345 clib_warning ("parse error '%U'", format_unformat_error, i);
15351 if (spd_id == (u32) ~ 0)
15353 errmsg ("spd_id must be set");
15357 if (sw_if_index_set == 0)
15359 errmsg ("missing interface name or sw_if_index");
15363 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
15365 mp->spd_id = ntohl (spd_id);
15366 mp->sw_if_index = ntohl (sw_if_index);
15367 mp->is_add = is_add;
15375 api_ipsec_spd_add_del_entry (vat_main_t * vam)
15377 unformat_input_t *i = vam->input;
15378 vl_api_ipsec_spd_add_del_entry_t *mp;
15379 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
15380 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
15382 u32 rport_start = 0, rport_stop = (u32) ~ 0;
15383 u32 lport_start = 0, lport_stop = (u32) ~ 0;
15384 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
15385 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
15388 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
15389 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
15390 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
15391 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
15392 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
15393 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
15395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15397 if (unformat (i, "del"))
15399 if (unformat (i, "outbound"))
15401 if (unformat (i, "inbound"))
15403 else if (unformat (i, "spd_id %d", &spd_id))
15405 else if (unformat (i, "sa_id %d", &sa_id))
15407 else if (unformat (i, "priority %d", &priority))
15409 else if (unformat (i, "protocol %d", &protocol))
15411 else if (unformat (i, "lport_start %d", &lport_start))
15413 else if (unformat (i, "lport_stop %d", &lport_stop))
15415 else if (unformat (i, "rport_start %d", &rport_start))
15417 else if (unformat (i, "rport_stop %d", &rport_stop))
15421 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
15427 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
15434 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
15440 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
15447 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
15453 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
15460 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
15466 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
15472 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
15474 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
15476 clib_warning ("unsupported action: 'resolve'");
15482 clib_warning ("parse error '%U'", format_unformat_error, i);
15488 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
15490 mp->spd_id = ntohl (spd_id);
15491 mp->priority = ntohl (priority);
15492 mp->is_outbound = is_outbound;
15494 mp->is_ipv6 = is_ipv6;
15495 if (is_ipv6 || is_ip_any)
15497 clib_memcpy (mp->remote_address_start, &raddr6_start,
15498 sizeof (ip6_address_t));
15499 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
15500 sizeof (ip6_address_t));
15501 clib_memcpy (mp->local_address_start, &laddr6_start,
15502 sizeof (ip6_address_t));
15503 clib_memcpy (mp->local_address_stop, &laddr6_stop,
15504 sizeof (ip6_address_t));
15508 clib_memcpy (mp->remote_address_start, &raddr4_start,
15509 sizeof (ip4_address_t));
15510 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
15511 sizeof (ip4_address_t));
15512 clib_memcpy (mp->local_address_start, &laddr4_start,
15513 sizeof (ip4_address_t));
15514 clib_memcpy (mp->local_address_stop, &laddr4_stop,
15515 sizeof (ip4_address_t));
15517 mp->protocol = (u8) protocol;
15518 mp->local_port_start = ntohs ((u16) lport_start);
15519 mp->local_port_stop = ntohs ((u16) lport_stop);
15520 mp->remote_port_start = ntohs ((u16) rport_start);
15521 mp->remote_port_stop = ntohs ((u16) rport_stop);
15522 mp->policy = (u8) policy;
15523 mp->sa_id = ntohl (sa_id);
15524 mp->is_add = is_add;
15525 mp->is_ip_any = is_ip_any;
15532 api_ipsec_sad_add_del_entry (vat_main_t * vam)
15534 unformat_input_t *i = vam->input;
15535 vl_api_ipsec_sad_add_del_entry_t *mp;
15536 u32 sad_id = 0, spi = 0;
15537 u8 *ck = 0, *ik = 0;
15540 u8 protocol = IPSEC_PROTOCOL_AH;
15541 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
15542 u32 crypto_alg = 0, integ_alg = 0;
15543 ip4_address_t tun_src4;
15544 ip4_address_t tun_dst4;
15545 ip6_address_t tun_src6;
15546 ip6_address_t tun_dst6;
15549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15551 if (unformat (i, "del"))
15553 else if (unformat (i, "sad_id %d", &sad_id))
15555 else if (unformat (i, "spi %d", &spi))
15557 else if (unformat (i, "esp"))
15558 protocol = IPSEC_PROTOCOL_ESP;
15559 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
15562 is_tunnel_ipv6 = 0;
15564 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
15567 is_tunnel_ipv6 = 0;
15569 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
15572 is_tunnel_ipv6 = 1;
15574 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
15577 is_tunnel_ipv6 = 1;
15581 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15583 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15585 clib_warning ("unsupported crypto-alg: '%U'",
15586 format_ipsec_crypto_alg, crypto_alg);
15590 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15594 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15596 if (integ_alg >= IPSEC_INTEG_N_ALG)
15598 clib_warning ("unsupported integ-alg: '%U'",
15599 format_ipsec_integ_alg, integ_alg);
15603 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15607 clib_warning ("parse error '%U'", format_unformat_error, i);
15613 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
15615 mp->sad_id = ntohl (sad_id);
15616 mp->is_add = is_add;
15617 mp->protocol = protocol;
15618 mp->spi = ntohl (spi);
15619 mp->is_tunnel = is_tunnel;
15620 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
15621 mp->crypto_algorithm = crypto_alg;
15622 mp->integrity_algorithm = integ_alg;
15623 mp->crypto_key_length = vec_len (ck);
15624 mp->integrity_key_length = vec_len (ik);
15626 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15627 mp->crypto_key_length = sizeof (mp->crypto_key);
15629 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15630 mp->integrity_key_length = sizeof (mp->integrity_key);
15633 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15635 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15639 if (is_tunnel_ipv6)
15641 clib_memcpy (mp->tunnel_src_address, &tun_src6,
15642 sizeof (ip6_address_t));
15643 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
15644 sizeof (ip6_address_t));
15648 clib_memcpy (mp->tunnel_src_address, &tun_src4,
15649 sizeof (ip4_address_t));
15650 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
15651 sizeof (ip4_address_t));
15661 api_ipsec_sa_set_key (vat_main_t * vam)
15663 unformat_input_t *i = vam->input;
15664 vl_api_ipsec_sa_set_key_t *mp;
15666 u8 *ck = 0, *ik = 0;
15669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15671 if (unformat (i, "sa_id %d", &sa_id))
15673 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15675 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15679 clib_warning ("parse error '%U'", format_unformat_error, i);
15684 M (IPSEC_SA_SET_KEY, mp);
15686 mp->sa_id = ntohl (sa_id);
15687 mp->crypto_key_length = vec_len (ck);
15688 mp->integrity_key_length = vec_len (ik);
15690 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15691 mp->crypto_key_length = sizeof (mp->crypto_key);
15693 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15694 mp->integrity_key_length = sizeof (mp->integrity_key);
15697 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15699 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15707 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
15709 unformat_input_t *i = vam->input;
15710 vl_api_ipsec_tunnel_if_add_del_t *mp;
15711 u32 local_spi = 0, remote_spi = 0;
15712 u32 crypto_alg = 0, integ_alg = 0;
15713 u8 *lck = NULL, *rck = NULL;
15714 u8 *lik = NULL, *rik = NULL;
15715 ip4_address_t local_ip = { {0} };
15716 ip4_address_t remote_ip = { {0} };
15719 u8 anti_replay = 0;
15724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15726 if (unformat (i, "del"))
15728 else if (unformat (i, "esn"))
15730 else if (unformat (i, "anti_replay"))
15732 else if (unformat (i, "local_spi %d", &local_spi))
15734 else if (unformat (i, "remote_spi %d", &remote_spi))
15736 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
15738 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
15740 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
15743 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
15745 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15747 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15751 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15753 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15755 errmsg ("unsupported crypto-alg: '%U'\n",
15756 format_ipsec_crypto_alg, crypto_alg);
15762 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15764 if (integ_alg >= IPSEC_INTEG_N_ALG)
15766 errmsg ("unsupported integ-alg: '%U'\n",
15767 format_ipsec_integ_alg, integ_alg);
15771 else if (unformat (i, "instance %u", &instance))
15775 errmsg ("parse error '%U'\n", format_unformat_error, i);
15780 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15782 mp->is_add = is_add;
15784 mp->anti_replay = anti_replay;
15786 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
15787 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
15789 mp->local_spi = htonl (local_spi);
15790 mp->remote_spi = htonl (remote_spi);
15791 mp->crypto_alg = (u8) crypto_alg;
15793 mp->local_crypto_key_len = 0;
15796 mp->local_crypto_key_len = vec_len (lck);
15797 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15798 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15799 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15802 mp->remote_crypto_key_len = 0;
15805 mp->remote_crypto_key_len = vec_len (rck);
15806 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15807 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15808 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15811 mp->integ_alg = (u8) integ_alg;
15813 mp->local_integ_key_len = 0;
15816 mp->local_integ_key_len = vec_len (lik);
15817 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15818 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15819 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15822 mp->remote_integ_key_len = 0;
15825 mp->remote_integ_key_len = vec_len (rik);
15826 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15827 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15828 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15833 mp->renumber = renumber;
15834 mp->show_instance = ntohl (instance);
15843 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15845 vat_main_t *vam = &vat_main;
15847 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15848 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
15849 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
15850 "tunnel_src_addr %U tunnel_dst_addr %U "
15851 "salt %u seq_outbound %lu last_seq_inbound %lu "
15852 "replay_window %lu total_data_size %lu\n",
15853 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
15855 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
15856 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
15857 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
15858 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15859 mp->tunnel_src_addr,
15860 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15861 mp->tunnel_dst_addr,
15863 clib_net_to_host_u64 (mp->seq_outbound),
15864 clib_net_to_host_u64 (mp->last_seq_inbound),
15865 clib_net_to_host_u64 (mp->replay_window),
15866 clib_net_to_host_u64 (mp->total_data_size));
15869 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15870 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15872 static void vl_api_ipsec_sa_details_t_handler_json
15873 (vl_api_ipsec_sa_details_t * mp)
15875 vat_main_t *vam = &vat_main;
15876 vat_json_node_t *node = NULL;
15877 struct in_addr src_ip4, dst_ip4;
15878 struct in6_addr src_ip6, dst_ip6;
15880 if (VAT_JSON_ARRAY != vam->json_tree.type)
15882 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15883 vat_json_init_array (&vam->json_tree);
15885 node = vat_json_array_add (&vam->json_tree);
15887 vat_json_init_object (node);
15888 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
15889 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15890 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
15891 vat_json_object_add_uint (node, "proto", mp->protocol);
15892 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
15893 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
15894 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
15895 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
15896 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
15897 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
15898 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
15899 mp->crypto_key_len);
15900 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
15901 mp->integ_key_len);
15902 if (mp->is_tunnel_ip6)
15904 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
15905 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
15906 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
15907 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
15911 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
15912 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
15913 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
15914 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
15916 vat_json_object_add_uint (node, "replay_window",
15917 clib_net_to_host_u64 (mp->replay_window));
15918 vat_json_object_add_uint (node, "total_data_size",
15919 clib_net_to_host_u64 (mp->total_data_size));
15924 api_ipsec_sa_dump (vat_main_t * vam)
15926 unformat_input_t *i = vam->input;
15927 vl_api_ipsec_sa_dump_t *mp;
15928 vl_api_control_ping_t *mp_ping;
15932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15934 if (unformat (i, "sa_id %d", &sa_id))
15938 clib_warning ("parse error '%U'", format_unformat_error, i);
15943 M (IPSEC_SA_DUMP, mp);
15945 mp->sa_id = ntohl (sa_id);
15949 /* Use a control ping for synchronization */
15950 M (CONTROL_PING, mp_ping);
15958 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15960 unformat_input_t *i = vam->input;
15961 vl_api_ipsec_tunnel_if_set_key_t *mp;
15962 u32 sw_if_index = ~0;
15963 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15970 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15973 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
15974 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15976 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
15977 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15978 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
15979 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15981 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
15982 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15983 else if (unformat (i, "%U", unformat_hex_string, &key))
15987 clib_warning ("parse error '%U'", format_unformat_error, i);
15992 if (sw_if_index == ~0)
15994 errmsg ("interface must be specified");
15998 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
16000 errmsg ("key type must be specified");
16006 errmsg ("algorithm must be specified");
16010 if (vec_len (key) == 0)
16012 errmsg ("key must be specified");
16016 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
16018 mp->sw_if_index = htonl (sw_if_index);
16020 mp->key_type = key_type;
16021 mp->key_len = vec_len (key);
16022 clib_memcpy (mp->key, key, vec_len (key));
16031 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
16033 unformat_input_t *i = vam->input;
16034 vl_api_ipsec_tunnel_if_set_sa_t *mp;
16035 u32 sw_if_index = ~0;
16037 u8 is_outbound = (u8) ~ 0;
16040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16044 else if (unformat (i, "sa_id %d", &sa_id))
16046 else if (unformat (i, "outbound"))
16048 else if (unformat (i, "inbound"))
16052 clib_warning ("parse error '%U'", format_unformat_error, i);
16057 if (sw_if_index == ~0)
16059 errmsg ("interface must be specified");
16065 errmsg ("SA ID must be specified");
16069 M (IPSEC_TUNNEL_IF_SET_SA, mp);
16071 mp->sw_if_index = htonl (sw_if_index);
16072 mp->sa_id = htonl (sa_id);
16073 mp->is_outbound = is_outbound;
16082 api_ikev2_profile_add_del (vat_main_t * vam)
16084 unformat_input_t *i = vam->input;
16085 vl_api_ikev2_profile_add_del_t *mp;
16090 const char *valid_chars = "a-zA-Z0-9_";
16092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16094 if (unformat (i, "del"))
16096 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
16097 vec_add1 (name, 0);
16100 errmsg ("parse error '%U'", format_unformat_error, i);
16105 if (!vec_len (name))
16107 errmsg ("profile name must be specified");
16111 if (vec_len (name) > 64)
16113 errmsg ("profile name too long");
16117 M (IKEV2_PROFILE_ADD_DEL, mp);
16119 clib_memcpy (mp->name, name, vec_len (name));
16120 mp->is_add = is_add;
16129 api_ikev2_profile_set_auth (vat_main_t * vam)
16131 unformat_input_t *i = vam->input;
16132 vl_api_ikev2_profile_set_auth_t *mp;
16135 u32 auth_method = 0;
16139 const char *valid_chars = "a-zA-Z0-9_";
16141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16143 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
16144 vec_add1 (name, 0);
16145 else if (unformat (i, "auth_method %U",
16146 unformat_ikev2_auth_method, &auth_method))
16148 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
16150 else if (unformat (i, "auth_data %v", &data))
16154 errmsg ("parse error '%U'", format_unformat_error, i);
16159 if (!vec_len (name))
16161 errmsg ("profile name must be specified");
16165 if (vec_len (name) > 64)
16167 errmsg ("profile name too long");
16171 if (!vec_len (data))
16173 errmsg ("auth_data must be specified");
16179 errmsg ("auth_method must be specified");
16183 M (IKEV2_PROFILE_SET_AUTH, mp);
16185 mp->is_hex = is_hex;
16186 mp->auth_method = (u8) auth_method;
16187 mp->data_len = vec_len (data);
16188 clib_memcpy (mp->name, name, vec_len (name));
16189 clib_memcpy (mp->data, data, vec_len (data));
16199 api_ikev2_profile_set_id (vat_main_t * vam)
16201 unformat_input_t *i = vam->input;
16202 vl_api_ikev2_profile_set_id_t *mp;
16210 const char *valid_chars = "a-zA-Z0-9_";
16212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16214 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
16215 vec_add1 (name, 0);
16216 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
16218 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
16220 data = vec_new (u8, 4);
16221 clib_memcpy (data, ip4.as_u8, 4);
16223 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
16225 else if (unformat (i, "id_data %v", &data))
16227 else if (unformat (i, "local"))
16229 else if (unformat (i, "remote"))
16233 errmsg ("parse error '%U'", format_unformat_error, i);
16238 if (!vec_len (name))
16240 errmsg ("profile name must be specified");
16244 if (vec_len (name) > 64)
16246 errmsg ("profile name too long");
16250 if (!vec_len (data))
16252 errmsg ("id_data must be specified");
16258 errmsg ("id_type must be specified");
16262 M (IKEV2_PROFILE_SET_ID, mp);
16264 mp->is_local = is_local;
16265 mp->id_type = (u8) id_type;
16266 mp->data_len = vec_len (data);
16267 clib_memcpy (mp->name, name, vec_len (name));
16268 clib_memcpy (mp->data, data, vec_len (data));
16278 api_ikev2_profile_set_ts (vat_main_t * vam)
16280 unformat_input_t *i = vam->input;
16281 vl_api_ikev2_profile_set_ts_t *mp;
16284 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
16285 ip4_address_t start_addr, end_addr;
16287 const char *valid_chars = "a-zA-Z0-9_";
16290 start_addr.as_u32 = 0;
16291 end_addr.as_u32 = (u32) ~ 0;
16293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16295 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
16296 vec_add1 (name, 0);
16297 else if (unformat (i, "protocol %d", &proto))
16299 else if (unformat (i, "start_port %d", &start_port))
16301 else if (unformat (i, "end_port %d", &end_port))
16304 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
16306 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
16308 else if (unformat (i, "local"))
16310 else if (unformat (i, "remote"))
16314 errmsg ("parse error '%U'", format_unformat_error, i);
16319 if (!vec_len (name))
16321 errmsg ("profile name must be specified");
16325 if (vec_len (name) > 64)
16327 errmsg ("profile name too long");
16331 M (IKEV2_PROFILE_SET_TS, mp);
16333 mp->is_local = is_local;
16334 mp->proto = (u8) proto;
16335 mp->start_port = (u16) start_port;
16336 mp->end_port = (u16) end_port;
16337 mp->start_addr = start_addr.as_u32;
16338 mp->end_addr = end_addr.as_u32;
16339 clib_memcpy (mp->name, name, vec_len (name));
16348 api_ikev2_set_local_key (vat_main_t * vam)
16350 unformat_input_t *i = vam->input;
16351 vl_api_ikev2_set_local_key_t *mp;
16355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16357 if (unformat (i, "file %v", &file))
16358 vec_add1 (file, 0);
16361 errmsg ("parse error '%U'", format_unformat_error, i);
16366 if (!vec_len (file))
16368 errmsg ("RSA key file must be specified");
16372 if (vec_len (file) > 256)
16374 errmsg ("file name too long");
16378 M (IKEV2_SET_LOCAL_KEY, mp);
16380 clib_memcpy (mp->key_file, file, vec_len (file));
16389 api_ikev2_set_responder (vat_main_t * vam)
16391 unformat_input_t *i = vam->input;
16392 vl_api_ikev2_set_responder_t *mp;
16395 u32 sw_if_index = ~0;
16396 ip4_address_t address;
16398 const char *valid_chars = "a-zA-Z0-9_";
16400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16403 (i, "%U interface %d address %U", unformat_token, valid_chars,
16404 &name, &sw_if_index, unformat_ip4_address, &address))
16405 vec_add1 (name, 0);
16408 errmsg ("parse error '%U'", format_unformat_error, i);
16413 if (!vec_len (name))
16415 errmsg ("profile name must be specified");
16419 if (vec_len (name) > 64)
16421 errmsg ("profile name too long");
16425 M (IKEV2_SET_RESPONDER, mp);
16427 clib_memcpy (mp->name, name, vec_len (name));
16430 mp->sw_if_index = sw_if_index;
16431 clib_memcpy (mp->address, &address, sizeof (address));
16439 api_ikev2_set_ike_transforms (vat_main_t * vam)
16441 unformat_input_t *i = vam->input;
16442 vl_api_ikev2_set_ike_transforms_t *mp;
16445 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
16447 const char *valid_chars = "a-zA-Z0-9_";
16449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16451 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
16452 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
16453 vec_add1 (name, 0);
16456 errmsg ("parse error '%U'", format_unformat_error, i);
16461 if (!vec_len (name))
16463 errmsg ("profile name must be specified");
16467 if (vec_len (name) > 64)
16469 errmsg ("profile name too long");
16473 M (IKEV2_SET_IKE_TRANSFORMS, mp);
16475 clib_memcpy (mp->name, name, vec_len (name));
16477 mp->crypto_alg = crypto_alg;
16478 mp->crypto_key_size = crypto_key_size;
16479 mp->integ_alg = integ_alg;
16480 mp->dh_group = dh_group;
16489 api_ikev2_set_esp_transforms (vat_main_t * vam)
16491 unformat_input_t *i = vam->input;
16492 vl_api_ikev2_set_esp_transforms_t *mp;
16495 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
16497 const char *valid_chars = "a-zA-Z0-9_";
16499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16501 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
16502 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
16503 vec_add1 (name, 0);
16506 errmsg ("parse error '%U'", format_unformat_error, i);
16511 if (!vec_len (name))
16513 errmsg ("profile name must be specified");
16517 if (vec_len (name) > 64)
16519 errmsg ("profile name too long");
16523 M (IKEV2_SET_ESP_TRANSFORMS, mp);
16525 clib_memcpy (mp->name, name, vec_len (name));
16527 mp->crypto_alg = crypto_alg;
16528 mp->crypto_key_size = crypto_key_size;
16529 mp->integ_alg = integ_alg;
16530 mp->dh_group = dh_group;
16538 api_ikev2_set_sa_lifetime (vat_main_t * vam)
16540 unformat_input_t *i = vam->input;
16541 vl_api_ikev2_set_sa_lifetime_t *mp;
16544 u64 lifetime, lifetime_maxdata;
16545 u32 lifetime_jitter, handover;
16547 const char *valid_chars = "a-zA-Z0-9_";
16549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16551 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
16552 &lifetime, &lifetime_jitter, &handover,
16553 &lifetime_maxdata))
16554 vec_add1 (name, 0);
16557 errmsg ("parse error '%U'", format_unformat_error, i);
16562 if (!vec_len (name))
16564 errmsg ("profile name must be specified");
16568 if (vec_len (name) > 64)
16570 errmsg ("profile name too long");
16574 M (IKEV2_SET_SA_LIFETIME, mp);
16576 clib_memcpy (mp->name, name, vec_len (name));
16578 mp->lifetime = lifetime;
16579 mp->lifetime_jitter = lifetime_jitter;
16580 mp->handover = handover;
16581 mp->lifetime_maxdata = lifetime_maxdata;
16589 api_ikev2_initiate_sa_init (vat_main_t * vam)
16591 unformat_input_t *i = vam->input;
16592 vl_api_ikev2_initiate_sa_init_t *mp;
16596 const char *valid_chars = "a-zA-Z0-9_";
16598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16600 if (unformat (i, "%U", unformat_token, valid_chars, &name))
16601 vec_add1 (name, 0);
16604 errmsg ("parse error '%U'", format_unformat_error, i);
16609 if (!vec_len (name))
16611 errmsg ("profile name must be specified");
16615 if (vec_len (name) > 64)
16617 errmsg ("profile name too long");
16621 M (IKEV2_INITIATE_SA_INIT, mp);
16623 clib_memcpy (mp->name, name, vec_len (name));
16632 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
16634 unformat_input_t *i = vam->input;
16635 vl_api_ikev2_initiate_del_ike_sa_t *mp;
16640 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16642 if (unformat (i, "%lx", &ispi))
16646 errmsg ("parse error '%U'", format_unformat_error, i);
16651 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
16661 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
16663 unformat_input_t *i = vam->input;
16664 vl_api_ikev2_initiate_del_child_sa_t *mp;
16669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16671 if (unformat (i, "%x", &ispi))
16675 errmsg ("parse error '%U'", format_unformat_error, i);
16680 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
16690 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
16692 unformat_input_t *i = vam->input;
16693 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
16698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16700 if (unformat (i, "%x", &ispi))
16704 errmsg ("parse error '%U'", format_unformat_error, i);
16709 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
16719 api_get_first_msg_id (vat_main_t * vam)
16721 vl_api_get_first_msg_id_t *mp;
16722 unformat_input_t *i = vam->input;
16727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16729 if (unformat (i, "client %s", &name))
16737 errmsg ("missing client name");
16740 vec_add1 (name, 0);
16742 if (vec_len (name) > 63)
16744 errmsg ("client name too long");
16748 M (GET_FIRST_MSG_ID, mp);
16749 clib_memcpy (mp->name, name, vec_len (name));
16756 api_cop_interface_enable_disable (vat_main_t * vam)
16758 unformat_input_t *line_input = vam->input;
16759 vl_api_cop_interface_enable_disable_t *mp;
16760 u32 sw_if_index = ~0;
16761 u8 enable_disable = 1;
16764 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16766 if (unformat (line_input, "disable"))
16767 enable_disable = 0;
16768 if (unformat (line_input, "enable"))
16769 enable_disable = 1;
16770 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16771 vam, &sw_if_index))
16773 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16779 if (sw_if_index == ~0)
16781 errmsg ("missing interface name or sw_if_index");
16785 /* Construct the API message */
16786 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16787 mp->sw_if_index = ntohl (sw_if_index);
16788 mp->enable_disable = enable_disable;
16792 /* Wait for the reply */
16798 api_cop_whitelist_enable_disable (vat_main_t * vam)
16800 unformat_input_t *line_input = vam->input;
16801 vl_api_cop_whitelist_enable_disable_t *mp;
16802 u32 sw_if_index = ~0;
16803 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16807 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16809 if (unformat (line_input, "ip4"))
16811 else if (unformat (line_input, "ip6"))
16813 else if (unformat (line_input, "default"))
16815 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16816 vam, &sw_if_index))
16818 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16820 else if (unformat (line_input, "fib-id %d", &fib_id))
16826 if (sw_if_index == ~0)
16828 errmsg ("missing interface name or sw_if_index");
16832 /* Construct the API message */
16833 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16834 mp->sw_if_index = ntohl (sw_if_index);
16835 mp->fib_id = ntohl (fib_id);
16838 mp->default_cop = default_cop;
16842 /* Wait for the reply */
16848 api_get_node_graph (vat_main_t * vam)
16850 vl_api_get_node_graph_t *mp;
16853 M (GET_NODE_GRAPH, mp);
16857 /* Wait for the reply */
16863 /** Used for parsing LISP eids */
16864 typedef CLIB_PACKED(struct{
16865 u8 addr[16]; /**< eid address */
16866 u32 len; /**< prefix length if IP */
16867 u8 type; /**< type of eid */
16872 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16874 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16876 clib_memset (a, 0, sizeof (a[0]));
16878 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16880 a->type = 0; /* ipv4 type */
16882 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16884 a->type = 1; /* ipv6 type */
16886 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16888 a->type = 2; /* mac type */
16890 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16892 a->type = 3; /* NSH type */
16893 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16894 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16901 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16910 lisp_eid_size_vat (u8 type)
16927 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16929 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16933 api_one_add_del_locator_set (vat_main_t * vam)
16935 unformat_input_t *input = vam->input;
16936 vl_api_one_add_del_locator_set_t *mp;
16938 u8 *locator_set_name = NULL;
16939 u8 locator_set_name_set = 0;
16940 vl_api_local_locator_t locator, *locators = 0;
16941 u32 sw_if_index, priority, weight;
16945 /* Parse args required to build the message */
16946 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16948 if (unformat (input, "del"))
16952 else if (unformat (input, "locator-set %s", &locator_set_name))
16954 locator_set_name_set = 1;
16956 else if (unformat (input, "sw_if_index %u p %u w %u",
16957 &sw_if_index, &priority, &weight))
16959 locator.sw_if_index = htonl (sw_if_index);
16960 locator.priority = priority;
16961 locator.weight = weight;
16962 vec_add1 (locators, locator);
16966 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16967 &sw_if_index, &priority, &weight))
16969 locator.sw_if_index = htonl (sw_if_index);
16970 locator.priority = priority;
16971 locator.weight = weight;
16972 vec_add1 (locators, locator);
16978 if (locator_set_name_set == 0)
16980 errmsg ("missing locator-set name");
16981 vec_free (locators);
16985 if (vec_len (locator_set_name) > 64)
16987 errmsg ("locator-set name too long");
16988 vec_free (locator_set_name);
16989 vec_free (locators);
16992 vec_add1 (locator_set_name, 0);
16994 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16996 /* Construct the API message */
16997 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16999 mp->is_add = is_add;
17000 clib_memcpy (mp->locator_set_name, locator_set_name,
17001 vec_len (locator_set_name));
17002 vec_free (locator_set_name);
17004 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
17006 clib_memcpy (mp->locators, locators, data_len);
17007 vec_free (locators);
17012 /* Wait for a reply... */
17017 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
17020 api_one_add_del_locator (vat_main_t * vam)
17022 unformat_input_t *input = vam->input;
17023 vl_api_one_add_del_locator_t *mp;
17024 u32 tmp_if_index = ~0;
17025 u32 sw_if_index = ~0;
17026 u8 sw_if_index_set = 0;
17027 u8 sw_if_index_if_name_set = 0;
17029 u8 priority_set = 0;
17033 u8 *locator_set_name = NULL;
17034 u8 locator_set_name_set = 0;
17037 /* Parse args required to build the message */
17038 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17040 if (unformat (input, "del"))
17044 else if (unformat (input, "locator-set %s", &locator_set_name))
17046 locator_set_name_set = 1;
17048 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
17051 sw_if_index_if_name_set = 1;
17052 sw_if_index = tmp_if_index;
17054 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
17056 sw_if_index_set = 1;
17057 sw_if_index = tmp_if_index;
17059 else if (unformat (input, "p %d", &priority))
17063 else if (unformat (input, "w %d", &weight))
17071 if (locator_set_name_set == 0)
17073 errmsg ("missing locator-set name");
17077 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
17079 errmsg ("missing sw_if_index");
17080 vec_free (locator_set_name);
17084 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
17086 errmsg ("cannot use both params interface name and sw_if_index");
17087 vec_free (locator_set_name);
17091 if (priority_set == 0)
17093 errmsg ("missing locator-set priority");
17094 vec_free (locator_set_name);
17098 if (weight_set == 0)
17100 errmsg ("missing locator-set weight");
17101 vec_free (locator_set_name);
17105 if (vec_len (locator_set_name) > 64)
17107 errmsg ("locator-set name too long");
17108 vec_free (locator_set_name);
17111 vec_add1 (locator_set_name, 0);
17113 /* Construct the API message */
17114 M (ONE_ADD_DEL_LOCATOR, mp);
17116 mp->is_add = is_add;
17117 mp->sw_if_index = ntohl (sw_if_index);
17118 mp->priority = priority;
17119 mp->weight = weight;
17120 clib_memcpy (mp->locator_set_name, locator_set_name,
17121 vec_len (locator_set_name));
17122 vec_free (locator_set_name);
17127 /* Wait for a reply... */
17132 #define api_lisp_add_del_locator api_one_add_del_locator
17135 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
17137 u32 *key_id = va_arg (*args, u32 *);
17140 if (unformat (input, "%s", &s))
17142 if (!strcmp ((char *) s, "sha1"))
17143 key_id[0] = HMAC_SHA_1_96;
17144 else if (!strcmp ((char *) s, "sha256"))
17145 key_id[0] = HMAC_SHA_256_128;
17148 clib_warning ("invalid key_id: '%s'", s);
17149 key_id[0] = HMAC_NO_KEY;
17160 api_one_add_del_local_eid (vat_main_t * vam)
17162 unformat_input_t *input = vam->input;
17163 vl_api_one_add_del_local_eid_t *mp;
17166 lisp_eid_vat_t _eid, *eid = &_eid;
17167 u8 *locator_set_name = 0;
17168 u8 locator_set_name_set = 0;
17174 /* Parse args required to build the message */
17175 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17177 if (unformat (input, "del"))
17181 else if (unformat (input, "vni %d", &vni))
17185 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17189 else if (unformat (input, "locator-set %s", &locator_set_name))
17191 locator_set_name_set = 1;
17193 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
17195 else if (unformat (input, "secret-key %_%v%_", &key))
17201 if (locator_set_name_set == 0)
17203 errmsg ("missing locator-set name");
17209 errmsg ("EID address not set!");
17210 vec_free (locator_set_name);
17214 if (key && (0 == key_id))
17216 errmsg ("invalid key_id!");
17220 if (vec_len (key) > 64)
17222 errmsg ("key too long");
17227 if (vec_len (locator_set_name) > 64)
17229 errmsg ("locator-set name too long");
17230 vec_free (locator_set_name);
17233 vec_add1 (locator_set_name, 0);
17235 /* Construct the API message */
17236 M (ONE_ADD_DEL_LOCAL_EID, mp);
17238 mp->is_add = is_add;
17239 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17240 mp->eid_type = eid->type;
17241 mp->prefix_len = eid->len;
17242 mp->vni = clib_host_to_net_u32 (vni);
17243 mp->key_id = clib_host_to_net_u16 (key_id);
17244 clib_memcpy (mp->locator_set_name, locator_set_name,
17245 vec_len (locator_set_name));
17246 clib_memcpy (mp->key, key, vec_len (key));
17248 vec_free (locator_set_name);
17254 /* Wait for a reply... */
17259 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
17262 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
17264 u32 dp_table = 0, vni = 0;;
17265 unformat_input_t *input = vam->input;
17266 vl_api_gpe_add_del_fwd_entry_t *mp;
17268 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
17269 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
17270 u8 rmt_eid_set = 0, lcl_eid_set = 0;
17271 u32 action = ~0, w;
17272 ip4_address_t rmt_rloc4, lcl_rloc4;
17273 ip6_address_t rmt_rloc6, lcl_rloc6;
17274 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
17277 clib_memset (&rloc, 0, sizeof (rloc));
17279 /* Parse args required to build the message */
17280 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17282 if (unformat (input, "del"))
17284 else if (unformat (input, "add"))
17286 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
17290 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
17294 else if (unformat (input, "vrf %d", &dp_table))
17296 else if (unformat (input, "bd %d", &dp_table))
17298 else if (unformat (input, "vni %d", &vni))
17300 else if (unformat (input, "w %d", &w))
17304 errmsg ("No RLOC configured for setting priority/weight!");
17307 curr_rloc->weight = w;
17309 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
17310 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
17314 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
17316 vec_add1 (lcl_locs, rloc);
17318 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
17319 vec_add1 (rmt_locs, rloc);
17320 /* weight saved in rmt loc */
17321 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
17323 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
17324 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
17327 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
17329 vec_add1 (lcl_locs, rloc);
17331 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
17332 vec_add1 (rmt_locs, rloc);
17333 /* weight saved in rmt loc */
17334 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
17336 else if (unformat (input, "action %d", &action))
17342 clib_warning ("parse error '%U'", format_unformat_error, input);
17349 errmsg ("remote eid addresses not set");
17353 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
17355 errmsg ("eid types don't match");
17359 if (0 == rmt_locs && (u32) ~ 0 == action)
17361 errmsg ("action not set for negative mapping");
17365 /* Construct the API message */
17366 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
17367 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
17369 mp->is_add = is_add;
17370 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
17371 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
17372 mp->eid_type = rmt_eid->type;
17373 mp->dp_table = clib_host_to_net_u32 (dp_table);
17374 mp->vni = clib_host_to_net_u32 (vni);
17375 mp->rmt_len = rmt_eid->len;
17376 mp->lcl_len = lcl_eid->len;
17377 mp->action = action;
17379 if (0 != rmt_locs && 0 != lcl_locs)
17381 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
17382 clib_memcpy (mp->locs, lcl_locs,
17383 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
17385 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
17386 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
17387 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
17389 vec_free (lcl_locs);
17390 vec_free (rmt_locs);
17395 /* Wait for a reply... */
17401 api_one_add_del_map_server (vat_main_t * vam)
17403 unformat_input_t *input = vam->input;
17404 vl_api_one_add_del_map_server_t *mp;
17408 ip4_address_t ipv4;
17409 ip6_address_t ipv6;
17412 /* Parse args required to build the message */
17413 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17415 if (unformat (input, "del"))
17419 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
17423 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
17431 if (ipv4_set && ipv6_set)
17433 errmsg ("both eid v4 and v6 addresses set");
17437 if (!ipv4_set && !ipv6_set)
17439 errmsg ("eid addresses not set");
17443 /* Construct the API message */
17444 M (ONE_ADD_DEL_MAP_SERVER, mp);
17446 mp->is_add = is_add;
17450 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
17455 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
17461 /* Wait for a reply... */
17466 #define api_lisp_add_del_map_server api_one_add_del_map_server
17469 api_one_add_del_map_resolver (vat_main_t * vam)
17471 unformat_input_t *input = vam->input;
17472 vl_api_one_add_del_map_resolver_t *mp;
17476 ip4_address_t ipv4;
17477 ip6_address_t ipv6;
17480 /* Parse args required to build the message */
17481 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17483 if (unformat (input, "del"))
17487 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
17491 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
17499 if (ipv4_set && ipv6_set)
17501 errmsg ("both eid v4 and v6 addresses set");
17505 if (!ipv4_set && !ipv6_set)
17507 errmsg ("eid addresses not set");
17511 /* Construct the API message */
17512 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
17514 mp->is_add = is_add;
17518 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
17523 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
17529 /* Wait for a reply... */
17534 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
17537 api_lisp_gpe_enable_disable (vat_main_t * vam)
17539 unformat_input_t *input = vam->input;
17540 vl_api_gpe_enable_disable_t *mp;
17545 /* Parse args required to build the message */
17546 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17548 if (unformat (input, "enable"))
17553 else if (unformat (input, "disable"))
17564 errmsg ("Value not set");
17568 /* Construct the API message */
17569 M (GPE_ENABLE_DISABLE, mp);
17576 /* Wait for a reply... */
17582 api_one_rloc_probe_enable_disable (vat_main_t * vam)
17584 unformat_input_t *input = vam->input;
17585 vl_api_one_rloc_probe_enable_disable_t *mp;
17590 /* Parse args required to build the message */
17591 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17593 if (unformat (input, "enable"))
17598 else if (unformat (input, "disable"))
17606 errmsg ("Value not set");
17610 /* Construct the API message */
17611 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
17613 mp->is_enabled = is_en;
17618 /* Wait for a reply... */
17623 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
17626 api_one_map_register_enable_disable (vat_main_t * vam)
17628 unformat_input_t *input = vam->input;
17629 vl_api_one_map_register_enable_disable_t *mp;
17634 /* Parse args required to build the message */
17635 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17637 if (unformat (input, "enable"))
17642 else if (unformat (input, "disable"))
17650 errmsg ("Value not set");
17654 /* Construct the API message */
17655 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
17657 mp->is_enabled = is_en;
17662 /* Wait for a reply... */
17667 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
17670 api_one_enable_disable (vat_main_t * vam)
17672 unformat_input_t *input = vam->input;
17673 vl_api_one_enable_disable_t *mp;
17678 /* Parse args required to build the message */
17679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17681 if (unformat (input, "enable"))
17686 else if (unformat (input, "disable"))
17696 errmsg ("Value not set");
17700 /* Construct the API message */
17701 M (ONE_ENABLE_DISABLE, mp);
17708 /* Wait for a reply... */
17713 #define api_lisp_enable_disable api_one_enable_disable
17716 api_one_enable_disable_xtr_mode (vat_main_t * vam)
17718 unformat_input_t *input = vam->input;
17719 vl_api_one_enable_disable_xtr_mode_t *mp;
17724 /* Parse args required to build the message */
17725 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17727 if (unformat (input, "enable"))
17732 else if (unformat (input, "disable"))
17742 errmsg ("Value not set");
17746 /* Construct the API message */
17747 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
17754 /* Wait for a reply... */
17760 api_one_show_xtr_mode (vat_main_t * vam)
17762 vl_api_one_show_xtr_mode_t *mp;
17765 /* Construct the API message */
17766 M (ONE_SHOW_XTR_MODE, mp);
17771 /* Wait for a reply... */
17777 api_one_enable_disable_pitr_mode (vat_main_t * vam)
17779 unformat_input_t *input = vam->input;
17780 vl_api_one_enable_disable_pitr_mode_t *mp;
17785 /* Parse args required to build the message */
17786 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17788 if (unformat (input, "enable"))
17793 else if (unformat (input, "disable"))
17803 errmsg ("Value not set");
17807 /* Construct the API message */
17808 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17815 /* Wait for a reply... */
17821 api_one_show_pitr_mode (vat_main_t * vam)
17823 vl_api_one_show_pitr_mode_t *mp;
17826 /* Construct the API message */
17827 M (ONE_SHOW_PITR_MODE, mp);
17832 /* Wait for a reply... */
17838 api_one_enable_disable_petr_mode (vat_main_t * vam)
17840 unformat_input_t *input = vam->input;
17841 vl_api_one_enable_disable_petr_mode_t *mp;
17846 /* Parse args required to build the message */
17847 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17849 if (unformat (input, "enable"))
17854 else if (unformat (input, "disable"))
17864 errmsg ("Value not set");
17868 /* Construct the API message */
17869 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17876 /* Wait for a reply... */
17882 api_one_show_petr_mode (vat_main_t * vam)
17884 vl_api_one_show_petr_mode_t *mp;
17887 /* Construct the API message */
17888 M (ONE_SHOW_PETR_MODE, mp);
17893 /* Wait for a reply... */
17899 api_show_one_map_register_state (vat_main_t * vam)
17901 vl_api_show_one_map_register_state_t *mp;
17904 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17909 /* wait for reply */
17914 #define api_show_lisp_map_register_state api_show_one_map_register_state
17917 api_show_one_rloc_probe_state (vat_main_t * vam)
17919 vl_api_show_one_rloc_probe_state_t *mp;
17922 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17927 /* wait for reply */
17932 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17935 api_one_add_del_ndp_entry (vat_main_t * vam)
17937 vl_api_one_add_del_ndp_entry_t *mp;
17938 unformat_input_t *input = vam->input;
17943 u8 mac[6] = { 0, };
17944 u8 ip6[16] = { 0, };
17948 /* Parse args required to build the message */
17949 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17951 if (unformat (input, "del"))
17953 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17955 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17957 else if (unformat (input, "bd %d", &bd))
17961 errmsg ("parse error '%U'", format_unformat_error, input);
17966 if (!bd_set || !ip_set || (!mac_set && is_add))
17968 errmsg ("Missing BD, IP or MAC!");
17972 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17973 mp->is_add = is_add;
17974 clib_memcpy (mp->mac, mac, 6);
17975 mp->bd = clib_host_to_net_u32 (bd);
17976 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17981 /* wait for reply */
17987 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17989 vl_api_one_add_del_l2_arp_entry_t *mp;
17990 unformat_input_t *input = vam->input;
17995 u8 mac[6] = { 0, };
17996 u32 ip4 = 0, bd = ~0;
17999 /* Parse args required to build the message */
18000 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18002 if (unformat (input, "del"))
18004 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
18006 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
18008 else if (unformat (input, "bd %d", &bd))
18012 errmsg ("parse error '%U'", format_unformat_error, input);
18017 if (!bd_set || !ip_set || (!mac_set && is_add))
18019 errmsg ("Missing BD, IP or MAC!");
18023 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
18024 mp->is_add = is_add;
18025 clib_memcpy (mp->mac, mac, 6);
18026 mp->bd = clib_host_to_net_u32 (bd);
18032 /* wait for reply */
18038 api_one_ndp_bd_get (vat_main_t * vam)
18040 vl_api_one_ndp_bd_get_t *mp;
18043 M (ONE_NDP_BD_GET, mp);
18048 /* wait for reply */
18054 api_one_ndp_entries_get (vat_main_t * vam)
18056 vl_api_one_ndp_entries_get_t *mp;
18057 unformat_input_t *input = vam->input;
18062 /* Parse args required to build the message */
18063 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18065 if (unformat (input, "bd %d", &bd))
18069 errmsg ("parse error '%U'", format_unformat_error, input);
18076 errmsg ("Expected bridge domain!");
18080 M (ONE_NDP_ENTRIES_GET, mp);
18081 mp->bd = clib_host_to_net_u32 (bd);
18086 /* wait for reply */
18092 api_one_l2_arp_bd_get (vat_main_t * vam)
18094 vl_api_one_l2_arp_bd_get_t *mp;
18097 M (ONE_L2_ARP_BD_GET, mp);
18102 /* wait for reply */
18108 api_one_l2_arp_entries_get (vat_main_t * vam)
18110 vl_api_one_l2_arp_entries_get_t *mp;
18111 unformat_input_t *input = vam->input;
18116 /* Parse args required to build the message */
18117 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18119 if (unformat (input, "bd %d", &bd))
18123 errmsg ("parse error '%U'", format_unformat_error, input);
18130 errmsg ("Expected bridge domain!");
18134 M (ONE_L2_ARP_ENTRIES_GET, mp);
18135 mp->bd = clib_host_to_net_u32 (bd);
18140 /* wait for reply */
18146 api_one_stats_enable_disable (vat_main_t * vam)
18148 vl_api_one_stats_enable_disable_t *mp;
18149 unformat_input_t *input = vam->input;
18154 /* Parse args required to build the message */
18155 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18157 if (unformat (input, "enable"))
18162 else if (unformat (input, "disable"))
18172 errmsg ("Value not set");
18176 M (ONE_STATS_ENABLE_DISABLE, mp);
18182 /* wait for reply */
18188 api_show_one_stats_enable_disable (vat_main_t * vam)
18190 vl_api_show_one_stats_enable_disable_t *mp;
18193 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
18198 /* wait for reply */
18204 api_show_one_map_request_mode (vat_main_t * vam)
18206 vl_api_show_one_map_request_mode_t *mp;
18209 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
18214 /* wait for reply */
18219 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
18222 api_one_map_request_mode (vat_main_t * vam)
18224 unformat_input_t *input = vam->input;
18225 vl_api_one_map_request_mode_t *mp;
18229 /* Parse args required to build the message */
18230 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18232 if (unformat (input, "dst-only"))
18234 else if (unformat (input, "src-dst"))
18238 errmsg ("parse error '%U'", format_unformat_error, input);
18243 M (ONE_MAP_REQUEST_MODE, mp);
18250 /* wait for reply */
18255 #define api_lisp_map_request_mode api_one_map_request_mode
18258 * Enable/disable ONE proxy ITR.
18260 * @param vam vpp API test context
18261 * @return return code
18264 api_one_pitr_set_locator_set (vat_main_t * vam)
18266 u8 ls_name_set = 0;
18267 unformat_input_t *input = vam->input;
18268 vl_api_one_pitr_set_locator_set_t *mp;
18273 /* Parse args required to build the message */
18274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18276 if (unformat (input, "del"))
18278 else if (unformat (input, "locator-set %s", &ls_name))
18282 errmsg ("parse error '%U'", format_unformat_error, input);
18289 errmsg ("locator-set name not set!");
18293 M (ONE_PITR_SET_LOCATOR_SET, mp);
18295 mp->is_add = is_add;
18296 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
18297 vec_free (ls_name);
18302 /* wait for reply */
18307 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
18310 api_one_nsh_set_locator_set (vat_main_t * vam)
18312 u8 ls_name_set = 0;
18313 unformat_input_t *input = vam->input;
18314 vl_api_one_nsh_set_locator_set_t *mp;
18319 /* Parse args required to build the message */
18320 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18322 if (unformat (input, "del"))
18324 else if (unformat (input, "ls %s", &ls_name))
18328 errmsg ("parse error '%U'", format_unformat_error, input);
18333 if (!ls_name_set && is_add)
18335 errmsg ("locator-set name not set!");
18339 M (ONE_NSH_SET_LOCATOR_SET, mp);
18341 mp->is_add = is_add;
18342 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
18343 vec_free (ls_name);
18348 /* wait for reply */
18354 api_show_one_pitr (vat_main_t * vam)
18356 vl_api_show_one_pitr_t *mp;
18359 if (!vam->json_output)
18361 print (vam->ofp, "%=20s", "lisp status:");
18364 M (SHOW_ONE_PITR, mp);
18368 /* Wait for a reply... */
18373 #define api_show_lisp_pitr api_show_one_pitr
18376 api_one_use_petr (vat_main_t * vam)
18378 unformat_input_t *input = vam->input;
18379 vl_api_one_use_petr_t *mp;
18384 clib_memset (&ip, 0, sizeof (ip));
18386 /* Parse args required to build the message */
18387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18389 if (unformat (input, "disable"))
18392 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
18395 ip_addr_version (&ip) = IP4;
18398 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
18401 ip_addr_version (&ip) = IP6;
18405 errmsg ("parse error '%U'", format_unformat_error, input);
18410 M (ONE_USE_PETR, mp);
18412 mp->is_add = is_add;
18415 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
18417 clib_memcpy (mp->address, &ip, 4);
18419 clib_memcpy (mp->address, &ip, 16);
18425 /* wait for reply */
18430 #define api_lisp_use_petr api_one_use_petr
18433 api_show_one_nsh_mapping (vat_main_t * vam)
18435 vl_api_show_one_use_petr_t *mp;
18438 if (!vam->json_output)
18440 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
18443 M (SHOW_ONE_NSH_MAPPING, mp);
18447 /* Wait for a reply... */
18453 api_show_one_use_petr (vat_main_t * vam)
18455 vl_api_show_one_use_petr_t *mp;
18458 if (!vam->json_output)
18460 print (vam->ofp, "%=20s", "Proxy-ETR status:");
18463 M (SHOW_ONE_USE_PETR, mp);
18467 /* Wait for a reply... */
18472 #define api_show_lisp_use_petr api_show_one_use_petr
18475 * Add/delete mapping between vni and vrf
18478 api_one_eid_table_add_del_map (vat_main_t * vam)
18480 unformat_input_t *input = vam->input;
18481 vl_api_one_eid_table_add_del_map_t *mp;
18482 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
18483 u32 vni, vrf, bd_index;
18486 /* Parse args required to build the message */
18487 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18489 if (unformat (input, "del"))
18491 else if (unformat (input, "vrf %d", &vrf))
18493 else if (unformat (input, "bd_index %d", &bd_index))
18495 else if (unformat (input, "vni %d", &vni))
18501 if (!vni_set || (!vrf_set && !bd_index_set))
18503 errmsg ("missing arguments!");
18507 if (vrf_set && bd_index_set)
18509 errmsg ("error: both vrf and bd entered!");
18513 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
18515 mp->is_add = is_add;
18516 mp->vni = htonl (vni);
18517 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
18518 mp->is_l2 = bd_index_set;
18523 /* wait for reply */
18528 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
18531 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
18533 u32 *action = va_arg (*args, u32 *);
18536 if (unformat (input, "%s", &s))
18538 if (!strcmp ((char *) s, "no-action"))
18540 else if (!strcmp ((char *) s, "natively-forward"))
18542 else if (!strcmp ((char *) s, "send-map-request"))
18544 else if (!strcmp ((char *) s, "drop"))
18548 clib_warning ("invalid action: '%s'", s);
18560 * Add/del remote mapping to/from ONE control plane
18562 * @param vam vpp API test context
18563 * @return return code
18566 api_one_add_del_remote_mapping (vat_main_t * vam)
18568 unformat_input_t *input = vam->input;
18569 vl_api_one_add_del_remote_mapping_t *mp;
18571 lisp_eid_vat_t _eid, *eid = &_eid;
18572 lisp_eid_vat_t _seid, *seid = &_seid;
18573 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
18574 u32 action = ~0, p, w, data_len;
18575 ip4_address_t rloc4;
18576 ip6_address_t rloc6;
18577 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
18580 clib_memset (&rloc, 0, sizeof (rloc));
18582 /* Parse args required to build the message */
18583 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18585 if (unformat (input, "del-all"))
18589 else if (unformat (input, "del"))
18593 else if (unformat (input, "add"))
18597 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
18601 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
18605 else if (unformat (input, "vni %d", &vni))
18609 else if (unformat (input, "p %d w %d", &p, &w))
18613 errmsg ("No RLOC configured for setting priority/weight!");
18616 curr_rloc->priority = p;
18617 curr_rloc->weight = w;
18619 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
18622 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
18623 vec_add1 (rlocs, rloc);
18624 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18626 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
18629 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
18630 vec_add1 (rlocs, rloc);
18631 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18633 else if (unformat (input, "action %U",
18634 unformat_negative_mapping_action, &action))
18640 clib_warning ("parse error '%U'", format_unformat_error, input);
18647 errmsg ("missing params!");
18651 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
18653 errmsg ("no action set for negative map-reply!");
18657 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
18659 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
18660 mp->is_add = is_add;
18661 mp->vni = htonl (vni);
18662 mp->action = (u8) action;
18663 mp->is_src_dst = seid_set;
18664 mp->eid_len = eid->len;
18665 mp->seid_len = seid->len;
18666 mp->del_all = del_all;
18667 mp->eid_type = eid->type;
18668 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
18669 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
18671 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
18672 clib_memcpy (mp->rlocs, rlocs, data_len);
18678 /* Wait for a reply... */
18683 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
18686 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
18687 * forwarding entries in data-plane accordingly.
18689 * @param vam vpp API test context
18690 * @return return code
18693 api_one_add_del_adjacency (vat_main_t * vam)
18695 unformat_input_t *input = vam->input;
18696 vl_api_one_add_del_adjacency_t *mp;
18698 ip4_address_t leid4, reid4;
18699 ip6_address_t leid6, reid6;
18700 u8 reid_mac[6] = { 0 };
18701 u8 leid_mac[6] = { 0 };
18702 u8 reid_type, leid_type;
18703 u32 leid_len = 0, reid_len = 0, len;
18707 leid_type = reid_type = (u8) ~ 0;
18709 /* Parse args required to build the message */
18710 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18712 if (unformat (input, "del"))
18716 else if (unformat (input, "add"))
18720 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
18723 reid_type = 0; /* ipv4 */
18726 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
18729 reid_type = 1; /* ipv6 */
18732 else if (unformat (input, "reid %U", unformat_ethernet_address,
18735 reid_type = 2; /* mac */
18737 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
18740 leid_type = 0; /* ipv4 */
18743 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
18746 leid_type = 1; /* ipv6 */
18749 else if (unformat (input, "leid %U", unformat_ethernet_address,
18752 leid_type = 2; /* mac */
18754 else if (unformat (input, "vni %d", &vni))
18760 errmsg ("parse error '%U'", format_unformat_error, input);
18765 if ((u8) ~ 0 == reid_type)
18767 errmsg ("missing params!");
18771 if (leid_type != reid_type)
18773 errmsg ("remote and local EIDs are of different types!");
18777 M (ONE_ADD_DEL_ADJACENCY, mp);
18778 mp->is_add = is_add;
18779 mp->vni = htonl (vni);
18780 mp->leid_len = leid_len;
18781 mp->reid_len = reid_len;
18782 mp->eid_type = reid_type;
18784 switch (mp->eid_type)
18787 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18788 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18791 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18792 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18795 clib_memcpy (mp->leid, leid_mac, 6);
18796 clib_memcpy (mp->reid, reid_mac, 6);
18799 errmsg ("unknown EID type %d!", mp->eid_type);
18806 /* Wait for a reply... */
18811 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18814 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18816 u32 *mode = va_arg (*args, u32 *);
18818 if (unformat (input, "lisp"))
18820 else if (unformat (input, "vxlan"))
18829 api_gpe_get_encap_mode (vat_main_t * vam)
18831 vl_api_gpe_get_encap_mode_t *mp;
18834 /* Construct the API message */
18835 M (GPE_GET_ENCAP_MODE, mp);
18840 /* Wait for a reply... */
18846 api_gpe_set_encap_mode (vat_main_t * vam)
18848 unformat_input_t *input = vam->input;
18849 vl_api_gpe_set_encap_mode_t *mp;
18853 /* Parse args required to build the message */
18854 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18856 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18862 /* Construct the API message */
18863 M (GPE_SET_ENCAP_MODE, mp);
18870 /* Wait for a reply... */
18876 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18878 unformat_input_t *input = vam->input;
18879 vl_api_gpe_add_del_iface_t *mp;
18880 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18881 u32 dp_table = 0, vni = 0;
18884 /* Parse args required to build the message */
18885 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18887 if (unformat (input, "up"))
18892 else if (unformat (input, "down"))
18897 else if (unformat (input, "table_id %d", &dp_table))
18901 else if (unformat (input, "bd_id %d", &dp_table))
18906 else if (unformat (input, "vni %d", &vni))
18914 if (action_set == 0)
18916 errmsg ("Action not set");
18919 if (dp_table_set == 0 || vni_set == 0)
18921 errmsg ("vni and dp_table must be set");
18925 /* Construct the API message */
18926 M (GPE_ADD_DEL_IFACE, mp);
18928 mp->is_add = is_add;
18929 mp->dp_table = clib_host_to_net_u32 (dp_table);
18931 mp->vni = clib_host_to_net_u32 (vni);
18936 /* Wait for a reply... */
18942 api_one_map_register_fallback_threshold (vat_main_t * vam)
18944 unformat_input_t *input = vam->input;
18945 vl_api_one_map_register_fallback_threshold_t *mp;
18950 /* Parse args required to build the message */
18951 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18953 if (unformat (input, "%u", &value))
18957 clib_warning ("parse error '%U'", format_unformat_error, input);
18964 errmsg ("fallback threshold value is missing!");
18968 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18969 mp->value = clib_host_to_net_u32 (value);
18974 /* Wait for a reply... */
18980 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18982 vl_api_show_one_map_register_fallback_threshold_t *mp;
18985 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18990 /* Wait for a reply... */
18996 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18998 u32 *proto = va_arg (*args, u32 *);
19000 if (unformat (input, "udp"))
19002 else if (unformat (input, "api"))
19011 api_one_set_transport_protocol (vat_main_t * vam)
19013 unformat_input_t *input = vam->input;
19014 vl_api_one_set_transport_protocol_t *mp;
19019 /* Parse args required to build the message */
19020 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19022 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
19026 clib_warning ("parse error '%U'", format_unformat_error, input);
19033 errmsg ("Transport protocol missing!");
19037 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
19038 mp->protocol = (u8) protocol;
19043 /* Wait for a reply... */
19049 api_one_get_transport_protocol (vat_main_t * vam)
19051 vl_api_one_get_transport_protocol_t *mp;
19054 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
19059 /* Wait for a reply... */
19065 api_one_map_register_set_ttl (vat_main_t * vam)
19067 unformat_input_t *input = vam->input;
19068 vl_api_one_map_register_set_ttl_t *mp;
19073 /* Parse args required to build the message */
19074 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19076 if (unformat (input, "%u", &ttl))
19080 clib_warning ("parse error '%U'", format_unformat_error, input);
19087 errmsg ("TTL value missing!");
19091 M (ONE_MAP_REGISTER_SET_TTL, mp);
19092 mp->ttl = clib_host_to_net_u32 (ttl);
19097 /* Wait for a reply... */
19103 api_show_one_map_register_ttl (vat_main_t * vam)
19105 vl_api_show_one_map_register_ttl_t *mp;
19108 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
19113 /* Wait for a reply... */
19119 * Add/del map request itr rlocs from ONE control plane and updates
19121 * @param vam vpp API test context
19122 * @return return code
19125 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
19127 unformat_input_t *input = vam->input;
19128 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
19129 u8 *locator_set_name = 0;
19130 u8 locator_set_name_set = 0;
19134 /* Parse args required to build the message */
19135 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19137 if (unformat (input, "del"))
19141 else if (unformat (input, "%_%v%_", &locator_set_name))
19143 locator_set_name_set = 1;
19147 clib_warning ("parse error '%U'", format_unformat_error, input);
19152 if (is_add && !locator_set_name_set)
19154 errmsg ("itr-rloc is not set!");
19158 if (is_add && vec_len (locator_set_name) > 64)
19160 errmsg ("itr-rloc locator-set name too long");
19161 vec_free (locator_set_name);
19165 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
19166 mp->is_add = is_add;
19169 clib_memcpy (mp->locator_set_name, locator_set_name,
19170 vec_len (locator_set_name));
19174 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
19176 vec_free (locator_set_name);
19181 /* Wait for a reply... */
19186 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
19189 api_one_locator_dump (vat_main_t * vam)
19191 unformat_input_t *input = vam->input;
19192 vl_api_one_locator_dump_t *mp;
19193 vl_api_control_ping_t *mp_ping;
19194 u8 is_index_set = 0, is_name_set = 0;
19199 /* Parse args required to build the message */
19200 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19202 if (unformat (input, "ls_name %_%v%_", &ls_name))
19206 else if (unformat (input, "ls_index %d", &ls_index))
19212 errmsg ("parse error '%U'", format_unformat_error, input);
19217 if (!is_index_set && !is_name_set)
19219 errmsg ("error: expected one of index or name!");
19223 if (is_index_set && is_name_set)
19225 errmsg ("error: only one param expected!");
19229 if (vec_len (ls_name) > 62)
19231 errmsg ("error: locator set name too long!");
19235 if (!vam->json_output)
19237 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
19240 M (ONE_LOCATOR_DUMP, mp);
19241 mp->is_index_set = is_index_set;
19244 mp->ls_index = clib_host_to_net_u32 (ls_index);
19247 vec_add1 (ls_name, 0);
19248 strncpy ((char *) mp->ls_name, (char *) ls_name,
19249 sizeof (mp->ls_name) - 1);
19255 /* Use a control ping for synchronization */
19256 MPING (CONTROL_PING, mp_ping);
19259 /* Wait for a reply... */
19264 #define api_lisp_locator_dump api_one_locator_dump
19267 api_one_locator_set_dump (vat_main_t * vam)
19269 vl_api_one_locator_set_dump_t *mp;
19270 vl_api_control_ping_t *mp_ping;
19271 unformat_input_t *input = vam->input;
19275 /* Parse args required to build the message */
19276 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19278 if (unformat (input, "local"))
19282 else if (unformat (input, "remote"))
19288 errmsg ("parse error '%U'", format_unformat_error, input);
19293 if (!vam->json_output)
19295 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
19298 M (ONE_LOCATOR_SET_DUMP, mp);
19300 mp->filter = filter;
19305 /* Use a control ping for synchronization */
19306 MPING (CONTROL_PING, mp_ping);
19309 /* Wait for a reply... */
19314 #define api_lisp_locator_set_dump api_one_locator_set_dump
19317 api_one_eid_table_map_dump (vat_main_t * vam)
19321 unformat_input_t *input = vam->input;
19322 vl_api_one_eid_table_map_dump_t *mp;
19323 vl_api_control_ping_t *mp_ping;
19326 /* Parse args required to build the message */
19327 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19329 if (unformat (input, "l2"))
19334 else if (unformat (input, "l3"))
19341 errmsg ("parse error '%U'", format_unformat_error, input);
19348 errmsg ("expected one of 'l2' or 'l3' parameter!");
19352 if (!vam->json_output)
19354 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
19357 M (ONE_EID_TABLE_MAP_DUMP, mp);
19363 /* Use a control ping for synchronization */
19364 MPING (CONTROL_PING, mp_ping);
19367 /* Wait for a reply... */
19372 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
19375 api_one_eid_table_vni_dump (vat_main_t * vam)
19377 vl_api_one_eid_table_vni_dump_t *mp;
19378 vl_api_control_ping_t *mp_ping;
19381 if (!vam->json_output)
19383 print (vam->ofp, "VNI");
19386 M (ONE_EID_TABLE_VNI_DUMP, mp);
19391 /* Use a control ping for synchronization */
19392 MPING (CONTROL_PING, mp_ping);
19395 /* Wait for a reply... */
19400 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
19403 api_one_eid_table_dump (vat_main_t * vam)
19405 unformat_input_t *i = vam->input;
19406 vl_api_one_eid_table_dump_t *mp;
19407 vl_api_control_ping_t *mp_ping;
19408 struct in_addr ip4;
19409 struct in6_addr ip6;
19411 u8 eid_type = ~0, eid_set = 0;
19412 u32 prefix_length = ~0, t, vni = 0;
19415 lisp_nsh_api_t nsh;
19417 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19419 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
19425 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
19431 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
19436 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
19441 else if (unformat (i, "vni %d", &t))
19445 else if (unformat (i, "local"))
19449 else if (unformat (i, "remote"))
19455 errmsg ("parse error '%U'", format_unformat_error, i);
19460 if (!vam->json_output)
19462 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
19463 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
19466 M (ONE_EID_TABLE_DUMP, mp);
19468 mp->filter = filter;
19472 mp->vni = htonl (vni);
19473 mp->eid_type = eid_type;
19477 mp->prefix_length = prefix_length;
19478 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
19481 mp->prefix_length = prefix_length;
19482 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
19485 clib_memcpy (mp->eid, mac, sizeof (mac));
19488 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
19491 errmsg ("unknown EID type %d!", eid_type);
19499 /* Use a control ping for synchronization */
19500 MPING (CONTROL_PING, mp_ping);
19503 /* Wait for a reply... */
19508 #define api_lisp_eid_table_dump api_one_eid_table_dump
19511 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
19513 unformat_input_t *i = vam->input;
19514 vl_api_gpe_fwd_entries_get_t *mp;
19519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19521 if (unformat (i, "vni %d", &vni))
19527 errmsg ("parse error '%U'", format_unformat_error, i);
19534 errmsg ("vni not set!");
19538 if (!vam->json_output)
19540 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
19544 M (GPE_FWD_ENTRIES_GET, mp);
19545 mp->vni = clib_host_to_net_u32 (vni);
19550 /* Wait for a reply... */
19555 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
19556 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
19557 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
19558 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
19559 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
19560 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
19561 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
19562 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
19565 api_one_adjacencies_get (vat_main_t * vam)
19567 unformat_input_t *i = vam->input;
19568 vl_api_one_adjacencies_get_t *mp;
19573 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19575 if (unformat (i, "vni %d", &vni))
19581 errmsg ("parse error '%U'", format_unformat_error, i);
19588 errmsg ("vni not set!");
19592 if (!vam->json_output)
19594 print (vam->ofp, "%s %40s", "leid", "reid");
19597 M (ONE_ADJACENCIES_GET, mp);
19598 mp->vni = clib_host_to_net_u32 (vni);
19603 /* Wait for a reply... */
19608 #define api_lisp_adjacencies_get api_one_adjacencies_get
19611 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
19613 unformat_input_t *i = vam->input;
19614 vl_api_gpe_native_fwd_rpaths_get_t *mp;
19616 u8 ip_family_set = 0, is_ip4 = 1;
19618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19620 if (unformat (i, "ip4"))
19625 else if (unformat (i, "ip6"))
19632 errmsg ("parse error '%U'", format_unformat_error, i);
19637 if (!ip_family_set)
19639 errmsg ("ip family not set!");
19643 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
19644 mp->is_ip4 = is_ip4;
19649 /* Wait for a reply... */
19655 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
19657 vl_api_gpe_fwd_entry_vnis_get_t *mp;
19660 if (!vam->json_output)
19662 print (vam->ofp, "VNIs");
19665 M (GPE_FWD_ENTRY_VNIS_GET, mp);
19670 /* Wait for a reply... */
19676 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
19678 unformat_input_t *i = vam->input;
19679 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
19681 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
19682 struct in_addr ip4;
19683 struct in6_addr ip6;
19684 u32 table_id = 0, nh_sw_if_index = ~0;
19686 clib_memset (&ip4, 0, sizeof (ip4));
19687 clib_memset (&ip6, 0, sizeof (ip6));
19689 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19691 if (unformat (i, "del"))
19693 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
19694 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19699 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
19700 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19705 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
19709 nh_sw_if_index = ~0;
19711 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
19715 nh_sw_if_index = ~0;
19717 else if (unformat (i, "table %d", &table_id))
19721 errmsg ("parse error '%U'", format_unformat_error, i);
19728 errmsg ("nh addr not set!");
19732 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
19733 mp->is_add = is_add;
19734 mp->table_id = clib_host_to_net_u32 (table_id);
19735 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
19736 mp->is_ip4 = is_ip4;
19738 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
19740 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
19745 /* Wait for a reply... */
19751 api_one_map_server_dump (vat_main_t * vam)
19753 vl_api_one_map_server_dump_t *mp;
19754 vl_api_control_ping_t *mp_ping;
19757 if (!vam->json_output)
19759 print (vam->ofp, "%=20s", "Map server");
19762 M (ONE_MAP_SERVER_DUMP, mp);
19766 /* Use a control ping for synchronization */
19767 MPING (CONTROL_PING, mp_ping);
19770 /* Wait for a reply... */
19775 #define api_lisp_map_server_dump api_one_map_server_dump
19778 api_one_map_resolver_dump (vat_main_t * vam)
19780 vl_api_one_map_resolver_dump_t *mp;
19781 vl_api_control_ping_t *mp_ping;
19784 if (!vam->json_output)
19786 print (vam->ofp, "%=20s", "Map resolver");
19789 M (ONE_MAP_RESOLVER_DUMP, mp);
19793 /* Use a control ping for synchronization */
19794 MPING (CONTROL_PING, mp_ping);
19797 /* Wait for a reply... */
19802 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19805 api_one_stats_flush (vat_main_t * vam)
19807 vl_api_one_stats_flush_t *mp;
19810 M (ONE_STATS_FLUSH, mp);
19817 api_one_stats_dump (vat_main_t * vam)
19819 vl_api_one_stats_dump_t *mp;
19820 vl_api_control_ping_t *mp_ping;
19823 M (ONE_STATS_DUMP, mp);
19827 /* Use a control ping for synchronization */
19828 MPING (CONTROL_PING, mp_ping);
19831 /* Wait for a reply... */
19837 api_show_one_status (vat_main_t * vam)
19839 vl_api_show_one_status_t *mp;
19842 if (!vam->json_output)
19844 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19847 M (SHOW_ONE_STATUS, mp);
19850 /* Wait for a reply... */
19855 #define api_show_lisp_status api_show_one_status
19858 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19860 vl_api_gpe_fwd_entry_path_dump_t *mp;
19861 vl_api_control_ping_t *mp_ping;
19862 unformat_input_t *i = vam->input;
19863 u32 fwd_entry_index = ~0;
19866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19868 if (unformat (i, "index %d", &fwd_entry_index))
19874 if (~0 == fwd_entry_index)
19876 errmsg ("no index specified!");
19880 if (!vam->json_output)
19882 print (vam->ofp, "first line");
19885 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19889 /* Use a control ping for synchronization */
19890 MPING (CONTROL_PING, mp_ping);
19893 /* Wait for a reply... */
19899 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19901 vl_api_one_get_map_request_itr_rlocs_t *mp;
19904 if (!vam->json_output)
19906 print (vam->ofp, "%=20s", "itr-rlocs:");
19909 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19912 /* Wait for a reply... */
19917 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19920 api_af_packet_create (vat_main_t * vam)
19922 unformat_input_t *i = vam->input;
19923 vl_api_af_packet_create_t *mp;
19924 u8 *host_if_name = 0;
19926 u8 random_hw_addr = 1;
19929 clib_memset (hw_addr, 0, sizeof (hw_addr));
19931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19933 if (unformat (i, "name %s", &host_if_name))
19934 vec_add1 (host_if_name, 0);
19935 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19936 random_hw_addr = 0;
19941 if (!vec_len (host_if_name))
19943 errmsg ("host-interface name must be specified");
19947 if (vec_len (host_if_name) > 64)
19949 errmsg ("host-interface name too long");
19953 M (AF_PACKET_CREATE, mp);
19955 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19956 clib_memcpy (mp->hw_addr, hw_addr, 6);
19957 mp->use_random_hw_addr = random_hw_addr;
19958 vec_free (host_if_name);
19966 fprintf (vam->ofp ? vam->ofp : stderr,
19967 " new sw_if_index = %d\n", vam->sw_if_index);
19974 api_af_packet_delete (vat_main_t * vam)
19976 unformat_input_t *i = vam->input;
19977 vl_api_af_packet_delete_t *mp;
19978 u8 *host_if_name = 0;
19981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19983 if (unformat (i, "name %s", &host_if_name))
19984 vec_add1 (host_if_name, 0);
19989 if (!vec_len (host_if_name))
19991 errmsg ("host-interface name must be specified");
19995 if (vec_len (host_if_name) > 64)
19997 errmsg ("host-interface name too long");
20001 M (AF_PACKET_DELETE, mp);
20003 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
20004 vec_free (host_if_name);
20011 static void vl_api_af_packet_details_t_handler
20012 (vl_api_af_packet_details_t * mp)
20014 vat_main_t *vam = &vat_main;
20016 print (vam->ofp, "%-16s %d",
20017 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
20020 static void vl_api_af_packet_details_t_handler_json
20021 (vl_api_af_packet_details_t * mp)
20023 vat_main_t *vam = &vat_main;
20024 vat_json_node_t *node = NULL;
20026 if (VAT_JSON_ARRAY != vam->json_tree.type)
20028 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20029 vat_json_init_array (&vam->json_tree);
20031 node = vat_json_array_add (&vam->json_tree);
20033 vat_json_init_object (node);
20034 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20035 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
20039 api_af_packet_dump (vat_main_t * vam)
20041 vl_api_af_packet_dump_t *mp;
20042 vl_api_control_ping_t *mp_ping;
20045 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
20046 /* Get list of tap interfaces */
20047 M (AF_PACKET_DUMP, mp);
20050 /* Use a control ping for synchronization */
20051 MPING (CONTROL_PING, mp_ping);
20059 api_policer_add_del (vat_main_t * vam)
20061 unformat_input_t *i = vam->input;
20062 vl_api_policer_add_del_t *mp;
20072 u8 color_aware = 0;
20073 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
20076 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
20077 conform_action.dscp = 0;
20078 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
20079 exceed_action.dscp = 0;
20080 violate_action.action_type = SSE2_QOS_ACTION_DROP;
20081 violate_action.dscp = 0;
20083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20085 if (unformat (i, "del"))
20087 else if (unformat (i, "name %s", &name))
20088 vec_add1 (name, 0);
20089 else if (unformat (i, "cir %u", &cir))
20091 else if (unformat (i, "eir %u", &eir))
20093 else if (unformat (i, "cb %u", &cb))
20095 else if (unformat (i, "eb %u", &eb))
20097 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
20100 else if (unformat (i, "round_type %U", unformat_policer_round_type,
20103 else if (unformat (i, "type %U", unformat_policer_type, &type))
20105 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
20108 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
20111 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
20114 else if (unformat (i, "color-aware"))
20120 if (!vec_len (name))
20122 errmsg ("policer name must be specified");
20126 if (vec_len (name) > 64)
20128 errmsg ("policer name too long");
20132 M (POLICER_ADD_DEL, mp);
20134 clib_memcpy (mp->name, name, vec_len (name));
20136 mp->is_add = is_add;
20137 mp->cir = ntohl (cir);
20138 mp->eir = ntohl (eir);
20139 mp->cb = clib_net_to_host_u64 (cb);
20140 mp->eb = clib_net_to_host_u64 (eb);
20141 mp->rate_type = rate_type;
20142 mp->round_type = round_type;
20144 mp->conform_action_type = conform_action.action_type;
20145 mp->conform_dscp = conform_action.dscp;
20146 mp->exceed_action_type = exceed_action.action_type;
20147 mp->exceed_dscp = exceed_action.dscp;
20148 mp->violate_action_type = violate_action.action_type;
20149 mp->violate_dscp = violate_action.dscp;
20150 mp->color_aware = color_aware;
20158 api_policer_dump (vat_main_t * vam)
20160 unformat_input_t *i = vam->input;
20161 vl_api_policer_dump_t *mp;
20162 vl_api_control_ping_t *mp_ping;
20163 u8 *match_name = 0;
20164 u8 match_name_valid = 0;
20167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20169 if (unformat (i, "name %s", &match_name))
20171 vec_add1 (match_name, 0);
20172 match_name_valid = 1;
20178 M (POLICER_DUMP, mp);
20179 mp->match_name_valid = match_name_valid;
20180 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
20181 vec_free (match_name);
20185 /* Use a control ping for synchronization */
20186 MPING (CONTROL_PING, mp_ping);
20189 /* Wait for a reply... */
20195 api_policer_classify_set_interface (vat_main_t * vam)
20197 unformat_input_t *i = vam->input;
20198 vl_api_policer_classify_set_interface_t *mp;
20200 int sw_if_index_set;
20201 u32 ip4_table_index = ~0;
20202 u32 ip6_table_index = ~0;
20203 u32 l2_table_index = ~0;
20207 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20209 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20210 sw_if_index_set = 1;
20211 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20212 sw_if_index_set = 1;
20213 else if (unformat (i, "del"))
20215 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20217 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20219 else if (unformat (i, "l2-table %d", &l2_table_index))
20223 clib_warning ("parse error '%U'", format_unformat_error, i);
20228 if (sw_if_index_set == 0)
20230 errmsg ("missing interface name or sw_if_index");
20234 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
20236 mp->sw_if_index = ntohl (sw_if_index);
20237 mp->ip4_table_index = ntohl (ip4_table_index);
20238 mp->ip6_table_index = ntohl (ip6_table_index);
20239 mp->l2_table_index = ntohl (l2_table_index);
20240 mp->is_add = is_add;
20248 api_policer_classify_dump (vat_main_t * vam)
20250 unformat_input_t *i = vam->input;
20251 vl_api_policer_classify_dump_t *mp;
20252 vl_api_control_ping_t *mp_ping;
20253 u8 type = POLICER_CLASSIFY_N_TABLES;
20256 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
20260 errmsg ("classify table type must be specified");
20264 if (!vam->json_output)
20266 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20269 M (POLICER_CLASSIFY_DUMP, mp);
20274 /* Use a control ping for synchronization */
20275 MPING (CONTROL_PING, mp_ping);
20278 /* Wait for a reply... */
20284 api_netmap_create (vat_main_t * vam)
20286 unformat_input_t *i = vam->input;
20287 vl_api_netmap_create_t *mp;
20290 u8 random_hw_addr = 1;
20295 clib_memset (hw_addr, 0, sizeof (hw_addr));
20297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20299 if (unformat (i, "name %s", &if_name))
20300 vec_add1 (if_name, 0);
20301 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
20302 random_hw_addr = 0;
20303 else if (unformat (i, "pipe"))
20305 else if (unformat (i, "master"))
20307 else if (unformat (i, "slave"))
20313 if (!vec_len (if_name))
20315 errmsg ("interface name must be specified");
20319 if (vec_len (if_name) > 64)
20321 errmsg ("interface name too long");
20325 M (NETMAP_CREATE, mp);
20327 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
20328 clib_memcpy (mp->hw_addr, hw_addr, 6);
20329 mp->use_random_hw_addr = random_hw_addr;
20330 mp->is_pipe = is_pipe;
20331 mp->is_master = is_master;
20332 vec_free (if_name);
20340 api_netmap_delete (vat_main_t * vam)
20342 unformat_input_t *i = vam->input;
20343 vl_api_netmap_delete_t *mp;
20347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20349 if (unformat (i, "name %s", &if_name))
20350 vec_add1 (if_name, 0);
20355 if (!vec_len (if_name))
20357 errmsg ("interface name must be specified");
20361 if (vec_len (if_name) > 64)
20363 errmsg ("interface name too long");
20367 M (NETMAP_DELETE, mp);
20369 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
20370 vec_free (if_name);
20378 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
20380 if (fp->afi == IP46_TYPE_IP6)
20382 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20383 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20384 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20385 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20386 format_ip6_address, fp->next_hop);
20387 else if (fp->afi == IP46_TYPE_IP4)
20389 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20390 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20391 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20392 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20393 format_ip4_address, fp->next_hop);
20397 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
20398 vl_api_fib_path_t * fp)
20400 struct in_addr ip4;
20401 struct in6_addr ip6;
20403 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20404 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20405 vat_json_object_add_uint (node, "is_local", fp->is_local);
20406 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20407 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20408 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20409 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20410 if (fp->afi == IP46_TYPE_IP4)
20412 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20413 vat_json_object_add_ip4 (node, "next_hop", ip4);
20415 else if (fp->afi == IP46_TYPE_IP6)
20417 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20418 vat_json_object_add_ip6 (node, "next_hop", ip6);
20423 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
20425 vat_main_t *vam = &vat_main;
20426 int count = ntohl (mp->mt_count);
20427 vl_api_fib_path_t *fp;
20430 print (vam->ofp, "[%d]: sw_if_index %d via:",
20431 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
20433 for (i = 0; i < count; i++)
20435 vl_api_mpls_fib_path_print (vam, fp);
20439 print (vam->ofp, "");
20442 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
20443 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
20446 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
20448 vat_main_t *vam = &vat_main;
20449 vat_json_node_t *node = NULL;
20450 int count = ntohl (mp->mt_count);
20451 vl_api_fib_path_t *fp;
20454 if (VAT_JSON_ARRAY != vam->json_tree.type)
20456 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20457 vat_json_init_array (&vam->json_tree);
20459 node = vat_json_array_add (&vam->json_tree);
20461 vat_json_init_object (node);
20462 vat_json_object_add_uint (node, "tunnel_index",
20463 ntohl (mp->mt_tunnel_index));
20464 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
20466 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
20469 for (i = 0; i < count; i++)
20471 vl_api_mpls_fib_path_json_print (node, fp);
20477 api_mpls_tunnel_dump (vat_main_t * vam)
20479 vl_api_mpls_tunnel_dump_t *mp;
20480 vl_api_control_ping_t *mp_ping;
20481 u32 sw_if_index = ~0;
20484 /* Parse args required to build the message */
20485 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
20487 if (unformat (vam->input, "sw_if_index %d", &sw_if_index))
20491 print (vam->ofp, " sw_if_index %d", sw_if_index);
20493 M (MPLS_TUNNEL_DUMP, mp);
20494 mp->sw_if_index = htonl (sw_if_index);
20497 /* Use a control ping for synchronization */
20498 MPING (CONTROL_PING, mp_ping);
20505 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
20506 #define vl_api_mpls_fib_details_t_print vl_noop_handler
20510 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
20512 vat_main_t *vam = &vat_main;
20513 int count = ntohl (mp->count);
20514 vl_api_fib_path_t *fp;
20518 "table-id %d, label %u, ess_bit %u",
20519 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
20521 for (i = 0; i < count; i++)
20523 vl_api_mpls_fib_path_print (vam, fp);
20528 static void vl_api_mpls_fib_details_t_handler_json
20529 (vl_api_mpls_fib_details_t * mp)
20531 vat_main_t *vam = &vat_main;
20532 int count = ntohl (mp->count);
20533 vat_json_node_t *node = NULL;
20534 vl_api_fib_path_t *fp;
20537 if (VAT_JSON_ARRAY != vam->json_tree.type)
20539 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20540 vat_json_init_array (&vam->json_tree);
20542 node = vat_json_array_add (&vam->json_tree);
20544 vat_json_init_object (node);
20545 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20546 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
20547 vat_json_object_add_uint (node, "label", ntohl (mp->label));
20548 vat_json_object_add_uint (node, "path_count", count);
20550 for (i = 0; i < count; i++)
20552 vl_api_mpls_fib_path_json_print (node, fp);
20558 api_mpls_fib_dump (vat_main_t * vam)
20560 vl_api_mpls_fib_dump_t *mp;
20561 vl_api_control_ping_t *mp_ping;
20564 M (MPLS_FIB_DUMP, mp);
20567 /* Use a control ping for synchronization */
20568 MPING (CONTROL_PING, mp_ping);
20575 #define vl_api_ip_fib_details_t_endian vl_noop_handler
20576 #define vl_api_ip_fib_details_t_print vl_noop_handler
20579 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
20581 vat_main_t *vam = &vat_main;
20582 int count = ntohl (mp->count);
20583 vl_api_fib_path_t *fp;
20587 "table-id %d, prefix %U/%d stats-index %d",
20588 ntohl (mp->table_id), format_ip4_address, mp->address,
20589 mp->address_length, ntohl (mp->stats_index));
20591 for (i = 0; i < count; i++)
20593 if (fp->afi == IP46_TYPE_IP6)
20595 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20596 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
20597 "next_hop_table %d",
20598 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20599 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20600 format_ip6_address, fp->next_hop, ntohl (fp->table_id));
20601 else if (fp->afi == IP46_TYPE_IP4)
20603 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20604 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
20605 "next_hop_table %d",
20606 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20607 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20608 format_ip4_address, fp->next_hop, ntohl (fp->table_id));
20613 static void vl_api_ip_fib_details_t_handler_json
20614 (vl_api_ip_fib_details_t * mp)
20616 vat_main_t *vam = &vat_main;
20617 int count = ntohl (mp->count);
20618 vat_json_node_t *node = NULL;
20619 struct in_addr ip4;
20620 struct in6_addr ip6;
20621 vl_api_fib_path_t *fp;
20624 if (VAT_JSON_ARRAY != vam->json_tree.type)
20626 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20627 vat_json_init_array (&vam->json_tree);
20629 node = vat_json_array_add (&vam->json_tree);
20631 vat_json_init_object (node);
20632 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20633 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
20634 vat_json_object_add_ip4 (node, "prefix", ip4);
20635 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20636 vat_json_object_add_uint (node, "path_count", count);
20638 for (i = 0; i < count; i++)
20640 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20641 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20642 vat_json_object_add_uint (node, "is_local", fp->is_local);
20643 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20644 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20645 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20646 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20647 if (fp->afi == IP46_TYPE_IP4)
20649 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20650 vat_json_object_add_ip4 (node, "next_hop", ip4);
20652 else if (fp->afi == IP46_TYPE_IP6)
20654 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20655 vat_json_object_add_ip6 (node, "next_hop", ip6);
20661 api_ip_fib_dump (vat_main_t * vam)
20663 vl_api_ip_fib_dump_t *mp;
20664 vl_api_control_ping_t *mp_ping;
20667 M (IP_FIB_DUMP, mp);
20670 /* Use a control ping for synchronization */
20671 MPING (CONTROL_PING, mp_ping);
20679 api_ip_mfib_dump (vat_main_t * vam)
20681 vl_api_ip_mfib_dump_t *mp;
20682 vl_api_control_ping_t *mp_ping;
20685 M (IP_MFIB_DUMP, mp);
20688 /* Use a control ping for synchronization */
20689 MPING (CONTROL_PING, mp_ping);
20696 static void vl_api_ip_neighbor_details_t_handler
20697 (vl_api_ip_neighbor_details_t * mp)
20699 vat_main_t *vam = &vat_main;
20701 print (vam->ofp, "%c %U %U",
20702 (mp->is_static) ? 'S' : 'D',
20703 format_ethernet_address, &mp->mac_address,
20704 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
20708 static void vl_api_ip_neighbor_details_t_handler_json
20709 (vl_api_ip_neighbor_details_t * mp)
20712 vat_main_t *vam = &vat_main;
20713 vat_json_node_t *node;
20714 struct in_addr ip4;
20715 struct in6_addr ip6;
20717 if (VAT_JSON_ARRAY != vam->json_tree.type)
20719 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20720 vat_json_init_array (&vam->json_tree);
20722 node = vat_json_array_add (&vam->json_tree);
20724 vat_json_init_object (node);
20725 vat_json_object_add_string_copy (node, "flag",
20726 (mp->is_static) ? (u8 *) "static" : (u8 *)
20729 vat_json_object_add_string_copy (node, "link_layer",
20730 format (0, "%U", format_ethernet_address,
20731 &mp->mac_address));
20735 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
20736 vat_json_object_add_ip6 (node, "ip_address", ip6);
20740 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
20741 vat_json_object_add_ip4 (node, "ip_address", ip4);
20746 api_ip_neighbor_dump (vat_main_t * vam)
20748 unformat_input_t *i = vam->input;
20749 vl_api_ip_neighbor_dump_t *mp;
20750 vl_api_control_ping_t *mp_ping;
20752 u32 sw_if_index = ~0;
20755 /* Parse args required to build the message */
20756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20758 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20760 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20762 else if (unformat (i, "ip6"))
20768 if (sw_if_index == ~0)
20770 errmsg ("missing interface name or sw_if_index");
20774 M (IP_NEIGHBOR_DUMP, mp);
20775 mp->is_ipv6 = (u8) is_ipv6;
20776 mp->sw_if_index = ntohl (sw_if_index);
20779 /* Use a control ping for synchronization */
20780 MPING (CONTROL_PING, mp_ping);
20787 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
20788 #define vl_api_ip6_fib_details_t_print vl_noop_handler
20791 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
20793 vat_main_t *vam = &vat_main;
20794 int count = ntohl (mp->count);
20795 vl_api_fib_path_t *fp;
20799 "table-id %d, prefix %U/%d stats-index %d",
20800 ntohl (mp->table_id), format_ip6_address, mp->address,
20801 mp->address_length, ntohl (mp->stats_index));
20803 for (i = 0; i < count; i++)
20805 if (fp->afi == IP46_TYPE_IP6)
20807 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20808 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20809 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20810 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20811 format_ip6_address, fp->next_hop);
20812 else if (fp->afi == IP46_TYPE_IP4)
20814 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20815 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20816 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20817 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20818 format_ip4_address, fp->next_hop);
20823 static void vl_api_ip6_fib_details_t_handler_json
20824 (vl_api_ip6_fib_details_t * mp)
20826 vat_main_t *vam = &vat_main;
20827 int count = ntohl (mp->count);
20828 vat_json_node_t *node = NULL;
20829 struct in_addr ip4;
20830 struct in6_addr ip6;
20831 vl_api_fib_path_t *fp;
20834 if (VAT_JSON_ARRAY != vam->json_tree.type)
20836 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20837 vat_json_init_array (&vam->json_tree);
20839 node = vat_json_array_add (&vam->json_tree);
20841 vat_json_init_object (node);
20842 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20843 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20844 vat_json_object_add_ip6 (node, "prefix", ip6);
20845 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20846 vat_json_object_add_uint (node, "path_count", count);
20848 for (i = 0; i < count; i++)
20850 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20851 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20852 vat_json_object_add_uint (node, "is_local", fp->is_local);
20853 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20854 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20855 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20856 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20857 if (fp->afi == IP46_TYPE_IP4)
20859 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20860 vat_json_object_add_ip4 (node, "next_hop", ip4);
20862 else if (fp->afi == IP46_TYPE_IP6)
20864 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20865 vat_json_object_add_ip6 (node, "next_hop", ip6);
20871 api_ip6_fib_dump (vat_main_t * vam)
20873 vl_api_ip6_fib_dump_t *mp;
20874 vl_api_control_ping_t *mp_ping;
20877 M (IP6_FIB_DUMP, mp);
20880 /* Use a control ping for synchronization */
20881 MPING (CONTROL_PING, mp_ping);
20889 api_ip6_mfib_dump (vat_main_t * vam)
20891 vl_api_ip6_mfib_dump_t *mp;
20892 vl_api_control_ping_t *mp_ping;
20895 M (IP6_MFIB_DUMP, mp);
20898 /* Use a control ping for synchronization */
20899 MPING (CONTROL_PING, mp_ping);
20907 api_classify_table_ids (vat_main_t * vam)
20909 vl_api_classify_table_ids_t *mp;
20912 /* Construct the API message */
20913 M (CLASSIFY_TABLE_IDS, mp);
20922 api_classify_table_by_interface (vat_main_t * vam)
20924 unformat_input_t *input = vam->input;
20925 vl_api_classify_table_by_interface_t *mp;
20927 u32 sw_if_index = ~0;
20929 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20931 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20933 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20938 if (sw_if_index == ~0)
20940 errmsg ("missing interface name or sw_if_index");
20944 /* Construct the API message */
20945 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20947 mp->sw_if_index = ntohl (sw_if_index);
20955 api_classify_table_info (vat_main_t * vam)
20957 unformat_input_t *input = vam->input;
20958 vl_api_classify_table_info_t *mp;
20962 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20964 if (unformat (input, "table_id %d", &table_id))
20969 if (table_id == ~0)
20971 errmsg ("missing table id");
20975 /* Construct the API message */
20976 M (CLASSIFY_TABLE_INFO, mp);
20978 mp->table_id = ntohl (table_id);
20986 api_classify_session_dump (vat_main_t * vam)
20988 unformat_input_t *input = vam->input;
20989 vl_api_classify_session_dump_t *mp;
20990 vl_api_control_ping_t *mp_ping;
20994 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20996 if (unformat (input, "table_id %d", &table_id))
21001 if (table_id == ~0)
21003 errmsg ("missing table id");
21007 /* Construct the API message */
21008 M (CLASSIFY_SESSION_DUMP, mp);
21010 mp->table_id = ntohl (table_id);
21013 /* Use a control ping for synchronization */
21014 MPING (CONTROL_PING, mp_ping);
21022 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
21024 vat_main_t *vam = &vat_main;
21026 print (vam->ofp, "collector_address %U, collector_port %d, "
21027 "src_address %U, vrf_id %d, path_mtu %u, "
21028 "template_interval %u, udp_checksum %d",
21029 format_ip4_address, mp->collector_address,
21030 ntohs (mp->collector_port),
21031 format_ip4_address, mp->src_address,
21032 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
21033 ntohl (mp->template_interval), mp->udp_checksum);
21036 vam->result_ready = 1;
21040 vl_api_ipfix_exporter_details_t_handler_json
21041 (vl_api_ipfix_exporter_details_t * mp)
21043 vat_main_t *vam = &vat_main;
21044 vat_json_node_t node;
21045 struct in_addr collector_address;
21046 struct in_addr src_address;
21048 vat_json_init_object (&node);
21049 clib_memcpy (&collector_address, &mp->collector_address,
21050 sizeof (collector_address));
21051 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
21052 vat_json_object_add_uint (&node, "collector_port",
21053 ntohs (mp->collector_port));
21054 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
21055 vat_json_object_add_ip4 (&node, "src_address", src_address);
21056 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
21057 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
21058 vat_json_object_add_uint (&node, "template_interval",
21059 ntohl (mp->template_interval));
21060 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
21062 vat_json_print (vam->ofp, &node);
21063 vat_json_free (&node);
21065 vam->result_ready = 1;
21069 api_ipfix_exporter_dump (vat_main_t * vam)
21071 vl_api_ipfix_exporter_dump_t *mp;
21074 /* Construct the API message */
21075 M (IPFIX_EXPORTER_DUMP, mp);
21084 api_ipfix_classify_stream_dump (vat_main_t * vam)
21086 vl_api_ipfix_classify_stream_dump_t *mp;
21089 /* Construct the API message */
21090 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
21101 vl_api_ipfix_classify_stream_details_t_handler
21102 (vl_api_ipfix_classify_stream_details_t * mp)
21104 vat_main_t *vam = &vat_main;
21105 print (vam->ofp, "domain_id %d, src_port %d",
21106 ntohl (mp->domain_id), ntohs (mp->src_port));
21108 vam->result_ready = 1;
21112 vl_api_ipfix_classify_stream_details_t_handler_json
21113 (vl_api_ipfix_classify_stream_details_t * mp)
21115 vat_main_t *vam = &vat_main;
21116 vat_json_node_t node;
21118 vat_json_init_object (&node);
21119 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
21120 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
21122 vat_json_print (vam->ofp, &node);
21123 vat_json_free (&node);
21125 vam->result_ready = 1;
21129 api_ipfix_classify_table_dump (vat_main_t * vam)
21131 vl_api_ipfix_classify_table_dump_t *mp;
21132 vl_api_control_ping_t *mp_ping;
21135 if (!vam->json_output)
21137 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
21138 "transport_protocol");
21141 /* Construct the API message */
21142 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
21147 /* Use a control ping for synchronization */
21148 MPING (CONTROL_PING, mp_ping);
21156 vl_api_ipfix_classify_table_details_t_handler
21157 (vl_api_ipfix_classify_table_details_t * mp)
21159 vat_main_t *vam = &vat_main;
21160 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
21161 mp->transport_protocol);
21165 vl_api_ipfix_classify_table_details_t_handler_json
21166 (vl_api_ipfix_classify_table_details_t * mp)
21168 vat_json_node_t *node = NULL;
21169 vat_main_t *vam = &vat_main;
21171 if (VAT_JSON_ARRAY != vam->json_tree.type)
21173 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21174 vat_json_init_array (&vam->json_tree);
21177 node = vat_json_array_add (&vam->json_tree);
21178 vat_json_init_object (node);
21180 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
21181 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
21182 vat_json_object_add_uint (node, "transport_protocol",
21183 mp->transport_protocol);
21187 api_sw_interface_span_enable_disable (vat_main_t * vam)
21189 unformat_input_t *i = vam->input;
21190 vl_api_sw_interface_span_enable_disable_t *mp;
21191 u32 src_sw_if_index = ~0;
21192 u32 dst_sw_if_index = ~0;
21197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21200 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
21202 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
21206 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
21208 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
21210 else if (unformat (i, "disable"))
21212 else if (unformat (i, "rx"))
21214 else if (unformat (i, "tx"))
21216 else if (unformat (i, "both"))
21218 else if (unformat (i, "l2"))
21224 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
21226 mp->sw_if_index_from = htonl (src_sw_if_index);
21227 mp->sw_if_index_to = htonl (dst_sw_if_index);
21237 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
21240 vat_main_t *vam = &vat_main;
21241 u8 *sw_if_from_name = 0;
21242 u8 *sw_if_to_name = 0;
21243 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
21244 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
21245 char *states[] = { "none", "rx", "tx", "both" };
21249 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
21251 if ((u32) p->value[0] == sw_if_index_from)
21253 sw_if_from_name = (u8 *)(p->key);
21257 if ((u32) p->value[0] == sw_if_index_to)
21259 sw_if_to_name = (u8 *)(p->key);
21260 if (sw_if_from_name)
21265 print (vam->ofp, "%20s => %20s (%s) %s",
21266 sw_if_from_name, sw_if_to_name, states[mp->state],
21267 mp->is_l2 ? "l2" : "device");
21271 vl_api_sw_interface_span_details_t_handler_json
21272 (vl_api_sw_interface_span_details_t * mp)
21274 vat_main_t *vam = &vat_main;
21275 vat_json_node_t *node = NULL;
21276 u8 *sw_if_from_name = 0;
21277 u8 *sw_if_to_name = 0;
21278 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
21279 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
21283 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
21285 if ((u32) p->value[0] == sw_if_index_from)
21287 sw_if_from_name = (u8 *)(p->key);
21291 if ((u32) p->value[0] == sw_if_index_to)
21293 sw_if_to_name = (u8 *)(p->key);
21294 if (sw_if_from_name)
21300 if (VAT_JSON_ARRAY != vam->json_tree.type)
21302 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21303 vat_json_init_array (&vam->json_tree);
21305 node = vat_json_array_add (&vam->json_tree);
21307 vat_json_init_object (node);
21308 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
21309 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
21310 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
21311 if (0 != sw_if_to_name)
21313 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
21315 vat_json_object_add_uint (node, "state", mp->state);
21316 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
21320 api_sw_interface_span_dump (vat_main_t * vam)
21322 unformat_input_t *input = vam->input;
21323 vl_api_sw_interface_span_dump_t *mp;
21324 vl_api_control_ping_t *mp_ping;
21328 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21330 if (unformat (input, "l2"))
21336 M (SW_INTERFACE_SPAN_DUMP, mp);
21340 /* Use a control ping for synchronization */
21341 MPING (CONTROL_PING, mp_ping);
21349 api_pg_create_interface (vat_main_t * vam)
21351 unformat_input_t *input = vam->input;
21352 vl_api_pg_create_interface_t *mp;
21356 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21358 if (unformat (input, "if_id %d", &if_id))
21365 errmsg ("missing pg interface index");
21369 /* Construct the API message */
21370 M (PG_CREATE_INTERFACE, mp);
21372 mp->interface_id = ntohl (if_id);
21380 api_pg_capture (vat_main_t * vam)
21382 unformat_input_t *input = vam->input;
21383 vl_api_pg_capture_t *mp;
21388 u8 pcap_file_set = 0;
21391 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21393 if (unformat (input, "if_id %d", &if_id))
21395 else if (unformat (input, "pcap %s", &pcap_file))
21397 else if (unformat (input, "count %d", &count))
21399 else if (unformat (input, "disable"))
21406 errmsg ("missing pg interface index");
21409 if (pcap_file_set > 0)
21411 if (vec_len (pcap_file) > 255)
21413 errmsg ("pcap file name is too long");
21418 u32 name_len = vec_len (pcap_file);
21419 /* Construct the API message */
21420 M (PG_CAPTURE, mp);
21422 mp->interface_id = ntohl (if_id);
21423 mp->is_enabled = enable;
21424 mp->count = ntohl (count);
21425 mp->pcap_name_length = ntohl (name_len);
21426 if (pcap_file_set != 0)
21428 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
21430 vec_free (pcap_file);
21438 api_pg_enable_disable (vat_main_t * vam)
21440 unformat_input_t *input = vam->input;
21441 vl_api_pg_enable_disable_t *mp;
21444 u8 stream_name_set = 0;
21445 u8 *stream_name = 0;
21447 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21449 if (unformat (input, "stream %s", &stream_name))
21450 stream_name_set = 1;
21451 else if (unformat (input, "disable"))
21457 if (stream_name_set > 0)
21459 if (vec_len (stream_name) > 255)
21461 errmsg ("stream name too long");
21466 u32 name_len = vec_len (stream_name);
21467 /* Construct the API message */
21468 M (PG_ENABLE_DISABLE, mp);
21470 mp->is_enabled = enable;
21471 if (stream_name_set != 0)
21473 mp->stream_name_length = ntohl (name_len);
21474 clib_memcpy (mp->stream_name, stream_name, name_len);
21476 vec_free (stream_name);
21484 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
21486 unformat_input_t *input = vam->input;
21487 vl_api_ip_source_and_port_range_check_add_del_t *mp;
21489 u16 *low_ports = 0;
21490 u16 *high_ports = 0;
21493 ip4_address_t ip4_addr;
21494 ip6_address_t ip6_addr;
21503 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21505 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
21511 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
21516 else if (unformat (input, "vrf %d", &vrf_id))
21518 else if (unformat (input, "del"))
21520 else if (unformat (input, "port %d", &tmp))
21522 if (tmp == 0 || tmp > 65535)
21524 errmsg ("port %d out of range", tmp);
21528 this_hi = this_low + 1;
21529 vec_add1 (low_ports, this_low);
21530 vec_add1 (high_ports, this_hi);
21532 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
21534 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
21536 errmsg ("incorrect range parameters");
21540 /* Note: in debug CLI +1 is added to high before
21541 passing to real fn that does "the work"
21542 (ip_source_and_port_range_check_add_del).
21543 This fn is a wrapper around the binary API fn a
21544 control plane will call, which expects this increment
21545 to have occurred. Hence letting the binary API control
21546 plane fn do the increment for consistency between VAT
21547 and other control planes.
21550 vec_add1 (low_ports, this_low);
21551 vec_add1 (high_ports, this_hi);
21557 if (prefix_set == 0)
21559 errmsg ("<address>/<mask> not specified");
21565 errmsg ("VRF ID required, not specified");
21572 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21576 if (vec_len (low_ports) == 0)
21578 errmsg ("At least one port or port range required");
21582 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
21584 mp->is_add = is_add;
21589 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
21594 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
21597 mp->mask_length = length;
21598 mp->number_of_ranges = vec_len (low_ports);
21600 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
21601 vec_free (low_ports);
21603 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
21604 vec_free (high_ports);
21606 mp->vrf_id = ntohl (vrf_id);
21614 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
21616 unformat_input_t *input = vam->input;
21617 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
21618 u32 sw_if_index = ~0;
21620 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
21621 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
21625 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21627 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21629 else if (unformat (input, "sw_if_index %d", &sw_if_index))
21631 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
21633 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
21635 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
21637 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
21639 else if (unformat (input, "del"))
21645 if (sw_if_index == ~0)
21647 errmsg ("Interface required but not specified");
21653 errmsg ("VRF ID required but not specified");
21657 if (tcp_out_vrf_id == 0
21658 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
21661 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21665 /* Construct the API message */
21666 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
21668 mp->sw_if_index = ntohl (sw_if_index);
21669 mp->is_add = is_add;
21670 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
21671 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
21672 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
21673 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
21678 /* Wait for a reply... */
21684 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
21686 unformat_input_t *i = vam->input;
21687 vl_api_ipsec_gre_add_del_tunnel_t *mp;
21688 u32 local_sa_id = 0;
21689 u32 remote_sa_id = 0;
21690 ip4_address_t src_address;
21691 ip4_address_t dst_address;
21695 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21697 if (unformat (i, "local_sa %d", &local_sa_id))
21699 else if (unformat (i, "remote_sa %d", &remote_sa_id))
21701 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
21703 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
21705 else if (unformat (i, "del"))
21709 clib_warning ("parse error '%U'", format_unformat_error, i);
21714 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
21716 mp->local_sa_id = ntohl (local_sa_id);
21717 mp->remote_sa_id = ntohl (remote_sa_id);
21718 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
21719 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
21720 mp->is_add = is_add;
21728 api_punt (vat_main_t * vam)
21730 unformat_input_t *i = vam->input;
21738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21740 if (unformat (i, "ip %d", &ipv))
21742 else if (unformat (i, "protocol %d", &protocol))
21744 else if (unformat (i, "port %d", &port))
21746 else if (unformat (i, "del"))
21750 clib_warning ("parse error '%U'", format_unformat_error, i);
21757 mp->is_add = (u8) is_add;
21758 mp->ipv = (u8) ipv;
21759 mp->l4_protocol = (u8) protocol;
21760 mp->l4_port = htons ((u16) port);
21767 static void vl_api_ipsec_gre_tunnel_details_t_handler
21768 (vl_api_ipsec_gre_tunnel_details_t * mp)
21770 vat_main_t *vam = &vat_main;
21772 print (vam->ofp, "%11d%15U%15U%14d%14d",
21773 ntohl (mp->sw_if_index),
21774 format_ip4_address, &mp->src_address,
21775 format_ip4_address, &mp->dst_address,
21776 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
21779 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
21780 (vl_api_ipsec_gre_tunnel_details_t * mp)
21782 vat_main_t *vam = &vat_main;
21783 vat_json_node_t *node = NULL;
21784 struct in_addr ip4;
21786 if (VAT_JSON_ARRAY != vam->json_tree.type)
21788 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21789 vat_json_init_array (&vam->json_tree);
21791 node = vat_json_array_add (&vam->json_tree);
21793 vat_json_init_object (node);
21794 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
21795 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
21796 vat_json_object_add_ip4 (node, "src_address", ip4);
21797 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
21798 vat_json_object_add_ip4 (node, "dst_address", ip4);
21799 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
21800 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
21804 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
21806 unformat_input_t *i = vam->input;
21807 vl_api_ipsec_gre_tunnel_dump_t *mp;
21808 vl_api_control_ping_t *mp_ping;
21810 u8 sw_if_index_set = 0;
21813 /* Parse args required to build the message */
21814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21816 if (unformat (i, "sw_if_index %d", &sw_if_index))
21817 sw_if_index_set = 1;
21822 if (sw_if_index_set == 0)
21827 if (!vam->json_output)
21829 print (vam->ofp, "%11s%15s%15s%14s%14s",
21830 "sw_if_index", "src_address", "dst_address",
21831 "local_sa_id", "remote_sa_id");
21834 /* Get list of gre-tunnel interfaces */
21835 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21837 mp->sw_if_index = htonl (sw_if_index);
21841 /* Use a control ping for synchronization */
21842 MPING (CONTROL_PING, mp_ping);
21850 api_delete_subif (vat_main_t * vam)
21852 unformat_input_t *i = vam->input;
21853 vl_api_delete_subif_t *mp;
21854 u32 sw_if_index = ~0;
21857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21859 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21861 if (unformat (i, "sw_if_index %d", &sw_if_index))
21867 if (sw_if_index == ~0)
21869 errmsg ("missing sw_if_index");
21873 /* Construct the API message */
21874 M (DELETE_SUBIF, mp);
21875 mp->sw_if_index = ntohl (sw_if_index);
21882 #define foreach_pbb_vtr_op \
21883 _("disable", L2_VTR_DISABLED) \
21884 _("pop", L2_VTR_POP_2) \
21885 _("push", L2_VTR_PUSH_2)
21888 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21890 unformat_input_t *i = vam->input;
21891 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21892 u32 sw_if_index = ~0, vtr_op = ~0;
21893 u16 outer_tag = ~0;
21894 u8 dmac[6], smac[6];
21895 u8 dmac_set = 0, smac_set = 0;
21901 /* Shut up coverity */
21902 clib_memset (dmac, 0, sizeof (dmac));
21903 clib_memset (smac, 0, sizeof (smac));
21905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21907 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21909 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21911 else if (unformat (i, "vtr_op %d", &vtr_op))
21913 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21916 else if (unformat (i, "translate_pbb_stag"))
21918 if (unformat (i, "%d", &tmp))
21920 vtr_op = L2_VTR_TRANSLATE_2_1;
21926 ("translate_pbb_stag operation requires outer tag definition");
21930 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21932 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21934 else if (unformat (i, "sid %d", &sid))
21936 else if (unformat (i, "vlanid %d", &tmp))
21940 clib_warning ("parse error '%U'", format_unformat_error, i);
21945 if ((sw_if_index == ~0) || (vtr_op == ~0))
21947 errmsg ("missing sw_if_index or vtr operation");
21950 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21951 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21954 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21958 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21959 mp->sw_if_index = ntohl (sw_if_index);
21960 mp->vtr_op = ntohl (vtr_op);
21961 mp->outer_tag = ntohs (outer_tag);
21962 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21963 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21964 mp->b_vlanid = ntohs (vlanid);
21965 mp->i_sid = ntohl (sid);
21973 api_flow_classify_set_interface (vat_main_t * vam)
21975 unformat_input_t *i = vam->input;
21976 vl_api_flow_classify_set_interface_t *mp;
21978 int sw_if_index_set;
21979 u32 ip4_table_index = ~0;
21980 u32 ip6_table_index = ~0;
21984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21986 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21987 sw_if_index_set = 1;
21988 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21989 sw_if_index_set = 1;
21990 else if (unformat (i, "del"))
21992 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21994 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21998 clib_warning ("parse error '%U'", format_unformat_error, i);
22003 if (sw_if_index_set == 0)
22005 errmsg ("missing interface name or sw_if_index");
22009 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
22011 mp->sw_if_index = ntohl (sw_if_index);
22012 mp->ip4_table_index = ntohl (ip4_table_index);
22013 mp->ip6_table_index = ntohl (ip6_table_index);
22014 mp->is_add = is_add;
22022 api_flow_classify_dump (vat_main_t * vam)
22024 unformat_input_t *i = vam->input;
22025 vl_api_flow_classify_dump_t *mp;
22026 vl_api_control_ping_t *mp_ping;
22027 u8 type = FLOW_CLASSIFY_N_TABLES;
22030 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
22034 errmsg ("classify table type must be specified");
22038 if (!vam->json_output)
22040 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
22043 M (FLOW_CLASSIFY_DUMP, mp);
22048 /* Use a control ping for synchronization */
22049 MPING (CONTROL_PING, mp_ping);
22052 /* Wait for a reply... */
22058 api_feature_enable_disable (vat_main_t * vam)
22060 unformat_input_t *i = vam->input;
22061 vl_api_feature_enable_disable_t *mp;
22063 u8 *feature_name = 0;
22064 u32 sw_if_index = ~0;
22068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22070 if (unformat (i, "arc_name %s", &arc_name))
22072 else if (unformat (i, "feature_name %s", &feature_name))
22075 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22077 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22079 else if (unformat (i, "disable"))
22087 errmsg ("missing arc name");
22090 if (vec_len (arc_name) > 63)
22092 errmsg ("arc name too long");
22095 if (feature_name == 0)
22097 errmsg ("missing feature name");
22100 if (vec_len (feature_name) > 63)
22102 errmsg ("feature name too long");
22105 if (sw_if_index == ~0)
22107 errmsg ("missing interface name or sw_if_index");
22111 /* Construct the API message */
22112 M (FEATURE_ENABLE_DISABLE, mp);
22113 mp->sw_if_index = ntohl (sw_if_index);
22114 mp->enable = enable;
22115 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
22116 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
22117 vec_free (arc_name);
22118 vec_free (feature_name);
22126 api_sw_interface_tag_add_del (vat_main_t * vam)
22128 unformat_input_t *i = vam->input;
22129 vl_api_sw_interface_tag_add_del_t *mp;
22130 u32 sw_if_index = ~0;
22135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22137 if (unformat (i, "tag %s", &tag))
22139 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22141 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22143 else if (unformat (i, "del"))
22149 if (sw_if_index == ~0)
22151 errmsg ("missing interface name or sw_if_index");
22155 if (enable && (tag == 0))
22157 errmsg ("no tag specified");
22161 /* Construct the API message */
22162 M (SW_INTERFACE_TAG_ADD_DEL, mp);
22163 mp->sw_if_index = ntohl (sw_if_index);
22164 mp->is_add = enable;
22166 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
22174 static void vl_api_l2_xconnect_details_t_handler
22175 (vl_api_l2_xconnect_details_t * mp)
22177 vat_main_t *vam = &vat_main;
22179 print (vam->ofp, "%15d%15d",
22180 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
22183 static void vl_api_l2_xconnect_details_t_handler_json
22184 (vl_api_l2_xconnect_details_t * mp)
22186 vat_main_t *vam = &vat_main;
22187 vat_json_node_t *node = NULL;
22189 if (VAT_JSON_ARRAY != vam->json_tree.type)
22191 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22192 vat_json_init_array (&vam->json_tree);
22194 node = vat_json_array_add (&vam->json_tree);
22196 vat_json_init_object (node);
22197 vat_json_object_add_uint (node, "rx_sw_if_index",
22198 ntohl (mp->rx_sw_if_index));
22199 vat_json_object_add_uint (node, "tx_sw_if_index",
22200 ntohl (mp->tx_sw_if_index));
22204 api_l2_xconnect_dump (vat_main_t * vam)
22206 vl_api_l2_xconnect_dump_t *mp;
22207 vl_api_control_ping_t *mp_ping;
22210 if (!vam->json_output)
22212 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
22215 M (L2_XCONNECT_DUMP, mp);
22219 /* Use a control ping for synchronization */
22220 MPING (CONTROL_PING, mp_ping);
22228 api_hw_interface_set_mtu (vat_main_t * vam)
22230 unformat_input_t *i = vam->input;
22231 vl_api_hw_interface_set_mtu_t *mp;
22232 u32 sw_if_index = ~0;
22236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22238 if (unformat (i, "mtu %d", &mtu))
22240 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22242 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22248 if (sw_if_index == ~0)
22250 errmsg ("missing interface name or sw_if_index");
22256 errmsg ("no mtu specified");
22260 /* Construct the API message */
22261 M (HW_INTERFACE_SET_MTU, mp);
22262 mp->sw_if_index = ntohl (sw_if_index);
22263 mp->mtu = ntohs ((u16) mtu);
22271 api_p2p_ethernet_add (vat_main_t * vam)
22273 unformat_input_t *i = vam->input;
22274 vl_api_p2p_ethernet_add_t *mp;
22275 u32 parent_if_index = ~0;
22281 clib_memset (remote_mac, 0, sizeof (remote_mac));
22282 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22284 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
22286 else if (unformat (i, "sw_if_index %d", &parent_if_index))
22290 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
22292 else if (unformat (i, "sub_id %d", &sub_id))
22296 clib_warning ("parse error '%U'", format_unformat_error, i);
22301 if (parent_if_index == ~0)
22303 errmsg ("missing interface name or sw_if_index");
22308 errmsg ("missing remote mac address");
22313 errmsg ("missing sub-interface id");
22317 M (P2P_ETHERNET_ADD, mp);
22318 mp->parent_if_index = ntohl (parent_if_index);
22319 mp->subif_id = ntohl (sub_id);
22320 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
22328 api_p2p_ethernet_del (vat_main_t * vam)
22330 unformat_input_t *i = vam->input;
22331 vl_api_p2p_ethernet_del_t *mp;
22332 u32 parent_if_index = ~0;
22337 clib_memset (remote_mac, 0, sizeof (remote_mac));
22338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22340 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
22342 else if (unformat (i, "sw_if_index %d", &parent_if_index))
22346 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
22350 clib_warning ("parse error '%U'", format_unformat_error, i);
22355 if (parent_if_index == ~0)
22357 errmsg ("missing interface name or sw_if_index");
22362 errmsg ("missing remote mac address");
22366 M (P2P_ETHERNET_DEL, mp);
22367 mp->parent_if_index = ntohl (parent_if_index);
22368 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
22376 api_lldp_config (vat_main_t * vam)
22378 unformat_input_t *i = vam->input;
22379 vl_api_lldp_config_t *mp;
22381 int tx_interval = 0;
22382 u8 *sys_name = NULL;
22385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22387 if (unformat (i, "system-name %s", &sys_name))
22389 else if (unformat (i, "tx-hold %d", &tx_hold))
22391 else if (unformat (i, "tx-interval %d", &tx_interval))
22395 clib_warning ("parse error '%U'", format_unformat_error, i);
22400 vec_add1 (sys_name, 0);
22402 M (LLDP_CONFIG, mp);
22403 mp->tx_hold = htonl (tx_hold);
22404 mp->tx_interval = htonl (tx_interval);
22405 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
22406 vec_free (sys_name);
22414 api_sw_interface_set_lldp (vat_main_t * vam)
22416 unformat_input_t *i = vam->input;
22417 vl_api_sw_interface_set_lldp_t *mp;
22418 u32 sw_if_index = ~0;
22420 u8 *port_desc = NULL, *mgmt_oid = NULL;
22421 ip4_address_t ip4_addr;
22422 ip6_address_t ip6_addr;
22425 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
22426 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
22428 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22430 if (unformat (i, "disable"))
22433 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22435 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22437 else if (unformat (i, "port-desc %s", &port_desc))
22439 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
22441 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
22443 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
22449 if (sw_if_index == ~0)
22451 errmsg ("missing interface name or sw_if_index");
22455 /* Construct the API message */
22456 vec_add1 (port_desc, 0);
22457 vec_add1 (mgmt_oid, 0);
22458 M (SW_INTERFACE_SET_LLDP, mp);
22459 mp->sw_if_index = ntohl (sw_if_index);
22460 mp->enable = enable;
22461 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
22462 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
22463 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
22464 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
22465 vec_free (port_desc);
22466 vec_free (mgmt_oid);
22474 api_tcp_configure_src_addresses (vat_main_t * vam)
22476 vl_api_tcp_configure_src_addresses_t *mp;
22477 unformat_input_t *i = vam->input;
22478 ip4_address_t v4first, v4last;
22479 ip6_address_t v6first, v6last;
22484 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22486 if (unformat (i, "%U - %U",
22487 unformat_ip4_address, &v4first,
22488 unformat_ip4_address, &v4last))
22492 errmsg ("one range per message (range already set)");
22497 else if (unformat (i, "%U - %U",
22498 unformat_ip6_address, &v6first,
22499 unformat_ip6_address, &v6last))
22503 errmsg ("one range per message (range already set)");
22508 else if (unformat (i, "vrf %d", &vrf_id))
22514 if (range_set == 0)
22516 errmsg ("address range not set");
22520 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
22521 mp->vrf_id = ntohl (vrf_id);
22523 if (range_set == 2)
22526 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
22527 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
22532 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
22533 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
22540 static void vl_api_app_namespace_add_del_reply_t_handler
22541 (vl_api_app_namespace_add_del_reply_t * mp)
22543 vat_main_t *vam = &vat_main;
22544 i32 retval = ntohl (mp->retval);
22545 if (vam->async_mode)
22547 vam->async_errors += (retval < 0);
22551 vam->retval = retval;
22553 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
22554 vam->result_ready = 1;
22558 static void vl_api_app_namespace_add_del_reply_t_handler_json
22559 (vl_api_app_namespace_add_del_reply_t * mp)
22561 vat_main_t *vam = &vat_main;
22562 vat_json_node_t node;
22564 vat_json_init_object (&node);
22565 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
22566 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
22568 vat_json_print (vam->ofp, &node);
22569 vat_json_free (&node);
22571 vam->retval = ntohl (mp->retval);
22572 vam->result_ready = 1;
22576 api_app_namespace_add_del (vat_main_t * vam)
22578 vl_api_app_namespace_add_del_t *mp;
22579 unformat_input_t *i = vam->input;
22580 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
22581 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
22585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22587 if (unformat (i, "id %_%v%_", &ns_id))
22589 else if (unformat (i, "secret %lu", &secret))
22591 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22592 sw_if_index_set = 1;
22593 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
22595 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
22600 if (!ns_id || !secret_set || !sw_if_index_set)
22602 errmsg ("namespace id, secret and sw_if_index must be set");
22605 if (vec_len (ns_id) > 64)
22607 errmsg ("namespace id too long");
22610 M (APP_NAMESPACE_ADD_DEL, mp);
22612 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
22613 mp->namespace_id_len = vec_len (ns_id);
22614 mp->secret = clib_host_to_net_u64 (secret);
22615 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22616 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
22617 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
22625 api_sock_init_shm (vat_main_t * vam)
22627 #if VPP_API_TEST_BUILTIN == 0
22628 unformat_input_t *i = vam->input;
22629 vl_api_shm_elem_config_t *config = 0;
22630 u64 size = 64 << 20;
22633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22635 if (unformat (i, "size %U", unformat_memory_size, &size))
22642 * Canned custom ring allocator config.
22643 * Should probably parse all of this
22645 vec_validate (config, 6);
22646 config[0].type = VL_API_VLIB_RING;
22647 config[0].size = 256;
22648 config[0].count = 32;
22650 config[1].type = VL_API_VLIB_RING;
22651 config[1].size = 1024;
22652 config[1].count = 16;
22654 config[2].type = VL_API_VLIB_RING;
22655 config[2].size = 4096;
22656 config[2].count = 2;
22658 config[3].type = VL_API_CLIENT_RING;
22659 config[3].size = 256;
22660 config[3].count = 32;
22662 config[4].type = VL_API_CLIENT_RING;
22663 config[4].size = 1024;
22664 config[4].count = 16;
22666 config[5].type = VL_API_CLIENT_RING;
22667 config[5].size = 4096;
22668 config[5].count = 2;
22670 config[6].type = VL_API_QUEUE;
22671 config[6].count = 128;
22672 config[6].size = sizeof (uword);
22674 rv = vl_socket_client_init_shm (config);
22676 vam->client_index_invalid = 1;
22684 api_dns_enable_disable (vat_main_t * vam)
22686 unformat_input_t *line_input = vam->input;
22687 vl_api_dns_enable_disable_t *mp;
22688 u8 enable_disable = 1;
22691 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22693 if (unformat (line_input, "disable"))
22694 enable_disable = 0;
22695 if (unformat (line_input, "enable"))
22696 enable_disable = 1;
22701 /* Construct the API message */
22702 M (DNS_ENABLE_DISABLE, mp);
22703 mp->enable = enable_disable;
22707 /* Wait for the reply */
22713 api_dns_resolve_name (vat_main_t * vam)
22715 unformat_input_t *line_input = vam->input;
22716 vl_api_dns_resolve_name_t *mp;
22720 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22722 if (unformat (line_input, "%s", &name))
22728 if (vec_len (name) > 127)
22730 errmsg ("name too long");
22734 /* Construct the API message */
22735 M (DNS_RESOLVE_NAME, mp);
22736 memcpy (mp->name, name, vec_len (name));
22741 /* Wait for the reply */
22747 api_dns_resolve_ip (vat_main_t * vam)
22749 unformat_input_t *line_input = vam->input;
22750 vl_api_dns_resolve_ip_t *mp;
22752 ip4_address_t addr4;
22753 ip6_address_t addr6;
22756 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22758 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
22760 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
22768 errmsg ("missing address");
22772 /* Construct the API message */
22773 M (DNS_RESOLVE_IP, mp);
22774 mp->is_ip6 = is_ip6;
22776 memcpy (mp->address, &addr6, sizeof (addr6));
22778 memcpy (mp->address, &addr4, sizeof (addr4));
22782 /* Wait for the reply */
22788 api_dns_name_server_add_del (vat_main_t * vam)
22790 unformat_input_t *i = vam->input;
22791 vl_api_dns_name_server_add_del_t *mp;
22793 ip6_address_t ip6_server;
22794 ip4_address_t ip4_server;
22799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22801 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
22803 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
22805 else if (unformat (i, "del"))
22809 clib_warning ("parse error '%U'", format_unformat_error, i);
22814 if (ip4_set && ip6_set)
22816 errmsg ("Only one server address allowed per message");
22819 if ((ip4_set + ip6_set) == 0)
22821 errmsg ("Server address required");
22825 /* Construct the API message */
22826 M (DNS_NAME_SERVER_ADD_DEL, mp);
22830 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22835 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22839 mp->is_add = is_add;
22844 /* Wait for a reply, return good/bad news */
22850 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22852 vat_main_t *vam = &vat_main;
22857 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22858 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22859 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22860 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22861 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22862 clib_net_to_host_u32 (mp->action_index), mp->tag);
22867 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22868 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22869 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22870 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22871 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22872 clib_net_to_host_u32 (mp->action_index), mp->tag);
22877 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22880 vat_main_t *vam = &vat_main;
22881 vat_json_node_t *node = NULL;
22882 struct in6_addr ip6;
22883 struct in_addr ip4;
22885 if (VAT_JSON_ARRAY != vam->json_tree.type)
22887 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22888 vat_json_init_array (&vam->json_tree);
22890 node = vat_json_array_add (&vam->json_tree);
22891 vat_json_init_object (node);
22893 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22894 vat_json_object_add_uint (node, "appns_index",
22895 clib_net_to_host_u32 (mp->appns_index));
22896 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22897 vat_json_object_add_uint (node, "scope", mp->scope);
22898 vat_json_object_add_uint (node, "action_index",
22899 clib_net_to_host_u32 (mp->action_index));
22900 vat_json_object_add_uint (node, "lcl_port",
22901 clib_net_to_host_u16 (mp->lcl_port));
22902 vat_json_object_add_uint (node, "rmt_port",
22903 clib_net_to_host_u16 (mp->rmt_port));
22904 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22905 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22906 vat_json_object_add_string_copy (node, "tag", mp->tag);
22909 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22910 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22911 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22912 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22916 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22917 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22918 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22919 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22924 api_session_rule_add_del (vat_main_t * vam)
22926 vl_api_session_rule_add_del_t *mp;
22927 unformat_input_t *i = vam->input;
22928 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22929 u32 appns_index = 0, scope = 0;
22930 ip4_address_t lcl_ip4, rmt_ip4;
22931 ip6_address_t lcl_ip6, rmt_ip6;
22932 u8 is_ip4 = 1, conn_set = 0;
22933 u8 is_add = 1, *tag = 0;
22936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22938 if (unformat (i, "del"))
22940 else if (unformat (i, "add"))
22942 else if (unformat (i, "proto tcp"))
22944 else if (unformat (i, "proto udp"))
22946 else if (unformat (i, "appns %d", &appns_index))
22948 else if (unformat (i, "scope %d", &scope))
22950 else if (unformat (i, "tag %_%v%_", &tag))
22954 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22955 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22963 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22964 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22970 else if (unformat (i, "action %d", &action))
22975 if (proto == ~0 || !conn_set || action == ~0)
22977 errmsg ("transport proto, connection and action must be set");
22983 errmsg ("scope should be 0-3");
22987 M (SESSION_RULE_ADD_DEL, mp);
22989 mp->is_ip4 = is_ip4;
22990 mp->transport_proto = proto;
22991 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22992 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22993 mp->lcl_plen = lcl_plen;
22994 mp->rmt_plen = rmt_plen;
22995 mp->action_index = clib_host_to_net_u32 (action);
22996 mp->appns_index = clib_host_to_net_u32 (appns_index);
22998 mp->is_add = is_add;
23001 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
23002 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
23006 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
23007 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
23011 clib_memcpy (mp->tag, tag, vec_len (tag));
23021 api_session_rules_dump (vat_main_t * vam)
23023 vl_api_session_rules_dump_t *mp;
23024 vl_api_control_ping_t *mp_ping;
23027 if (!vam->json_output)
23029 print (vam->ofp, "%=20s", "Session Rules");
23032 M (SESSION_RULES_DUMP, mp);
23036 /* Use a control ping for synchronization */
23037 MPING (CONTROL_PING, mp_ping);
23040 /* Wait for a reply... */
23046 api_ip_container_proxy_add_del (vat_main_t * vam)
23048 vl_api_ip_container_proxy_add_del_t *mp;
23049 unformat_input_t *i = vam->input;
23050 u32 plen = ~0, sw_if_index = ~0;
23057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
23059 if (unformat (i, "del"))
23061 else if (unformat (i, "add"))
23063 if (unformat (i, "%U", unformat_ip4_address, &ip4))
23068 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
23073 else if (unformat (i, "sw_if_index %u", &sw_if_index))
23078 if (sw_if_index == ~0 || plen == ~0)
23080 errmsg ("address and sw_if_index must be set");
23084 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
23086 mp->is_ip4 = is_ip4;
23087 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
23089 mp->is_add = is_add;
23091 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
23093 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
23101 api_qos_record_enable_disable (vat_main_t * vam)
23103 unformat_input_t *i = vam->input;
23104 vl_api_qos_record_enable_disable_t *mp;
23105 u32 sw_if_index, qs = 0xff;
23106 u8 sw_if_index_set = 0;
23110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
23112 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
23113 sw_if_index_set = 1;
23114 else if (unformat (i, "sw_if_index %d", &sw_if_index))
23115 sw_if_index_set = 1;
23116 else if (unformat (i, "%U", unformat_qos_source, &qs))
23118 else if (unformat (i, "disable"))
23122 clib_warning ("parse error '%U'", format_unformat_error, i);
23127 if (sw_if_index_set == 0)
23129 errmsg ("missing interface name or sw_if_index");
23134 errmsg ("input location must be specified");
23138 M (QOS_RECORD_ENABLE_DISABLE, mp);
23140 mp->sw_if_index = ntohl (sw_if_index);
23141 mp->input_source = qs;
23142 mp->enable = enable;
23151 q_or_quit (vat_main_t * vam)
23153 #if VPP_API_TEST_BUILTIN == 0
23154 longjmp (vam->jump_buf, 1);
23156 return 0; /* not so much */
23160 q (vat_main_t * vam)
23162 return q_or_quit (vam);
23166 quit (vat_main_t * vam)
23168 return q_or_quit (vam);
23172 comment (vat_main_t * vam)
23178 statseg (vat_main_t * vam)
23180 ssvm_private_t *ssvmp = &vam->stat_segment;
23181 ssvm_shared_header_t *shared_header = ssvmp->sh;
23182 vlib_counter_t **counters;
23183 u64 thread0_index1_packets;
23184 u64 thread0_index1_bytes;
23185 f64 vector_rate, input_rate;
23188 uword *counter_vector_by_name;
23189 if (vam->stat_segment_lockp == 0)
23191 errmsg ("Stat segment not mapped...");
23195 /* look up "/if/rx for sw_if_index 1 as a test */
23197 clib_spinlock_lock (vam->stat_segment_lockp);
23199 counter_vector_by_name = (uword *) shared_header->opaque[1];
23201 p = hash_get_mem (counter_vector_by_name, "/if/rx");
23204 clib_spinlock_unlock (vam->stat_segment_lockp);
23205 errmsg ("/if/tx not found?");
23209 /* Fish per-thread vector of combined counters from shared memory */
23210 counters = (vlib_counter_t **) p[0];
23212 if (vec_len (counters[0]) < 2)
23214 clib_spinlock_unlock (vam->stat_segment_lockp);
23215 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
23219 /* Read thread 0 sw_if_index 1 counter */
23220 thread0_index1_packets = counters[0][1].packets;
23221 thread0_index1_bytes = counters[0][1].bytes;
23223 p = hash_get_mem (counter_vector_by_name, "vector_rate");
23226 clib_spinlock_unlock (vam->stat_segment_lockp);
23227 errmsg ("vector_rate not found?");
23231 vector_rate = *(f64 *) (p[0]);
23232 p = hash_get_mem (counter_vector_by_name, "input_rate");
23235 clib_spinlock_unlock (vam->stat_segment_lockp);
23236 errmsg ("input_rate not found?");
23239 input_rate = *(f64 *) (p[0]);
23241 clib_spinlock_unlock (vam->stat_segment_lockp);
23243 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
23244 vector_rate, input_rate);
23245 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
23246 thread0_index1_packets, thread0_index1_bytes);
23252 cmd_cmp (void *a1, void *a2)
23257 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
23261 help (vat_main_t * vam)
23266 unformat_input_t *i = vam->input;
23269 if (unformat (i, "%s", &name))
23273 vec_add1 (name, 0);
23275 hs = hash_get_mem (vam->help_by_name, name);
23277 print (vam->ofp, "usage: %s %s", name, hs[0]);
23279 print (vam->ofp, "No such msg / command '%s'", name);
23284 print (vam->ofp, "Help is available for the following:");
23287 hash_foreach_pair (p, vam->function_by_name,
23289 vec_add1 (cmds, (u8 *)(p->key));
23293 vec_sort_with_function (cmds, cmd_cmp);
23295 for (j = 0; j < vec_len (cmds); j++)
23296 print (vam->ofp, "%s", cmds[j]);
23303 set (vat_main_t * vam)
23305 u8 *name = 0, *value = 0;
23306 unformat_input_t *i = vam->input;
23308 if (unformat (i, "%s", &name))
23310 /* The input buffer is a vector, not a string. */
23311 value = vec_dup (i->buffer);
23312 vec_delete (value, i->index, 0);
23313 /* Almost certainly has a trailing newline */
23314 if (value[vec_len (value) - 1] == '\n')
23315 value[vec_len (value) - 1] = 0;
23316 /* Make sure it's a proper string, one way or the other */
23317 vec_add1 (value, 0);
23318 (void) clib_macro_set_value (&vam->macro_main,
23319 (char *) name, (char *) value);
23322 errmsg ("usage: set <name> <value>");
23330 unset (vat_main_t * vam)
23334 if (unformat (vam->input, "%s", &name))
23335 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
23336 errmsg ("unset: %s wasn't set", name);
23349 macro_sort_cmp (void *a1, void *a2)
23351 macro_sort_t *s1 = a1;
23352 macro_sort_t *s2 = a2;
23354 return strcmp ((char *) (s1->name), (char *) (s2->name));
23358 dump_macro_table (vat_main_t * vam)
23360 macro_sort_t *sort_me = 0, *sm;
23365 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
23367 vec_add2 (sort_me, sm, 1);
23368 sm->name = (u8 *)(p->key);
23369 sm->value = (u8 *) (p->value[0]);
23373 vec_sort_with_function (sort_me, macro_sort_cmp);
23375 if (vec_len (sort_me))
23376 print (vam->ofp, "%-15s%s", "Name", "Value");
23378 print (vam->ofp, "The macro table is empty...");
23380 for (i = 0; i < vec_len (sort_me); i++)
23381 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
23386 dump_node_table (vat_main_t * vam)
23389 vlib_node_t *node, *next_node;
23391 if (vec_len (vam->graph_nodes) == 0)
23393 print (vam->ofp, "Node table empty, issue get_node_graph...");
23397 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
23399 node = vam->graph_nodes[0][i];
23400 print (vam->ofp, "[%d] %s", i, node->name);
23401 for (j = 0; j < vec_len (node->next_nodes); j++)
23403 if (node->next_nodes[j] != ~0)
23405 next_node = vam->graph_nodes[0][node->next_nodes[j]];
23406 print (vam->ofp, " [%d] %s", j, next_node->name);
23414 value_sort_cmp (void *a1, void *a2)
23416 name_sort_t *n1 = a1;
23417 name_sort_t *n2 = a2;
23419 if (n1->value < n2->value)
23421 if (n1->value > n2->value)
23428 dump_msg_api_table (vat_main_t * vam)
23430 api_main_t *am = &api_main;
23431 name_sort_t *nses = 0, *ns;
23436 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
23438 vec_add2 (nses, ns, 1);
23439 ns->name = (u8 *)(hp->key);
23440 ns->value = (u32) hp->value[0];
23444 vec_sort_with_function (nses, value_sort_cmp);
23446 for (i = 0; i < vec_len (nses); i++)
23447 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
23453 get_msg_id (vat_main_t * vam)
23458 if (unformat (vam->input, "%s", &name_and_crc))
23460 message_index = vl_msg_api_get_msg_index (name_and_crc);
23461 if (message_index == ~0)
23463 print (vam->ofp, " '%s' not found", name_and_crc);
23466 print (vam->ofp, " '%s' has message index %d",
23467 name_and_crc, message_index);
23470 errmsg ("name_and_crc required...");
23475 search_node_table (vat_main_t * vam)
23477 unformat_input_t *line_input = vam->input;
23480 vlib_node_t *node, *next_node;
23483 if (vam->graph_node_index_by_name == 0)
23485 print (vam->ofp, "Node table empty, issue get_node_graph...");
23489 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
23491 if (unformat (line_input, "%s", &node_to_find))
23493 vec_add1 (node_to_find, 0);
23494 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
23497 print (vam->ofp, "%s not found...", node_to_find);
23500 node = vam->graph_nodes[0][p[0]];
23501 print (vam->ofp, "[%d] %s", p[0], node->name);
23502 for (j = 0; j < vec_len (node->next_nodes); j++)
23504 if (node->next_nodes[j] != ~0)
23506 next_node = vam->graph_nodes[0][node->next_nodes[j]];
23507 print (vam->ofp, " [%d] %s", j, next_node->name);
23514 clib_warning ("parse error '%U'", format_unformat_error,
23520 vec_free (node_to_find);
23529 script (vat_main_t * vam)
23531 #if (VPP_API_TEST_BUILTIN==0)
23533 char *save_current_file;
23534 unformat_input_t save_input;
23535 jmp_buf save_jump_buf;
23536 u32 save_line_number;
23538 FILE *new_fp, *save_ifp;
23540 if (unformat (vam->input, "%s", &s))
23542 new_fp = fopen ((char *) s, "r");
23545 errmsg ("Couldn't open script file %s", s);
23552 errmsg ("Missing script name");
23556 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
23557 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
23558 save_ifp = vam->ifp;
23559 save_line_number = vam->input_line_number;
23560 save_current_file = (char *) vam->current_file;
23562 vam->input_line_number = 0;
23564 vam->current_file = s;
23567 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
23568 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
23569 vam->ifp = save_ifp;
23570 vam->input_line_number = save_line_number;
23571 vam->current_file = (u8 *) save_current_file;
23576 clib_warning ("use the exec command...");
23582 echo (vat_main_t * vam)
23584 print (vam->ofp, "%v", vam->input->buffer);
23588 /* List of API message constructors, CLI names map to api_xxx */
23589 #define foreach_vpe_api_msg \
23590 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
23591 _(sw_interface_dump,"") \
23592 _(sw_interface_set_flags, \
23593 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
23594 _(sw_interface_add_del_address, \
23595 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
23596 _(sw_interface_set_rx_mode, \
23597 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
23598 _(sw_interface_set_rx_placement, \
23599 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
23600 _(sw_interface_rx_placement_dump, \
23601 "[<intfc> | sw_if_index <id>]") \
23602 _(sw_interface_set_table, \
23603 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
23604 _(sw_interface_set_mpls_enable, \
23605 "<intfc> | sw_if_index [disable | dis]") \
23606 _(sw_interface_set_vpath, \
23607 "<intfc> | sw_if_index <id> enable | disable") \
23608 _(sw_interface_set_vxlan_bypass, \
23609 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23610 _(sw_interface_set_geneve_bypass, \
23611 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23612 _(sw_interface_set_l2_xconnect, \
23613 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23614 "enable | disable") \
23615 _(sw_interface_set_l2_bridge, \
23616 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
23617 "[shg <split-horizon-group>] [bvi]\n" \
23618 "enable | disable") \
23619 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
23620 _(bridge_domain_add_del, \
23621 "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") \
23622 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
23624 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
23625 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
23626 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
23628 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23630 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23632 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
23634 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
23636 "<vpp-if-name> | sw_if_index <id>") \
23637 _(sw_interface_tap_dump, "") \
23639 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
23641 "<vpp-if-name> | sw_if_index <id>") \
23642 _(sw_interface_tap_v2_dump, "") \
23644 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
23645 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]}") \
23647 "<vpp-if-name> | sw_if_index <id>") \
23649 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
23650 _(bond_detach_slave, \
23651 "sw_if_index <n>") \
23652 _(sw_interface_bond_dump, "") \
23653 _(sw_interface_slave_dump, \
23654 "<vpp-if-name> | sw_if_index <id>") \
23655 _(ip_table_add_del, \
23656 "table <n> [ipv6] [add | del]\n") \
23657 _(ip_add_del_route, \
23658 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
23659 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
23660 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
23661 "[multipath] [count <n>] [del]") \
23662 _(ip_mroute_add_del, \
23663 "<src> <grp>/<mask> [table-id <n>]\n" \
23664 "[<intfc> | sw_if_index <id>] [local] [del]") \
23665 _(mpls_table_add_del, \
23666 "table <n> [add | del]\n") \
23667 _(mpls_route_add_del, \
23668 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
23669 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
23670 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
23671 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
23672 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
23673 "[count <n>] [del]") \
23674 _(mpls_ip_bind_unbind, \
23675 "<label> <addr/len>") \
23676 _(mpls_tunnel_add_del, \
23677 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
23678 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
23679 "[l2-only] [out-label <n>]") \
23680 _(sr_mpls_policy_add, \
23681 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
23682 _(sr_mpls_policy_del, \
23684 _(bier_table_add_del, \
23685 "<label> <sub-domain> <set> <bsl> [del]") \
23686 _(bier_route_add_del, \
23687 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
23688 "[<intfc> | sw_if_index <id>]" \
23689 "[weight <n>] [del] [multipath]") \
23690 _(proxy_arp_add_del, \
23691 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
23692 _(proxy_arp_intfc_enable_disable, \
23693 "<intfc> | sw_if_index <id> enable | disable") \
23694 _(sw_interface_set_unnumbered, \
23695 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
23696 _(ip_neighbor_add_del, \
23697 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
23698 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
23699 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
23700 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
23701 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
23702 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
23703 "[outer_vlan_id_any][inner_vlan_id_any]") \
23704 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
23705 _(reset_fib, "vrf <n> [ipv6]") \
23706 _(dhcp_proxy_config, \
23707 "svr <v46-address> src <v46-address>\n" \
23708 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
23709 _(dhcp_proxy_set_vss, \
23710 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
23711 _(dhcp_proxy_dump, "ip6") \
23712 _(dhcp_client_config, \
23713 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
23714 _(set_ip_flow_hash, \
23715 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
23716 _(sw_interface_ip6_enable_disable, \
23717 "<intfc> | sw_if_index <id> enable | disable") \
23718 _(ip6nd_proxy_add_del, \
23719 "<intfc> | sw_if_index <id> <ip6-address>") \
23720 _(ip6nd_proxy_dump, "") \
23721 _(sw_interface_ip6nd_ra_prefix, \
23722 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
23723 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
23724 "[nolink] [isno]") \
23725 _(sw_interface_ip6nd_ra_config, \
23726 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
23727 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
23728 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
23729 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
23730 _(l2_patch_add_del, \
23731 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23732 "enable | disable") \
23733 _(sr_localsid_add_del, \
23734 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
23735 "fib-table <num> (end.psp) sw_if_index <num>") \
23736 _(classify_add_del_table, \
23737 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
23738 " [del] [del-chain] mask <mask-value>\n" \
23739 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
23740 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
23741 _(classify_add_del_session, \
23742 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
23743 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
23744 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
23745 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
23746 _(classify_set_interface_ip_table, \
23747 "<intfc> | sw_if_index <nn> table <nn>") \
23748 _(classify_set_interface_l2_tables, \
23749 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23750 " [other-table <nn>]") \
23751 _(get_node_index, "node <node-name") \
23752 _(add_node_next, "node <node-name> next <next-node-name>") \
23753 _(l2tpv3_create_tunnel, \
23754 "client_address <ip6-addr> our_address <ip6-addr>\n" \
23755 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
23756 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
23757 _(l2tpv3_set_tunnel_cookies, \
23758 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
23759 "[new_remote_cookie <nn>]\n") \
23760 _(l2tpv3_interface_enable_disable, \
23761 "<intfc> | sw_if_index <nn> enable | disable") \
23762 _(l2tpv3_set_lookup_key, \
23763 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
23764 _(sw_if_l2tpv3_tunnel_dump, "") \
23765 _(vxlan_offload_rx, \
23766 "hw { <interface name> | hw_if_index <nn>} " \
23767 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
23768 _(vxlan_add_del_tunnel, \
23769 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23770 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
23771 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23772 _(geneve_add_del_tunnel, \
23773 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23774 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23775 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23776 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23777 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23778 _(gre_add_del_tunnel, \
23779 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
23780 "[teb | erspan <session-id>] [del]") \
23781 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23782 _(l2_fib_clear_table, "") \
23783 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
23784 _(l2_interface_vlan_tag_rewrite, \
23785 "<intfc> | sw_if_index <nn> \n" \
23786 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
23787 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
23788 _(create_vhost_user_if, \
23789 "socket <filename> [server] [renumber <dev_instance>] " \
23790 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
23791 "[mac <mac_address>]") \
23792 _(modify_vhost_user_if, \
23793 "<intfc> | sw_if_index <nn> socket <filename>\n" \
23794 "[server] [renumber <dev_instance>]") \
23795 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
23796 _(sw_interface_vhost_user_dump, "") \
23797 _(show_version, "") \
23798 _(show_threads, "") \
23799 _(vxlan_gpe_add_del_tunnel, \
23800 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
23801 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23802 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
23803 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
23804 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23805 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
23806 _(interface_name_renumber, \
23807 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
23808 _(input_acl_set_interface, \
23809 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23810 " [l2-table <nn>] [del]") \
23811 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
23812 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
23813 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
23814 _(want_ip4_arp_events, "address <ip4-address> [del]") \
23815 _(want_ip6_nd_events, "address <ip6-address> [del]") \
23816 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
23817 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
23818 _(ip_dump, "ipv4 | ipv6") \
23819 _(ipsec_spd_add_del, "spd_id <n> [del]") \
23820 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
23822 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
23823 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
23824 " integ_alg <alg> integ_key <hex>") \
23825 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
23826 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
23827 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
23828 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
23829 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
23830 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
23831 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
23832 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
23833 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
23834 " [instance <n>]") \
23835 _(ipsec_sa_dump, "[sa_id <n>]") \
23836 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
23837 " <alg> <hex>\n") \
23838 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
23839 _(ikev2_profile_add_del, "name <profile_name> [del]") \
23840 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
23841 "(auth_data 0x<data> | auth_data <data>)") \
23842 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
23843 "(id_data 0x<data> | id_data <data>) (local|remote)") \
23844 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
23845 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
23846 "(local|remote)") \
23847 _(ikev2_set_local_key, "file <absolute_file_path>") \
23848 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
23849 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23850 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23851 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
23852 _(ikev2_initiate_sa_init, "<profile_name>") \
23853 _(ikev2_initiate_del_ike_sa, "<ispi>") \
23854 _(ikev2_initiate_del_child_sa, "<ispi>") \
23855 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
23856 _(delete_loopback,"sw_if_index <nn>") \
23857 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
23858 _(bd_ip_mac_dump, "[bd_id] <id>") \
23859 _(want_interface_events, "enable|disable") \
23860 _(want_stats,"enable|disable") \
23861 _(get_first_msg_id, "client <name>") \
23862 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
23863 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
23864 "fib-id <nn> [ip4][ip6][default]") \
23865 _(get_node_graph, " ") \
23866 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
23867 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
23868 _(ioam_disable, "") \
23869 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
23870 " sw_if_index <sw_if_index> p <priority> " \
23871 "w <weight>] [del]") \
23872 _(one_add_del_locator, "locator-set <locator_name> " \
23873 "iface <intf> | sw_if_index <sw_if_index> " \
23874 "p <priority> w <weight> [del]") \
23875 _(one_add_del_local_eid,"vni <vni> eid " \
23876 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23877 "locator-set <locator_name> [del]" \
23878 "[key-id sha1|sha256 secret-key <secret-key>]")\
23879 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
23880 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
23881 _(one_enable_disable, "enable|disable") \
23882 _(one_map_register_enable_disable, "enable|disable") \
23883 _(one_map_register_fallback_threshold, "<value>") \
23884 _(one_rloc_probe_enable_disable, "enable|disable") \
23885 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23887 "rloc <locator> p <prio> " \
23888 "w <weight> [rloc <loc> ... ] " \
23889 "action <action> [del-all]") \
23890 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23892 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23893 _(one_use_petr, "ip-address> | disable") \
23894 _(one_map_request_mode, "src-dst|dst-only") \
23895 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23896 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23897 _(one_locator_set_dump, "[local | remote]") \
23898 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
23899 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23900 "[local] | [remote]") \
23901 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
23902 _(one_ndp_bd_get, "") \
23903 _(one_ndp_entries_get, "bd <bridge-domain>") \
23904 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
23905 _(one_l2_arp_bd_get, "") \
23906 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
23907 _(one_stats_enable_disable, "enable|disable") \
23908 _(show_one_stats_enable_disable, "") \
23909 _(one_eid_table_vni_dump, "") \
23910 _(one_eid_table_map_dump, "l2|l3") \
23911 _(one_map_resolver_dump, "") \
23912 _(one_map_server_dump, "") \
23913 _(one_adjacencies_get, "vni <vni>") \
23914 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
23915 _(show_one_rloc_probe_state, "") \
23916 _(show_one_map_register_state, "") \
23917 _(show_one_status, "") \
23918 _(one_stats_dump, "") \
23919 _(one_stats_flush, "") \
23920 _(one_get_map_request_itr_rlocs, "") \
23921 _(one_map_register_set_ttl, "<ttl>") \
23922 _(one_set_transport_protocol, "udp|api") \
23923 _(one_get_transport_protocol, "") \
23924 _(one_enable_disable_xtr_mode, "enable|disable") \
23925 _(one_show_xtr_mode, "") \
23926 _(one_enable_disable_pitr_mode, "enable|disable") \
23927 _(one_show_pitr_mode, "") \
23928 _(one_enable_disable_petr_mode, "enable|disable") \
23929 _(one_show_petr_mode, "") \
23930 _(show_one_nsh_mapping, "") \
23931 _(show_one_pitr, "") \
23932 _(show_one_use_petr, "") \
23933 _(show_one_map_request_mode, "") \
23934 _(show_one_map_register_ttl, "") \
23935 _(show_one_map_register_fallback_threshold, "") \
23936 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
23937 " sw_if_index <sw_if_index> p <priority> " \
23938 "w <weight>] [del]") \
23939 _(lisp_add_del_locator, "locator-set <locator_name> " \
23940 "iface <intf> | sw_if_index <sw_if_index> " \
23941 "p <priority> w <weight> [del]") \
23942 _(lisp_add_del_local_eid,"vni <vni> eid " \
23943 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23944 "locator-set <locator_name> [del]" \
23945 "[key-id sha1|sha256 secret-key <secret-key>]") \
23946 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
23947 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
23948 _(lisp_enable_disable, "enable|disable") \
23949 _(lisp_map_register_enable_disable, "enable|disable") \
23950 _(lisp_rloc_probe_enable_disable, "enable|disable") \
23951 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23953 "rloc <locator> p <prio> " \
23954 "w <weight> [rloc <loc> ... ] " \
23955 "action <action> [del-all]") \
23956 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23958 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23959 _(lisp_use_petr, "<ip-address> | disable") \
23960 _(lisp_map_request_mode, "src-dst|dst-only") \
23961 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23962 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23963 _(lisp_locator_set_dump, "[local | remote]") \
23964 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
23965 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23966 "[local] | [remote]") \
23967 _(lisp_eid_table_vni_dump, "") \
23968 _(lisp_eid_table_map_dump, "l2|l3") \
23969 _(lisp_map_resolver_dump, "") \
23970 _(lisp_map_server_dump, "") \
23971 _(lisp_adjacencies_get, "vni <vni>") \
23972 _(gpe_fwd_entry_vnis_get, "") \
23973 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23974 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23975 "[table <table-id>]") \
23976 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23977 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23978 _(gpe_set_encap_mode, "lisp|vxlan") \
23979 _(gpe_get_encap_mode, "") \
23980 _(lisp_gpe_add_del_iface, "up|down") \
23981 _(lisp_gpe_enable_disable, "enable|disable") \
23982 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23983 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23984 _(show_lisp_rloc_probe_state, "") \
23985 _(show_lisp_map_register_state, "") \
23986 _(show_lisp_status, "") \
23987 _(lisp_get_map_request_itr_rlocs, "") \
23988 _(show_lisp_pitr, "") \
23989 _(show_lisp_use_petr, "") \
23990 _(show_lisp_map_request_mode, "") \
23991 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23992 _(af_packet_delete, "name <host interface name>") \
23993 _(af_packet_dump, "") \
23994 _(policer_add_del, "name <policer name> <params> [del]") \
23995 _(policer_dump, "[name <policer name>]") \
23996 _(policer_classify_set_interface, \
23997 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23998 " [l2-table <nn>] [del]") \
23999 _(policer_classify_dump, "type [ip4|ip6|l2]") \
24000 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
24001 "[master|slave]") \
24002 _(netmap_delete, "name <interface name>") \
24003 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
24004 _(mpls_fib_dump, "") \
24005 _(classify_table_ids, "") \
24006 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
24007 _(classify_table_info, "table_id <nn>") \
24008 _(classify_session_dump, "table_id <nn>") \
24009 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
24010 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
24011 "[template_interval <nn>] [udp_checksum]") \
24012 _(ipfix_exporter_dump, "") \
24013 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
24014 _(ipfix_classify_stream_dump, "") \
24015 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
24016 _(ipfix_classify_table_dump, "") \
24017 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
24018 _(sw_interface_span_dump, "[l2]") \
24019 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
24020 _(pg_create_interface, "if_id <nn>") \
24021 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
24022 _(pg_enable_disable, "[stream <id>] disable") \
24023 _(ip_source_and_port_range_check_add_del, \
24024 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
24025 _(ip_source_and_port_range_check_interface_add_del, \
24026 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
24027 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
24028 _(ipsec_gre_add_del_tunnel, \
24029 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
24030 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
24031 _(delete_subif,"<intfc> | sw_if_index <nn>") \
24032 _(l2_interface_pbb_tag_rewrite, \
24033 "<intfc> | sw_if_index <nn> \n" \
24034 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
24035 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
24036 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
24037 _(flow_classify_set_interface, \
24038 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
24039 _(flow_classify_dump, "type [ip4|ip6]") \
24040 _(ip_fib_dump, "") \
24041 _(ip_mfib_dump, "") \
24042 _(ip6_fib_dump, "") \
24043 _(ip6_mfib_dump, "") \
24044 _(feature_enable_disable, "arc_name <arc_name> " \
24045 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
24046 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
24048 _(l2_xconnect_dump, "") \
24049 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
24050 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
24051 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
24052 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
24053 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
24054 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
24055 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
24056 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
24057 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
24058 _(sock_init_shm, "size <nnn>") \
24059 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
24060 _(dns_enable_disable, "[enable][disable]") \
24061 _(dns_name_server_add_del, "<ip-address> [del]") \
24062 _(dns_resolve_name, "<hostname>") \
24063 _(dns_resolve_ip, "<ip4|ip6>") \
24064 _(dns_name_server_add_del, "<ip-address> [del]") \
24065 _(dns_resolve_name, "<hostname>") \
24066 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
24067 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
24068 _(session_rules_dump, "") \
24069 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
24070 _(output_acl_set_interface, \
24071 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
24072 " [l2-table <nn>] [del]") \
24073 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
24075 /* List of command functions, CLI names map directly to functions */
24076 #define foreach_cli_function \
24077 _(comment, "usage: comment <ignore-rest-of-line>") \
24078 _(dump_interface_table, "usage: dump_interface_table") \
24079 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
24080 _(dump_ipv4_table, "usage: dump_ipv4_table") \
24081 _(dump_ipv6_table, "usage: dump_ipv6_table") \
24082 _(dump_stats_table, "usage: dump_stats_table") \
24083 _(dump_macro_table, "usage: dump_macro_table ") \
24084 _(dump_node_table, "usage: dump_node_table") \
24085 _(dump_msg_api_table, "usage: dump_msg_api_table") \
24086 _(get_msg_id, "usage: get_msg_id name_and_crc") \
24087 _(echo, "usage: echo <message>") \
24088 _(exec, "usage: exec <vpe-debug-CLI-command>") \
24089 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
24090 _(help, "usage: help") \
24091 _(q, "usage: quit") \
24092 _(quit, "usage: quit") \
24093 _(search_node_table, "usage: search_node_table <name>...") \
24094 _(set, "usage: set <variable-name> <value>") \
24095 _(script, "usage: script <file-name>") \
24096 _(statseg, "usage: statseg"); \
24097 _(unset, "usage: unset <variable-name>")
24100 static void vl_api_##n##_t_handler_uni \
24101 (vl_api_##n##_t * mp) \
24103 vat_main_t * vam = &vat_main; \
24104 if (vam->json_output) { \
24105 vl_api_##n##_t_handler_json(mp); \
24107 vl_api_##n##_t_handler(mp); \
24110 foreach_vpe_api_reply_msg;
24111 #if VPP_API_TEST_BUILTIN == 0
24112 foreach_standalone_reply_msg;
24117 vat_api_hookup (vat_main_t * vam)
24120 vl_msg_api_set_handlers(VL_API_##N, #n, \
24121 vl_api_##n##_t_handler_uni, \
24123 vl_api_##n##_t_endian, \
24124 vl_api_##n##_t_print, \
24125 sizeof(vl_api_##n##_t), 1);
24126 foreach_vpe_api_reply_msg;
24127 #if VPP_API_TEST_BUILTIN == 0
24128 foreach_standalone_reply_msg;
24132 #if (VPP_API_TEST_BUILTIN==0)
24133 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
24135 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
24137 vam->function_by_name = hash_create_string (0, sizeof (uword));
24139 vam->help_by_name = hash_create_string (0, sizeof (uword));
24142 /* API messages we can send */
24143 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
24144 foreach_vpe_api_msg;
24148 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
24149 foreach_vpe_api_msg;
24152 /* CLI functions */
24153 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
24154 foreach_cli_function;
24158 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
24159 foreach_cli_function;
24163 #if VPP_API_TEST_BUILTIN
24164 static clib_error_t *
24165 vat_api_hookup_shim (vlib_main_t * vm)
24167 vat_api_hookup (&vat_main);
24171 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
24175 * fd.io coding-style-patch-verification: ON
24178 * eval: (c-set-style "gnu")