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 <vppinfra/socket.h>
22 #include <vlibapi/api.h>
23 #include <vlibmemory/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/l2/l2_input.h>
26 #include <vnet/l2tp/l2tp.h>
27 #include <vnet/vxlan/vxlan.h>
28 #include <vnet/geneve/geneve.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp/api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/classify/policer_classify.h>
38 #include <vnet/classify/flow_classify.h>
39 #include <vnet/mpls/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
43 #include <vnet/map/map.h>
44 #include <vnet/cop/cop.h>
45 #include <vnet/ip/ip6_hop_by_hop.h>
46 #include <vnet/ip/ip_source_and_port_range_check.h>
47 #include <vnet/policer/xlate.h>
48 #include <vnet/span/span.h>
49 #include <vnet/policer/policer.h>
50 #include <vnet/policer/police.h>
51 #include <vnet/mfib/mfib_types.h>
52 #include <vnet/dhcp/dhcp_proxy.h>
54 #include "vat/json_format.h"
59 #define vl_typedefs /* define message structures */
60 #include <vpp/api/vpe_all_api_h.h>
63 /* declare message handlers for each api */
65 #define vl_endianfun /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* instantiate all the print functions we know about */
70 #define vl_print(handle, ...)
72 #include <vpp/api/vpe_all_api_h.h>
75 #define __plugin_msg_base 0
76 #include <vlibapi/vat_helper_macros.h>
78 #if VPP_API_TEST_BUILTIN == 0
88 vat_socket_connect (vat_main_t * vam)
90 vam->socket_client_main = &socket_client_main;
91 return vl_socket_client_connect ((char *) vam->socket_name, "vpp_api_test",
92 0 /* default socket rx, tx buffer */ );
94 #else /* vpp built-in case, we don't do sockets... */
96 vat_socket_connect (vat_main_t * vam)
102 vl_socket_client_read (int wait)
108 vl_socket_client_write ()
114 vl_socket_client_msg_alloc (int nbytes)
122 vat_time_now (vat_main_t * vam)
124 #if VPP_API_TEST_BUILTIN
125 return vlib_time_now (vam->vlib_main);
127 return clib_time_now (&vam->clib_time);
132 errmsg (char *fmt, ...)
134 vat_main_t *vam = &vat_main;
139 s = va_format (0, fmt, &va);
144 #if VPP_API_TEST_BUILTIN
145 vlib_cli_output (vam->vlib_main, (char *) s);
148 if (vam->ifp != stdin)
149 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
150 vam->input_line_number);
151 fformat (vam->ofp, (char *) s);
159 #if VPP_API_TEST_BUILTIN == 0
161 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
163 vat_main_t *vam = va_arg (*args, vat_main_t *);
164 u32 *result = va_arg (*args, u32 *);
168 if (!unformat (input, "%s", &if_name))
171 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
178 /* Parse an IP4 address %d.%d.%d.%d. */
180 unformat_ip4_address (unformat_input_t * input, va_list * args)
182 u8 *result = va_arg (*args, u8 *);
185 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
188 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
200 unformat_ethernet_address (unformat_input_t * input, va_list * args)
202 u8 *result = va_arg (*args, u8 *);
205 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
206 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
210 for (i = 0; i < 6; i++)
211 if (a[i] >= (1 << 8))
214 for (i = 0; i < 6; i++)
220 /* Returns ethernet type as an int in host byte order. */
222 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
225 u16 *result = va_arg (*args, u16 *);
229 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
231 if (type >= (1 << 16))
239 /* Parse an IP6 address. */
241 unformat_ip6_address (unformat_input_t * input, va_list * args)
243 ip6_address_t *result = va_arg (*args, ip6_address_t *);
245 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
246 uword c, n_colon, double_colon_index;
248 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
249 double_colon_index = ARRAY_LEN (hex_quads);
250 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
253 if (c >= '0' && c <= '9')
255 else if (c >= 'a' && c <= 'f')
256 hex_digit = c + 10 - 'a';
257 else if (c >= 'A' && c <= 'F')
258 hex_digit = c + 10 - 'A';
259 else if (c == ':' && n_colon < 2)
263 unformat_put_input (input);
267 /* Too many hex quads. */
268 if (n_hex_quads >= ARRAY_LEN (hex_quads))
273 hex_quad = (hex_quad << 4) | hex_digit;
275 /* Hex quad must fit in 16 bits. */
276 if (n_hex_digits >= 4)
283 /* Save position of :: */
286 /* More than one :: ? */
287 if (double_colon_index < ARRAY_LEN (hex_quads))
289 double_colon_index = n_hex_quads;
292 if (n_colon > 0 && n_hex_digits > 0)
294 hex_quads[n_hex_quads++] = hex_quad;
300 if (n_hex_digits > 0)
301 hex_quads[n_hex_quads++] = hex_quad;
306 /* Expand :: to appropriate number of zero hex quads. */
307 if (double_colon_index < ARRAY_LEN (hex_quads))
309 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
311 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
312 hex_quads[n_zero + i] = hex_quads[i];
314 for (i = 0; i < n_zero; i++)
315 hex_quads[double_colon_index + i] = 0;
317 n_hex_quads = ARRAY_LEN (hex_quads);
320 /* Too few hex quads given. */
321 if (n_hex_quads < ARRAY_LEN (hex_quads))
324 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
325 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
332 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
334 u32 *r = va_arg (*args, u32 *);
337 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
338 foreach_ipsec_policy_action
346 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
348 u32 *r = va_arg (*args, u32 *);
351 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
352 foreach_ipsec_crypto_alg
360 format_ipsec_crypto_alg (u8 * s, va_list * args)
362 u32 i = va_arg (*args, u32);
367 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
368 foreach_ipsec_crypto_alg
371 return format (s, "unknown");
373 return format (s, "%s", t);
377 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
379 u32 *r = va_arg (*args, u32 *);
382 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
383 foreach_ipsec_integ_alg
391 format_ipsec_integ_alg (u8 * s, va_list * args)
393 u32 i = va_arg (*args, u32);
398 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
399 foreach_ipsec_integ_alg
402 return format (s, "unknown");
404 return format (s, "%s", t);
408 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
410 u32 *r = va_arg (*args, u32 *);
413 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
414 foreach_ikev2_auth_method
422 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
424 u32 *r = va_arg (*args, u32 *);
427 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
428 foreach_ikev2_id_type
434 #else /* VPP_API_TEST_BUILTIN == 1 */
436 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
438 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
439 vnet_main_t *vnm = vnet_get_main ();
440 u32 *result = va_arg (*args, u32 *);
443 if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
446 *result = sw_if_index;
449 #endif /* VPP_API_TEST_BUILTIN */
452 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
454 u8 *r = va_arg (*args, u8 *);
456 if (unformat (input, "kbps"))
457 *r = SSE2_QOS_RATE_KBPS;
458 else if (unformat (input, "pps"))
459 *r = SSE2_QOS_RATE_PPS;
466 unformat_policer_round_type (unformat_input_t * input, va_list * args)
468 u8 *r = va_arg (*args, u8 *);
470 if (unformat (input, "closest"))
471 *r = SSE2_QOS_ROUND_TO_CLOSEST;
472 else if (unformat (input, "up"))
473 *r = SSE2_QOS_ROUND_TO_UP;
474 else if (unformat (input, "down"))
475 *r = SSE2_QOS_ROUND_TO_DOWN;
482 unformat_policer_type (unformat_input_t * input, va_list * args)
484 u8 *r = va_arg (*args, u8 *);
486 if (unformat (input, "1r2c"))
487 *r = SSE2_QOS_POLICER_TYPE_1R2C;
488 else if (unformat (input, "1r3c"))
489 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
490 else if (unformat (input, "2r3c-2698"))
491 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
492 else if (unformat (input, "2r3c-4115"))
493 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
494 else if (unformat (input, "2r3c-mef5cf1"))
495 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
502 unformat_dscp (unformat_input_t * input, va_list * va)
504 u8 *r = va_arg (*va, u8 *);
507 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
516 unformat_policer_action_type (unformat_input_t * input, va_list * va)
518 sse2_qos_pol_action_params_st *a
519 = va_arg (*va, sse2_qos_pol_action_params_st *);
521 if (unformat (input, "drop"))
522 a->action_type = SSE2_QOS_ACTION_DROP;
523 else if (unformat (input, "transmit"))
524 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
525 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
526 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
533 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
535 u32 *r = va_arg (*va, u32 *);
538 if (unformat (input, "ip4"))
539 tid = POLICER_CLASSIFY_TABLE_IP4;
540 else if (unformat (input, "ip6"))
541 tid = POLICER_CLASSIFY_TABLE_IP6;
542 else if (unformat (input, "l2"))
543 tid = POLICER_CLASSIFY_TABLE_L2;
552 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
554 u32 *r = va_arg (*va, u32 *);
557 if (unformat (input, "ip4"))
558 tid = FLOW_CLASSIFY_TABLE_IP4;
559 else if (unformat (input, "ip6"))
560 tid = FLOW_CLASSIFY_TABLE_IP6;
568 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
569 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
570 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
571 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
573 #if (VPP_API_TEST_BUILTIN==0)
575 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
577 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
578 mfib_itf_attribute_t attr;
581 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
583 if (unformat (input, mfib_itf_flag_long_names[attr]))
584 *iflags |= (1 << attr);
586 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
588 if (unformat (input, mfib_itf_flag_names[attr]))
589 *iflags |= (1 << attr);
592 return (old == *iflags ? 0 : 1);
596 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
598 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
599 mfib_entry_attribute_t attr;
602 FOR_EACH_MFIB_ATTRIBUTE (attr)
604 if (unformat (input, mfib_flag_long_names[attr]))
605 *eflags |= (1 << attr);
607 FOR_EACH_MFIB_ATTRIBUTE (attr)
609 if (unformat (input, mfib_flag_names[attr]))
610 *eflags |= (1 << attr);
613 return (old == *eflags ? 0 : 1);
617 format_ip4_address (u8 * s, va_list * args)
619 u8 *a = va_arg (*args, u8 *);
620 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
624 format_ip6_address (u8 * s, va_list * args)
626 ip6_address_t *a = va_arg (*args, ip6_address_t *);
627 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
629 i_max_n_zero = ARRAY_LEN (a->as_u16);
631 i_first_zero = i_max_n_zero;
633 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
635 u32 is_zero = a->as_u16[i] == 0;
636 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
642 if ((!is_zero && n_zeros > max_n_zeros)
643 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
645 i_max_n_zero = i_first_zero;
646 max_n_zeros = n_zeros;
647 i_first_zero = ARRAY_LEN (a->as_u16);
652 last_double_colon = 0;
653 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
655 if (i == i_max_n_zero && max_n_zeros > 1)
657 s = format (s, "::");
658 i += max_n_zeros - 1;
659 last_double_colon = 1;
663 s = format (s, "%s%x",
664 (last_double_colon || i == 0) ? "" : ":",
665 clib_net_to_host_u16 (a->as_u16[i]));
666 last_double_colon = 0;
673 /* Format an IP46 address. */
675 format_ip46_address (u8 * s, va_list * args)
677 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
678 ip46_type_t type = va_arg (*args, ip46_type_t);
684 is_ip4 = ip46_address_is_ip4 (ip46);
695 format (s, "%U", format_ip4_address, &ip46->ip4) :
696 format (s, "%U", format_ip6_address, &ip46->ip6);
700 format_ethernet_address (u8 * s, va_list * args)
702 u8 *a = va_arg (*args, u8 *);
704 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
705 a[0], a[1], a[2], a[3], a[4], a[5]);
710 increment_v4_address (ip4_address_t * a)
714 v = ntohl (a->as_u32) + 1;
715 a->as_u32 = ntohl (v);
719 increment_v6_address (ip6_address_t * a)
723 v0 = clib_net_to_host_u64 (a->as_u64[0]);
724 v1 = clib_net_to_host_u64 (a->as_u64[1]);
729 a->as_u64[0] = clib_net_to_host_u64 (v0);
730 a->as_u64[1] = clib_net_to_host_u64 (v1);
734 increment_mac_address (u8 * mac)
736 u64 tmp = *((u64 *) mac);
737 tmp = clib_net_to_host_u64 (tmp);
738 tmp += 1 << 16; /* skip unused (least significant) octets */
739 tmp = clib_host_to_net_u64 (tmp);
741 clib_memcpy (mac, &tmp, 6);
744 static void vl_api_create_loopback_reply_t_handler
745 (vl_api_create_loopback_reply_t * mp)
747 vat_main_t *vam = &vat_main;
748 i32 retval = ntohl (mp->retval);
750 vam->retval = retval;
751 vam->regenerate_interface_table = 1;
752 vam->sw_if_index = ntohl (mp->sw_if_index);
753 vam->result_ready = 1;
756 static void vl_api_create_loopback_reply_t_handler_json
757 (vl_api_create_loopback_reply_t * mp)
759 vat_main_t *vam = &vat_main;
760 vat_json_node_t node;
762 vat_json_init_object (&node);
763 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
764 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
766 vat_json_print (vam->ofp, &node);
767 vat_json_free (&node);
768 vam->retval = ntohl (mp->retval);
769 vam->result_ready = 1;
772 static void vl_api_create_loopback_instance_reply_t_handler
773 (vl_api_create_loopback_instance_reply_t * mp)
775 vat_main_t *vam = &vat_main;
776 i32 retval = ntohl (mp->retval);
778 vam->retval = retval;
779 vam->regenerate_interface_table = 1;
780 vam->sw_if_index = ntohl (mp->sw_if_index);
781 vam->result_ready = 1;
784 static void vl_api_create_loopback_instance_reply_t_handler_json
785 (vl_api_create_loopback_instance_reply_t * mp)
787 vat_main_t *vam = &vat_main;
788 vat_json_node_t node;
790 vat_json_init_object (&node);
791 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
792 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
794 vat_json_print (vam->ofp, &node);
795 vat_json_free (&node);
796 vam->retval = ntohl (mp->retval);
797 vam->result_ready = 1;
800 static void vl_api_af_packet_create_reply_t_handler
801 (vl_api_af_packet_create_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 i32 retval = ntohl (mp->retval);
806 vam->retval = retval;
807 vam->regenerate_interface_table = 1;
808 vam->sw_if_index = ntohl (mp->sw_if_index);
809 vam->result_ready = 1;
812 static void vl_api_af_packet_create_reply_t_handler_json
813 (vl_api_af_packet_create_reply_t * mp)
815 vat_main_t *vam = &vat_main;
816 vat_json_node_t node;
818 vat_json_init_object (&node);
819 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
820 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
822 vat_json_print (vam->ofp, &node);
823 vat_json_free (&node);
825 vam->retval = ntohl (mp->retval);
826 vam->result_ready = 1;
829 static void vl_api_create_vlan_subif_reply_t_handler
830 (vl_api_create_vlan_subif_reply_t * mp)
832 vat_main_t *vam = &vat_main;
833 i32 retval = ntohl (mp->retval);
835 vam->retval = retval;
836 vam->regenerate_interface_table = 1;
837 vam->sw_if_index = ntohl (mp->sw_if_index);
838 vam->result_ready = 1;
841 static void vl_api_create_vlan_subif_reply_t_handler_json
842 (vl_api_create_vlan_subif_reply_t * mp)
844 vat_main_t *vam = &vat_main;
845 vat_json_node_t node;
847 vat_json_init_object (&node);
848 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
849 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
851 vat_json_print (vam->ofp, &node);
852 vat_json_free (&node);
854 vam->retval = ntohl (mp->retval);
855 vam->result_ready = 1;
858 static void vl_api_create_subif_reply_t_handler
859 (vl_api_create_subif_reply_t * mp)
861 vat_main_t *vam = &vat_main;
862 i32 retval = ntohl (mp->retval);
864 vam->retval = retval;
865 vam->regenerate_interface_table = 1;
866 vam->sw_if_index = ntohl (mp->sw_if_index);
867 vam->result_ready = 1;
870 static void vl_api_create_subif_reply_t_handler_json
871 (vl_api_create_subif_reply_t * mp)
873 vat_main_t *vam = &vat_main;
874 vat_json_node_t node;
876 vat_json_init_object (&node);
877 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
878 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
880 vat_json_print (vam->ofp, &node);
881 vat_json_free (&node);
883 vam->retval = ntohl (mp->retval);
884 vam->result_ready = 1;
887 static void vl_api_interface_name_renumber_reply_t_handler
888 (vl_api_interface_name_renumber_reply_t * mp)
890 vat_main_t *vam = &vat_main;
891 i32 retval = ntohl (mp->retval);
893 vam->retval = retval;
894 vam->regenerate_interface_table = 1;
895 vam->result_ready = 1;
898 static void vl_api_interface_name_renumber_reply_t_handler_json
899 (vl_api_interface_name_renumber_reply_t * mp)
901 vat_main_t *vam = &vat_main;
902 vat_json_node_t node;
904 vat_json_init_object (&node);
905 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
907 vat_json_print (vam->ofp, &node);
908 vat_json_free (&node);
910 vam->retval = ntohl (mp->retval);
911 vam->result_ready = 1;
915 * Special-case: build the interface table, maintain
916 * the next loopback sw_if_index vbl.
918 static void vl_api_sw_interface_details_t_handler
919 (vl_api_sw_interface_details_t * mp)
921 vat_main_t *vam = &vat_main;
922 u8 *s = format (0, "%s%c", mp->interface_name, 0);
924 hash_set_mem (vam->sw_if_index_by_interface_name, s,
925 ntohl (mp->sw_if_index));
927 /* In sub interface case, fill the sub interface table entry */
928 if (mp->sw_if_index != mp->sup_sw_if_index)
930 sw_interface_subif_t *sub = NULL;
932 vec_add2 (vam->sw_if_subif_table, sub, 1);
934 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
935 strncpy ((char *) sub->interface_name, (char *) s,
936 vec_len (sub->interface_name));
937 sub->sw_if_index = ntohl (mp->sw_if_index);
938 sub->sub_id = ntohl (mp->sub_id);
940 sub->sub_dot1ad = mp->sub_dot1ad;
941 sub->sub_number_of_tags = mp->sub_number_of_tags;
942 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
943 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
944 sub->sub_exact_match = mp->sub_exact_match;
945 sub->sub_default = mp->sub_default;
946 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
947 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
949 /* vlan tag rewrite */
950 sub->vtr_op = ntohl (mp->vtr_op);
951 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
952 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
953 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
957 static void vl_api_sw_interface_details_t_handler_json
958 (vl_api_sw_interface_details_t * mp)
960 vat_main_t *vam = &vat_main;
961 vat_json_node_t *node = NULL;
963 if (VAT_JSON_ARRAY != vam->json_tree.type)
965 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
966 vat_json_init_array (&vam->json_tree);
968 node = vat_json_array_add (&vam->json_tree);
970 vat_json_init_object (node);
971 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
972 vat_json_object_add_uint (node, "sup_sw_if_index",
973 ntohl (mp->sup_sw_if_index));
974 vat_json_object_add_uint (node, "l2_address_length",
975 ntohl (mp->l2_address_length));
976 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
977 sizeof (mp->l2_address));
978 vat_json_object_add_string_copy (node, "interface_name",
980 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
981 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
982 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
983 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
984 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
985 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
986 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
987 vat_json_object_add_uint (node, "sub_number_of_tags",
988 mp->sub_number_of_tags);
989 vat_json_object_add_uint (node, "sub_outer_vlan_id",
990 ntohs (mp->sub_outer_vlan_id));
991 vat_json_object_add_uint (node, "sub_inner_vlan_id",
992 ntohs (mp->sub_inner_vlan_id));
993 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
994 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
995 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
996 mp->sub_outer_vlan_id_any);
997 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
998 mp->sub_inner_vlan_id_any);
999 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1000 vat_json_object_add_uint (node, "vtr_push_dot1q",
1001 ntohl (mp->vtr_push_dot1q));
1002 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1003 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1006 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1008 format_ethernet_address,
1010 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1012 format_ethernet_address,
1014 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1015 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1019 #if VPP_API_TEST_BUILTIN == 0
1020 static void vl_api_sw_interface_event_t_handler
1021 (vl_api_sw_interface_event_t * mp)
1023 vat_main_t *vam = &vat_main;
1024 if (vam->interface_event_display)
1025 errmsg ("interface flags: sw_if_index %d %s %s",
1026 ntohl (mp->sw_if_index),
1027 mp->admin_up_down ? "admin-up" : "admin-down",
1028 mp->link_up_down ? "link-up" : "link-down");
1032 static void vl_api_sw_interface_event_t_handler_json
1033 (vl_api_sw_interface_event_t * mp)
1035 /* JSON output not supported */
1039 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1041 vat_main_t *vam = &vat_main;
1042 i32 retval = ntohl (mp->retval);
1044 vam->retval = retval;
1045 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1046 vam->result_ready = 1;
1050 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1052 vat_main_t *vam = &vat_main;
1053 vat_json_node_t node;
1054 api_main_t *am = &api_main;
1058 vat_json_init_object (&node);
1059 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1060 vat_json_object_add_uint (&node, "reply_in_shmem",
1061 ntohl (mp->reply_in_shmem));
1062 /* Toss the shared-memory original... */
1063 pthread_mutex_lock (&am->vlib_rp->mutex);
1064 oldheap = svm_push_data_heap (am->vlib_rp);
1066 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1069 svm_pop_heap (oldheap);
1070 pthread_mutex_unlock (&am->vlib_rp->mutex);
1072 vat_json_print (vam->ofp, &node);
1073 vat_json_free (&node);
1075 vam->retval = ntohl (mp->retval);
1076 vam->result_ready = 1;
1080 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1082 vat_main_t *vam = &vat_main;
1083 i32 retval = ntohl (mp->retval);
1084 u32 length = ntohl (mp->length);
1086 vec_reset_length (vam->cmd_reply);
1088 vam->retval = retval;
1091 vec_validate (vam->cmd_reply, length);
1092 clib_memcpy ((char *) (vam->cmd_reply), mp->reply, length);
1093 vam->cmd_reply[length] = 0;
1095 vam->result_ready = 1;
1099 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1101 vat_main_t *vam = &vat_main;
1102 vat_json_node_t node;
1104 vec_reset_length (vam->cmd_reply);
1106 vat_json_init_object (&node);
1107 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1108 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1110 vat_json_print (vam->ofp, &node);
1111 vat_json_free (&node);
1113 vam->retval = ntohl (mp->retval);
1114 vam->result_ready = 1;
1117 static void vl_api_classify_add_del_table_reply_t_handler
1118 (vl_api_classify_add_del_table_reply_t * mp)
1120 vat_main_t *vam = &vat_main;
1121 i32 retval = ntohl (mp->retval);
1122 if (vam->async_mode)
1124 vam->async_errors += (retval < 0);
1128 vam->retval = retval;
1130 ((mp->new_table_index != 0xFFFFFFFF) ||
1131 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1132 (mp->match_n_vectors != 0xFFFFFFFF)))
1134 * Note: this is just barely thread-safe, depends on
1135 * the main thread spinning waiting for an answer...
1137 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1138 ntohl (mp->new_table_index),
1139 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1140 vam->result_ready = 1;
1144 static void vl_api_classify_add_del_table_reply_t_handler_json
1145 (vl_api_classify_add_del_table_reply_t * mp)
1147 vat_main_t *vam = &vat_main;
1148 vat_json_node_t node;
1150 vat_json_init_object (&node);
1151 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1152 vat_json_object_add_uint (&node, "new_table_index",
1153 ntohl (mp->new_table_index));
1154 vat_json_object_add_uint (&node, "skip_n_vectors",
1155 ntohl (mp->skip_n_vectors));
1156 vat_json_object_add_uint (&node, "match_n_vectors",
1157 ntohl (mp->match_n_vectors));
1159 vat_json_print (vam->ofp, &node);
1160 vat_json_free (&node);
1162 vam->retval = ntohl (mp->retval);
1163 vam->result_ready = 1;
1166 static void vl_api_get_node_index_reply_t_handler
1167 (vl_api_get_node_index_reply_t * mp)
1169 vat_main_t *vam = &vat_main;
1170 i32 retval = ntohl (mp->retval);
1171 if (vam->async_mode)
1173 vam->async_errors += (retval < 0);
1177 vam->retval = retval;
1179 errmsg ("node index %d", ntohl (mp->node_index));
1180 vam->result_ready = 1;
1184 static void vl_api_get_node_index_reply_t_handler_json
1185 (vl_api_get_node_index_reply_t * mp)
1187 vat_main_t *vam = &vat_main;
1188 vat_json_node_t node;
1190 vat_json_init_object (&node);
1191 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1192 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1194 vat_json_print (vam->ofp, &node);
1195 vat_json_free (&node);
1197 vam->retval = ntohl (mp->retval);
1198 vam->result_ready = 1;
1201 static void vl_api_get_next_index_reply_t_handler
1202 (vl_api_get_next_index_reply_t * mp)
1204 vat_main_t *vam = &vat_main;
1205 i32 retval = ntohl (mp->retval);
1206 if (vam->async_mode)
1208 vam->async_errors += (retval < 0);
1212 vam->retval = retval;
1214 errmsg ("next node index %d", ntohl (mp->next_index));
1215 vam->result_ready = 1;
1219 static void vl_api_get_next_index_reply_t_handler_json
1220 (vl_api_get_next_index_reply_t * mp)
1222 vat_main_t *vam = &vat_main;
1223 vat_json_node_t node;
1225 vat_json_init_object (&node);
1226 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1227 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1229 vat_json_print (vam->ofp, &node);
1230 vat_json_free (&node);
1232 vam->retval = ntohl (mp->retval);
1233 vam->result_ready = 1;
1236 static void vl_api_add_node_next_reply_t_handler
1237 (vl_api_add_node_next_reply_t * mp)
1239 vat_main_t *vam = &vat_main;
1240 i32 retval = ntohl (mp->retval);
1241 if (vam->async_mode)
1243 vam->async_errors += (retval < 0);
1247 vam->retval = retval;
1249 errmsg ("next index %d", ntohl (mp->next_index));
1250 vam->result_ready = 1;
1254 static void vl_api_add_node_next_reply_t_handler_json
1255 (vl_api_add_node_next_reply_t * mp)
1257 vat_main_t *vam = &vat_main;
1258 vat_json_node_t node;
1260 vat_json_init_object (&node);
1261 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1262 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1264 vat_json_print (vam->ofp, &node);
1265 vat_json_free (&node);
1267 vam->retval = ntohl (mp->retval);
1268 vam->result_ready = 1;
1271 static void vl_api_show_version_reply_t_handler
1272 (vl_api_show_version_reply_t * mp)
1274 vat_main_t *vam = &vat_main;
1275 i32 retval = ntohl (mp->retval);
1279 errmsg (" program: %s", mp->program);
1280 errmsg (" version: %s", mp->version);
1281 errmsg (" build date: %s", mp->build_date);
1282 errmsg ("build directory: %s", mp->build_directory);
1284 vam->retval = retval;
1285 vam->result_ready = 1;
1288 static void vl_api_show_version_reply_t_handler_json
1289 (vl_api_show_version_reply_t * mp)
1291 vat_main_t *vam = &vat_main;
1292 vat_json_node_t node;
1294 vat_json_init_object (&node);
1295 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1296 vat_json_object_add_string_copy (&node, "program", mp->program);
1297 vat_json_object_add_string_copy (&node, "version", mp->version);
1298 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1299 vat_json_object_add_string_copy (&node, "build_directory",
1300 mp->build_directory);
1302 vat_json_print (vam->ofp, &node);
1303 vat_json_free (&node);
1305 vam->retval = ntohl (mp->retval);
1306 vam->result_ready = 1;
1310 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1312 u32 sw_if_index = ntohl (mp->sw_if_index);
1313 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1314 mp->mac_ip ? "mac/ip binding" : "address resolution",
1315 ntohl (mp->pid), format_ip4_address, &mp->address,
1316 format_ethernet_address, mp->new_mac, sw_if_index);
1320 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1322 /* JSON output not supported */
1326 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1328 u32 sw_if_index = ntohl (mp->sw_if_index);
1329 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1330 mp->mac_ip ? "mac/ip binding" : "address resolution",
1331 ntohl (mp->pid), format_ip6_address, mp->address,
1332 format_ethernet_address, mp->new_mac, sw_if_index);
1336 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1338 /* JSON output not supported */
1342 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1344 u32 n_macs = ntohl (mp->n_macs);
1345 errmsg ("L2MAC event recived with pid %d cl-idx %d for %d macs: \n",
1346 ntohl (mp->pid), mp->client_index, n_macs);
1348 for (i = 0; i < n_macs; i++)
1350 vl_api_mac_entry_t *mac = &mp->mac[i];
1351 errmsg (" [%d] sw_if_index %d mac_addr %U is_del %d \n",
1352 i + 1, ntohl (mac->sw_if_index),
1353 format_ethernet_address, mac->mac_addr, mac->is_del);
1360 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1362 /* JSON output not supported */
1365 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1366 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1369 * Special-case: build the bridge domain table, maintain
1370 * the next bd id vbl.
1372 static void vl_api_bridge_domain_details_t_handler
1373 (vl_api_bridge_domain_details_t * mp)
1375 vat_main_t *vam = &vat_main;
1376 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1379 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1380 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1382 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1383 ntohl (mp->bd_id), mp->learn, mp->forward,
1384 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1388 vl_api_bridge_domain_sw_if_t *sw_ifs;
1389 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1392 sw_ifs = mp->sw_if_details;
1393 for (i = 0; i < n_sw_ifs; i++)
1399 sw_if_index = ntohl (sw_ifs->sw_if_index);
1402 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1404 if ((u32) p->value[0] == sw_if_index)
1406 sw_if_name = (u8 *)(p->key);
1411 print (vam->ofp, "%7d %3d %s", sw_if_index,
1412 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1413 "sw_if_index not found!");
1420 static void vl_api_bridge_domain_details_t_handler_json
1421 (vl_api_bridge_domain_details_t * mp)
1423 vat_main_t *vam = &vat_main;
1424 vat_json_node_t *node, *array = NULL;
1425 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1427 if (VAT_JSON_ARRAY != vam->json_tree.type)
1429 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1430 vat_json_init_array (&vam->json_tree);
1432 node = vat_json_array_add (&vam->json_tree);
1434 vat_json_init_object (node);
1435 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1436 vat_json_object_add_uint (node, "flood", mp->flood);
1437 vat_json_object_add_uint (node, "forward", mp->forward);
1438 vat_json_object_add_uint (node, "learn", mp->learn);
1439 vat_json_object_add_uint (node, "bvi_sw_if_index",
1440 ntohl (mp->bvi_sw_if_index));
1441 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1442 array = vat_json_object_add (node, "sw_if");
1443 vat_json_init_array (array);
1449 vl_api_bridge_domain_sw_if_t *sw_ifs;
1452 sw_ifs = mp->sw_if_details;
1453 for (i = 0; i < n_sw_ifs; i++)
1455 node = vat_json_array_add (array);
1456 vat_json_init_object (node);
1457 vat_json_object_add_uint (node, "sw_if_index",
1458 ntohl (sw_ifs->sw_if_index));
1459 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1465 static void vl_api_control_ping_reply_t_handler
1466 (vl_api_control_ping_reply_t * mp)
1468 vat_main_t *vam = &vat_main;
1469 i32 retval = ntohl (mp->retval);
1470 if (vam->async_mode)
1472 vam->async_errors += (retval < 0);
1476 vam->retval = retval;
1477 vam->result_ready = 1;
1479 if (vam->socket_client_main)
1480 vam->socket_client_main->control_pings_outstanding--;
1483 static void vl_api_control_ping_reply_t_handler_json
1484 (vl_api_control_ping_reply_t * mp)
1486 vat_main_t *vam = &vat_main;
1487 i32 retval = ntohl (mp->retval);
1489 if (VAT_JSON_NONE != vam->json_tree.type)
1491 vat_json_print (vam->ofp, &vam->json_tree);
1492 vat_json_free (&vam->json_tree);
1493 vam->json_tree.type = VAT_JSON_NONE;
1498 vat_json_init_array (&vam->json_tree);
1499 vat_json_print (vam->ofp, &vam->json_tree);
1500 vam->json_tree.type = VAT_JSON_NONE;
1503 vam->retval = retval;
1504 vam->result_ready = 1;
1508 vl_api_bridge_domain_set_mac_age_reply_t_handler
1509 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1511 vat_main_t *vam = &vat_main;
1512 i32 retval = ntohl (mp->retval);
1513 if (vam->async_mode)
1515 vam->async_errors += (retval < 0);
1519 vam->retval = retval;
1520 vam->result_ready = 1;
1524 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1525 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1527 vat_main_t *vam = &vat_main;
1528 vat_json_node_t node;
1530 vat_json_init_object (&node);
1531 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1533 vat_json_print (vam->ofp, &node);
1534 vat_json_free (&node);
1536 vam->retval = ntohl (mp->retval);
1537 vam->result_ready = 1;
1541 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1543 vat_main_t *vam = &vat_main;
1544 i32 retval = ntohl (mp->retval);
1545 if (vam->async_mode)
1547 vam->async_errors += (retval < 0);
1551 vam->retval = retval;
1552 vam->result_ready = 1;
1556 static void vl_api_l2_flags_reply_t_handler_json
1557 (vl_api_l2_flags_reply_t * mp)
1559 vat_main_t *vam = &vat_main;
1560 vat_json_node_t node;
1562 vat_json_init_object (&node);
1563 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1564 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1565 ntohl (mp->resulting_feature_bitmap));
1567 vat_json_print (vam->ofp, &node);
1568 vat_json_free (&node);
1570 vam->retval = ntohl (mp->retval);
1571 vam->result_ready = 1;
1574 static void vl_api_bridge_flags_reply_t_handler
1575 (vl_api_bridge_flags_reply_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 i32 retval = ntohl (mp->retval);
1579 if (vam->async_mode)
1581 vam->async_errors += (retval < 0);
1585 vam->retval = retval;
1586 vam->result_ready = 1;
1590 static void vl_api_bridge_flags_reply_t_handler_json
1591 (vl_api_bridge_flags_reply_t * mp)
1593 vat_main_t *vam = &vat_main;
1594 vat_json_node_t node;
1596 vat_json_init_object (&node);
1597 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1598 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1599 ntohl (mp->resulting_feature_bitmap));
1601 vat_json_print (vam->ofp, &node);
1602 vat_json_free (&node);
1604 vam->retval = ntohl (mp->retval);
1605 vam->result_ready = 1;
1608 static void vl_api_tap_connect_reply_t_handler
1609 (vl_api_tap_connect_reply_t * mp)
1611 vat_main_t *vam = &vat_main;
1612 i32 retval = ntohl (mp->retval);
1613 if (vam->async_mode)
1615 vam->async_errors += (retval < 0);
1619 vam->retval = retval;
1620 vam->sw_if_index = ntohl (mp->sw_if_index);
1621 vam->result_ready = 1;
1626 static void vl_api_tap_connect_reply_t_handler_json
1627 (vl_api_tap_connect_reply_t * mp)
1629 vat_main_t *vam = &vat_main;
1630 vat_json_node_t node;
1632 vat_json_init_object (&node);
1633 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1634 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1636 vat_json_print (vam->ofp, &node);
1637 vat_json_free (&node);
1639 vam->retval = ntohl (mp->retval);
1640 vam->result_ready = 1;
1645 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1647 vat_main_t *vam = &vat_main;
1648 i32 retval = ntohl (mp->retval);
1649 if (vam->async_mode)
1651 vam->async_errors += (retval < 0);
1655 vam->retval = retval;
1656 vam->sw_if_index = ntohl (mp->sw_if_index);
1657 vam->result_ready = 1;
1661 static void vl_api_tap_modify_reply_t_handler_json
1662 (vl_api_tap_modify_reply_t * mp)
1664 vat_main_t *vam = &vat_main;
1665 vat_json_node_t node;
1667 vat_json_init_object (&node);
1668 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1669 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1671 vat_json_print (vam->ofp, &node);
1672 vat_json_free (&node);
1674 vam->retval = ntohl (mp->retval);
1675 vam->result_ready = 1;
1679 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1681 vat_main_t *vam = &vat_main;
1682 i32 retval = ntohl (mp->retval);
1683 if (vam->async_mode)
1685 vam->async_errors += (retval < 0);
1689 vam->retval = retval;
1690 vam->result_ready = 1;
1694 static void vl_api_tap_delete_reply_t_handler_json
1695 (vl_api_tap_delete_reply_t * mp)
1697 vat_main_t *vam = &vat_main;
1698 vat_json_node_t node;
1700 vat_json_init_object (&node);
1701 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1703 vat_json_print (vam->ofp, &node);
1704 vat_json_free (&node);
1706 vam->retval = ntohl (mp->retval);
1707 vam->result_ready = 1;
1711 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1713 vat_main_t *vam = &vat_main;
1714 i32 retval = ntohl (mp->retval);
1715 if (vam->async_mode)
1717 vam->async_errors += (retval < 0);
1721 vam->retval = retval;
1722 vam->sw_if_index = ntohl (mp->sw_if_index);
1723 vam->result_ready = 1;
1728 static void vl_api_tap_create_v2_reply_t_handler_json
1729 (vl_api_tap_create_v2_reply_t * mp)
1731 vat_main_t *vam = &vat_main;
1732 vat_json_node_t node;
1734 vat_json_init_object (&node);
1735 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1736 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1738 vat_json_print (vam->ofp, &node);
1739 vat_json_free (&node);
1741 vam->retval = ntohl (mp->retval);
1742 vam->result_ready = 1;
1747 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1749 vat_main_t *vam = &vat_main;
1750 i32 retval = ntohl (mp->retval);
1751 if (vam->async_mode)
1753 vam->async_errors += (retval < 0);
1757 vam->retval = retval;
1758 vam->result_ready = 1;
1762 static void vl_api_tap_delete_v2_reply_t_handler_json
1763 (vl_api_tap_delete_v2_reply_t * mp)
1765 vat_main_t *vam = &vat_main;
1766 vat_json_node_t node;
1768 vat_json_init_object (&node);
1769 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1771 vat_json_print (vam->ofp, &node);
1772 vat_json_free (&node);
1774 vam->retval = ntohl (mp->retval);
1775 vam->result_ready = 1;
1778 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1779 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1781 vat_main_t *vam = &vat_main;
1782 i32 retval = ntohl (mp->retval);
1783 if (vam->async_mode)
1785 vam->async_errors += (retval < 0);
1789 vam->retval = retval;
1790 vam->result_ready = 1;
1794 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1795 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1797 vat_main_t *vam = &vat_main;
1798 vat_json_node_t node;
1800 vat_json_init_object (&node);
1801 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1802 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1803 ntohl (mp->sw_if_index));
1805 vat_json_print (vam->ofp, &node);
1806 vat_json_free (&node);
1808 vam->retval = ntohl (mp->retval);
1809 vam->result_ready = 1;
1812 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1813 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1815 vat_main_t *vam = &vat_main;
1816 i32 retval = ntohl (mp->retval);
1817 if (vam->async_mode)
1819 vam->async_errors += (retval < 0);
1823 vam->retval = retval;
1824 vam->sw_if_index = ntohl (mp->sw_if_index);
1825 vam->result_ready = 1;
1829 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1830 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1832 vat_main_t *vam = &vat_main;
1833 vat_json_node_t node;
1835 vat_json_init_object (&node);
1836 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1837 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1839 vat_json_print (vam->ofp, &node);
1840 vat_json_free (&node);
1842 vam->retval = ntohl (mp->retval);
1843 vam->result_ready = 1;
1846 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
1847 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1849 vat_main_t *vam = &vat_main;
1850 i32 retval = ntohl (mp->retval);
1851 if (vam->async_mode)
1853 vam->async_errors += (retval < 0);
1857 vam->retval = retval;
1858 vam->result_ready = 1;
1862 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
1863 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
1865 vat_main_t *vam = &vat_main;
1866 vat_json_node_t node;
1868 vat_json_init_object (&node);
1869 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1870 vat_json_object_add_uint (&node, "fwd_entry_index",
1871 clib_net_to_host_u32 (mp->fwd_entry_index));
1873 vat_json_print (vam->ofp, &node);
1874 vat_json_free (&node);
1876 vam->retval = ntohl (mp->retval);
1877 vam->result_ready = 1;
1881 format_lisp_transport_protocol (u8 * s, va_list * args)
1883 u32 proto = va_arg (*args, u32);
1888 return format (s, "udp");
1890 return format (s, "api");
1897 static void vl_api_one_get_transport_protocol_reply_t_handler
1898 (vl_api_one_get_transport_protocol_reply_t * mp)
1900 vat_main_t *vam = &vat_main;
1901 i32 retval = ntohl (mp->retval);
1902 if (vam->async_mode)
1904 vam->async_errors += (retval < 0);
1908 u32 proto = mp->protocol;
1909 print (vam->ofp, "Transport protocol: %U",
1910 format_lisp_transport_protocol, proto);
1911 vam->retval = retval;
1912 vam->result_ready = 1;
1916 static void vl_api_one_get_transport_protocol_reply_t_handler_json
1917 (vl_api_one_get_transport_protocol_reply_t * mp)
1919 vat_main_t *vam = &vat_main;
1920 vat_json_node_t node;
1923 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
1926 vat_json_init_object (&node);
1927 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1928 vat_json_object_add_string_copy (&node, "transport-protocol", s);
1931 vat_json_print (vam->ofp, &node);
1932 vat_json_free (&node);
1934 vam->retval = ntohl (mp->retval);
1935 vam->result_ready = 1;
1938 static void vl_api_one_add_del_locator_set_reply_t_handler
1939 (vl_api_one_add_del_locator_set_reply_t * mp)
1941 vat_main_t *vam = &vat_main;
1942 i32 retval = ntohl (mp->retval);
1943 if (vam->async_mode)
1945 vam->async_errors += (retval < 0);
1949 vam->retval = retval;
1950 vam->result_ready = 1;
1954 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1955 (vl_api_one_add_del_locator_set_reply_t * mp)
1957 vat_main_t *vam = &vat_main;
1958 vat_json_node_t node;
1960 vat_json_init_object (&node);
1961 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1962 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1964 vat_json_print (vam->ofp, &node);
1965 vat_json_free (&node);
1967 vam->retval = ntohl (mp->retval);
1968 vam->result_ready = 1;
1971 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1972 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1974 vat_main_t *vam = &vat_main;
1975 i32 retval = ntohl (mp->retval);
1976 if (vam->async_mode)
1978 vam->async_errors += (retval < 0);
1982 vam->retval = retval;
1983 vam->sw_if_index = ntohl (mp->sw_if_index);
1984 vam->result_ready = 1;
1986 vam->regenerate_interface_table = 1;
1989 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1990 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1992 vat_main_t *vam = &vat_main;
1993 vat_json_node_t node;
1995 vat_json_init_object (&node);
1996 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1997 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1999 vat_json_print (vam->ofp, &node);
2000 vat_json_free (&node);
2002 vam->retval = ntohl (mp->retval);
2003 vam->result_ready = 1;
2006 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2007 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2009 vat_main_t *vam = &vat_main;
2010 i32 retval = ntohl (mp->retval);
2011 if (vam->async_mode)
2013 vam->async_errors += (retval < 0);
2017 vam->retval = retval;
2018 vam->sw_if_index = ntohl (mp->sw_if_index);
2019 vam->result_ready = 1;
2023 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2024 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2026 vat_main_t *vam = &vat_main;
2027 vat_json_node_t node;
2029 vat_json_init_object (&node);
2030 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2031 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2033 vat_json_print (vam->ofp, &node);
2034 vat_json_free (&node);
2036 vam->retval = ntohl (mp->retval);
2037 vam->result_ready = 1;
2040 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2041 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2043 vat_main_t *vam = &vat_main;
2044 i32 retval = ntohl (mp->retval);
2045 if (vam->async_mode)
2047 vam->async_errors += (retval < 0);
2051 vam->retval = retval;
2052 vam->sw_if_index = ntohl (mp->sw_if_index);
2053 vam->result_ready = 1;
2055 vam->regenerate_interface_table = 1;
2058 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2059 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2061 vat_main_t *vam = &vat_main;
2062 vat_json_node_t node;
2064 vat_json_init_object (&node);
2065 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2066 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2068 vat_json_print (vam->ofp, &node);
2069 vat_json_free (&node);
2071 vam->retval = ntohl (mp->retval);
2072 vam->result_ready = 1;
2075 static void vl_api_gre_add_del_tunnel_reply_t_handler
2076 (vl_api_gre_add_del_tunnel_reply_t * mp)
2078 vat_main_t *vam = &vat_main;
2079 i32 retval = ntohl (mp->retval);
2080 if (vam->async_mode)
2082 vam->async_errors += (retval < 0);
2086 vam->retval = retval;
2087 vam->sw_if_index = ntohl (mp->sw_if_index);
2088 vam->result_ready = 1;
2092 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2093 (vl_api_gre_add_del_tunnel_reply_t * mp)
2095 vat_main_t *vam = &vat_main;
2096 vat_json_node_t node;
2098 vat_json_init_object (&node);
2099 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2100 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2102 vat_json_print (vam->ofp, &node);
2103 vat_json_free (&node);
2105 vam->retval = ntohl (mp->retval);
2106 vam->result_ready = 1;
2109 static void vl_api_create_vhost_user_if_reply_t_handler
2110 (vl_api_create_vhost_user_if_reply_t * mp)
2112 vat_main_t *vam = &vat_main;
2113 i32 retval = ntohl (mp->retval);
2114 if (vam->async_mode)
2116 vam->async_errors += (retval < 0);
2120 vam->retval = retval;
2121 vam->sw_if_index = ntohl (mp->sw_if_index);
2122 vam->result_ready = 1;
2124 vam->regenerate_interface_table = 1;
2127 static void vl_api_create_vhost_user_if_reply_t_handler_json
2128 (vl_api_create_vhost_user_if_reply_t * mp)
2130 vat_main_t *vam = &vat_main;
2131 vat_json_node_t node;
2133 vat_json_init_object (&node);
2134 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2135 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2137 vat_json_print (vam->ofp, &node);
2138 vat_json_free (&node);
2140 vam->retval = ntohl (mp->retval);
2141 vam->result_ready = 1;
2144 static clib_error_t *
2145 receive_fd_msg (int socket_fd, int *my_fd)
2148 char ctl[CMSG_SPACE (sizeof (int)) + CMSG_SPACE (sizeof (struct ucred))];
2149 struct msghdr mh = { 0 };
2150 struct iovec iov[1];
2152 struct ucred *cr = 0;
2153 struct cmsghdr *cmsg;
2154 pid_t pid __attribute__ ((unused));
2155 uid_t uid __attribute__ ((unused));
2156 gid_t gid __attribute__ ((unused));
2158 iov[0].iov_base = msgbuf;
2162 mh.msg_control = ctl;
2163 mh.msg_controllen = sizeof (ctl);
2165 memset (ctl, 0, sizeof (ctl));
2167 /* receive the incoming message */
2168 size = recvmsg (socket_fd, &mh, 0);
2171 return (size == 0) ? clib_error_return (0, "disconnected") :
2172 clib_error_return_unix (0, "recvmsg: malformed message (fd %d)",
2176 cmsg = CMSG_FIRSTHDR (&mh);
2179 if (cmsg->cmsg_level == SOL_SOCKET)
2181 if (cmsg->cmsg_type == SCM_CREDENTIALS)
2183 cr = (struct ucred *) CMSG_DATA (cmsg);
2188 else if (cmsg->cmsg_type == SCM_RIGHTS)
2190 clib_memcpy (my_fd, CMSG_DATA (cmsg), sizeof (int));
2193 cmsg = CMSG_NXTHDR (&mh, cmsg);
2198 static void vl_api_memfd_segment_create_reply_t_handler
2199 (vl_api_memfd_segment_create_reply_t * mp)
2201 /* Dont bother in the builtin version */
2202 #if VPP_API_TEST_BUILTIN == 0
2203 vat_main_t *vam = &vat_main;
2204 api_main_t *am = &api_main;
2205 socket_client_main_t *scm = vam->socket_client_main;
2207 clib_error_t *error;
2208 ssvm_private_t memfd;
2209 i32 retval = ntohl (mp->retval);
2213 error = receive_fd_msg (scm->socket_fd, &my_fd);
2220 memset (&memfd, 0, sizeof (memfd));
2223 vam->client_index_invalid = 1;
2225 /* Note: this closes memfd.fd */
2226 retval = ssvm_slave_init_memfd (&memfd);
2228 clib_warning ("WARNING: segment map returned %d", retval);
2230 /* Pivot to the memory client segment that vpp just created */
2232 am->vlib_rp = (void *) (memfd.requested_va + MMAP_PAGESIZE);
2234 am->shmem_hdr = (void *) am->vlib_rp->user_ctx;
2236 vl_client_install_client_message_handlers ();
2238 vl_client_connect_to_vlib_no_map ("pvt",
2240 32 /* input_queue_length */ );
2241 vam->vl_input_queue = am->shmem_hdr->vl_input_queue;
2243 vl_socket_client_enable_disable (0 /* disable socket */ );
2247 if (vam->async_mode)
2249 vam->async_errors += (retval < 0);
2253 vam->retval = retval;
2254 vam->result_ready = 1;
2259 static void vl_api_memfd_segment_create_reply_t_handler_json
2260 (vl_api_memfd_segment_create_reply_t * mp)
2262 clib_warning ("no");
2265 static void vl_api_dns_resolve_name_reply_t_handler
2266 (vl_api_dns_resolve_name_reply_t * mp)
2268 vat_main_t *vam = &vat_main;
2269 i32 retval = ntohl (mp->retval);
2270 if (vam->async_mode)
2272 vam->async_errors += (retval < 0);
2276 vam->retval = retval;
2277 vam->result_ready = 1;
2282 clib_warning ("ip4 address %U", format_ip4_address,
2283 (ip4_address_t *) mp->ip4_address);
2285 clib_warning ("ip6 address %U", format_ip6_address,
2286 (ip6_address_t *) mp->ip6_address);
2289 clib_warning ("retval %d", retval);
2293 static void vl_api_dns_resolve_name_reply_t_handler_json
2294 (vl_api_dns_resolve_name_reply_t * mp)
2296 clib_warning ("not implemented");
2299 static void vl_api_dns_resolve_ip_reply_t_handler
2300 (vl_api_dns_resolve_ip_reply_t * mp)
2302 vat_main_t *vam = &vat_main;
2303 i32 retval = ntohl (mp->retval);
2304 if (vam->async_mode)
2306 vam->async_errors += (retval < 0);
2310 vam->retval = retval;
2311 vam->result_ready = 1;
2315 clib_warning ("canonical name %s", mp->name);
2318 clib_warning ("retval %d", retval);
2322 static void vl_api_dns_resolve_ip_reply_t_handler_json
2323 (vl_api_dns_resolve_ip_reply_t * mp)
2325 clib_warning ("not implemented");
2329 static void vl_api_ip_address_details_t_handler
2330 (vl_api_ip_address_details_t * mp)
2332 vat_main_t *vam = &vat_main;
2333 static ip_address_details_t empty_ip_address_details = { {0} };
2334 ip_address_details_t *address = NULL;
2335 ip_details_t *current_ip_details = NULL;
2336 ip_details_t *details = NULL;
2338 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2340 if (!details || vam->current_sw_if_index >= vec_len (details)
2341 || !details[vam->current_sw_if_index].present)
2343 errmsg ("ip address details arrived but not stored");
2344 errmsg ("ip_dump should be called first");
2348 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2350 #define addresses (current_ip_details->addr)
2352 vec_validate_init_empty (addresses, vec_len (addresses),
2353 empty_ip_address_details);
2355 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2357 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2358 address->prefix_length = mp->prefix_length;
2362 static void vl_api_ip_address_details_t_handler_json
2363 (vl_api_ip_address_details_t * mp)
2365 vat_main_t *vam = &vat_main;
2366 vat_json_node_t *node = NULL;
2367 struct in6_addr ip6;
2370 if (VAT_JSON_ARRAY != vam->json_tree.type)
2372 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2373 vat_json_init_array (&vam->json_tree);
2375 node = vat_json_array_add (&vam->json_tree);
2377 vat_json_init_object (node);
2380 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2381 vat_json_object_add_ip6 (node, "ip", ip6);
2385 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2386 vat_json_object_add_ip4 (node, "ip", ip4);
2388 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2392 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2394 vat_main_t *vam = &vat_main;
2395 static ip_details_t empty_ip_details = { 0 };
2396 ip_details_t *ip = NULL;
2397 u32 sw_if_index = ~0;
2399 sw_if_index = ntohl (mp->sw_if_index);
2401 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2402 sw_if_index, empty_ip_details);
2404 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2411 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2413 vat_main_t *vam = &vat_main;
2415 if (VAT_JSON_ARRAY != vam->json_tree.type)
2417 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2418 vat_json_init_array (&vam->json_tree);
2420 vat_json_array_add_uint (&vam->json_tree,
2421 clib_net_to_host_u32 (mp->sw_if_index));
2424 static void vl_api_map_domain_details_t_handler_json
2425 (vl_api_map_domain_details_t * mp)
2427 vat_json_node_t *node = NULL;
2428 vat_main_t *vam = &vat_main;
2429 struct in6_addr ip6;
2432 if (VAT_JSON_ARRAY != vam->json_tree.type)
2434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2435 vat_json_init_array (&vam->json_tree);
2438 node = vat_json_array_add (&vam->json_tree);
2439 vat_json_init_object (node);
2441 vat_json_object_add_uint (node, "domain_index",
2442 clib_net_to_host_u32 (mp->domain_index));
2443 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
2444 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
2445 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
2446 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
2447 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
2448 vat_json_object_add_ip6 (node, "ip6_src", ip6);
2449 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
2450 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
2451 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
2452 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
2453 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
2454 vat_json_object_add_int (node, "psid_length", mp->psid_length);
2455 vat_json_object_add_uint (node, "flags", mp->flags);
2456 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
2457 vat_json_object_add_int (node, "is_translation", mp->is_translation);
2460 static void vl_api_map_domain_details_t_handler
2461 (vl_api_map_domain_details_t * mp)
2463 vat_main_t *vam = &vat_main;
2465 if (mp->is_translation)
2468 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2469 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2470 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2471 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2472 clib_net_to_host_u32 (mp->domain_index));
2477 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2478 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2479 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2480 format_ip6_address, mp->ip6_src,
2481 clib_net_to_host_u32 (mp->domain_index));
2483 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2484 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2485 mp->is_translation ? "map-t" : "");
2488 static void vl_api_map_rule_details_t_handler_json
2489 (vl_api_map_rule_details_t * mp)
2491 struct in6_addr ip6;
2492 vat_json_node_t *node = NULL;
2493 vat_main_t *vam = &vat_main;
2495 if (VAT_JSON_ARRAY != vam->json_tree.type)
2497 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2498 vat_json_init_array (&vam->json_tree);
2501 node = vat_json_array_add (&vam->json_tree);
2502 vat_json_init_object (node);
2504 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2505 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2506 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2510 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2512 vat_main_t *vam = &vat_main;
2513 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2514 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2518 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2520 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2521 "router_addr %U host_mac %U",
2522 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2523 format_ip4_address, &mp->host_address,
2524 format_ip4_address, &mp->router_address,
2525 format_ethernet_address, mp->host_mac);
2528 static void vl_api_dhcp_compl_event_t_handler_json
2529 (vl_api_dhcp_compl_event_t * mp)
2531 /* JSON output not supported */
2535 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2538 vat_main_t *vam = &vat_main;
2539 static u64 default_counter = 0;
2541 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2543 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2544 sw_if_index, default_counter);
2545 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2549 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2550 interface_counter_t counter)
2552 vat_main_t *vam = &vat_main;
2553 static interface_counter_t default_counter = { 0, };
2555 vec_validate_init_empty (vam->combined_interface_counters,
2556 vnet_counter_type, NULL);
2557 vec_validate_init_empty (vam->combined_interface_counters
2558 [vnet_counter_type], sw_if_index, default_counter);
2559 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2562 static void vl_api_vnet_interface_simple_counters_t_handler
2563 (vl_api_vnet_interface_simple_counters_t * mp)
2568 static void vl_api_vnet_interface_combined_counters_t_handler
2569 (vl_api_vnet_interface_combined_counters_t * mp)
2574 static void vl_api_vnet_interface_simple_counters_t_handler_json
2575 (vl_api_vnet_interface_simple_counters_t * mp)
2580 u32 first_sw_if_index;
2583 count = ntohl (mp->count);
2584 first_sw_if_index = ntohl (mp->first_sw_if_index);
2586 v_packets = (u64 *) & mp->data;
2587 for (i = 0; i < count; i++)
2589 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2590 set_simple_interface_counter (mp->vnet_counter_type,
2591 first_sw_if_index + i, packets);
2596 static void vl_api_vnet_interface_combined_counters_t_handler_json
2597 (vl_api_vnet_interface_combined_counters_t * mp)
2599 interface_counter_t counter;
2601 u32 first_sw_if_index;
2605 count = ntohl (mp->count);
2606 first_sw_if_index = ntohl (mp->first_sw_if_index);
2608 v = (vlib_counter_t *) & mp->data;
2609 for (i = 0; i < count; i++)
2612 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2614 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2615 set_combined_interface_counter (mp->vnet_counter_type,
2616 first_sw_if_index + i, counter);
2622 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2624 vat_main_t *vam = &vat_main;
2627 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2629 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2638 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2640 vat_main_t *vam = &vat_main;
2643 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2645 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2653 static void vl_api_vnet_ip4_fib_counters_t_handler
2654 (vl_api_vnet_ip4_fib_counters_t * mp)
2659 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2660 (vl_api_vnet_ip4_fib_counters_t * mp)
2662 vat_main_t *vam = &vat_main;
2663 vl_api_ip4_fib_counter_t *v;
2664 ip4_fib_counter_t *counter;
2671 vrf_id = ntohl (mp->vrf_id);
2672 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2673 if (~0 == vrf_index)
2675 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2676 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2677 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2678 vec_validate (vam->ip4_fib_counters, vrf_index);
2679 vam->ip4_fib_counters[vrf_index] = NULL;
2682 vec_free (vam->ip4_fib_counters[vrf_index]);
2683 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2684 count = ntohl (mp->count);
2685 for (i = 0; i < count; i++)
2687 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2688 counter = &vam->ip4_fib_counters[vrf_index][i];
2689 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2690 counter->address = ip4;
2691 counter->address_length = v->address_length;
2692 counter->packets = clib_net_to_host_u64 (v->packets);
2693 counter->bytes = clib_net_to_host_u64 (v->bytes);
2698 static void vl_api_vnet_ip4_nbr_counters_t_handler
2699 (vl_api_vnet_ip4_nbr_counters_t * mp)
2704 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2705 (vl_api_vnet_ip4_nbr_counters_t * mp)
2707 vat_main_t *vam = &vat_main;
2708 vl_api_ip4_nbr_counter_t *v;
2709 ip4_nbr_counter_t *counter;
2714 sw_if_index = ntohl (mp->sw_if_index);
2715 count = ntohl (mp->count);
2716 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2719 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2721 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2722 for (i = 0; i < count; i++)
2724 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2725 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2726 counter->address.s_addr = v->address;
2727 counter->packets = clib_net_to_host_u64 (v->packets);
2728 counter->bytes = clib_net_to_host_u64 (v->bytes);
2729 counter->linkt = v->link_type;
2734 static void vl_api_vnet_ip6_fib_counters_t_handler
2735 (vl_api_vnet_ip6_fib_counters_t * mp)
2740 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2741 (vl_api_vnet_ip6_fib_counters_t * mp)
2743 vat_main_t *vam = &vat_main;
2744 vl_api_ip6_fib_counter_t *v;
2745 ip6_fib_counter_t *counter;
2746 struct in6_addr ip6;
2752 vrf_id = ntohl (mp->vrf_id);
2753 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2754 if (~0 == vrf_index)
2756 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2757 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2758 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2759 vec_validate (vam->ip6_fib_counters, vrf_index);
2760 vam->ip6_fib_counters[vrf_index] = NULL;
2763 vec_free (vam->ip6_fib_counters[vrf_index]);
2764 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2765 count = ntohl (mp->count);
2766 for (i = 0; i < count; i++)
2768 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2769 counter = &vam->ip6_fib_counters[vrf_index][i];
2770 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2771 counter->address = ip6;
2772 counter->address_length = v->address_length;
2773 counter->packets = clib_net_to_host_u64 (v->packets);
2774 counter->bytes = clib_net_to_host_u64 (v->bytes);
2779 static void vl_api_vnet_ip6_nbr_counters_t_handler
2780 (vl_api_vnet_ip6_nbr_counters_t * mp)
2785 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2786 (vl_api_vnet_ip6_nbr_counters_t * mp)
2788 vat_main_t *vam = &vat_main;
2789 vl_api_ip6_nbr_counter_t *v;
2790 ip6_nbr_counter_t *counter;
2791 struct in6_addr ip6;
2796 sw_if_index = ntohl (mp->sw_if_index);
2797 count = ntohl (mp->count);
2798 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2801 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2803 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2804 for (i = 0; i < count; i++)
2806 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2807 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2808 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2809 counter->address = ip6;
2810 counter->packets = clib_net_to_host_u64 (v->packets);
2811 counter->bytes = clib_net_to_host_u64 (v->bytes);
2816 static void vl_api_get_first_msg_id_reply_t_handler
2817 (vl_api_get_first_msg_id_reply_t * mp)
2819 vat_main_t *vam = &vat_main;
2820 i32 retval = ntohl (mp->retval);
2822 if (vam->async_mode)
2824 vam->async_errors += (retval < 0);
2828 vam->retval = retval;
2829 vam->result_ready = 1;
2833 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2837 static void vl_api_get_first_msg_id_reply_t_handler_json
2838 (vl_api_get_first_msg_id_reply_t * mp)
2840 vat_main_t *vam = &vat_main;
2841 vat_json_node_t node;
2843 vat_json_init_object (&node);
2844 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2845 vat_json_object_add_uint (&node, "first_msg_id",
2846 (uint) ntohs (mp->first_msg_id));
2848 vat_json_print (vam->ofp, &node);
2849 vat_json_free (&node);
2851 vam->retval = ntohl (mp->retval);
2852 vam->result_ready = 1;
2855 static void vl_api_get_node_graph_reply_t_handler
2856 (vl_api_get_node_graph_reply_t * mp)
2858 vat_main_t *vam = &vat_main;
2859 api_main_t *am = &api_main;
2860 i32 retval = ntohl (mp->retval);
2861 u8 *pvt_copy, *reply;
2866 if (vam->async_mode)
2868 vam->async_errors += (retval < 0);
2872 vam->retval = retval;
2873 vam->result_ready = 1;
2876 /* "Should never happen..." */
2880 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2881 pvt_copy = vec_dup (reply);
2883 /* Toss the shared-memory original... */
2884 pthread_mutex_lock (&am->vlib_rp->mutex);
2885 oldheap = svm_push_data_heap (am->vlib_rp);
2889 svm_pop_heap (oldheap);
2890 pthread_mutex_unlock (&am->vlib_rp->mutex);
2892 if (vam->graph_nodes)
2894 hash_free (vam->graph_node_index_by_name);
2896 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2898 node = vam->graph_nodes[i];
2899 vec_free (node->name);
2900 vec_free (node->next_nodes);
2903 vec_free (vam->graph_nodes);
2906 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2907 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2908 vec_free (pvt_copy);
2910 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2912 node = vam->graph_nodes[i];
2913 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2917 static void vl_api_get_node_graph_reply_t_handler_json
2918 (vl_api_get_node_graph_reply_t * mp)
2920 vat_main_t *vam = &vat_main;
2921 api_main_t *am = &api_main;
2923 vat_json_node_t node;
2926 /* $$$$ make this real? */
2927 vat_json_init_object (&node);
2928 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2929 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2931 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2933 /* Toss the shared-memory original... */
2934 pthread_mutex_lock (&am->vlib_rp->mutex);
2935 oldheap = svm_push_data_heap (am->vlib_rp);
2939 svm_pop_heap (oldheap);
2940 pthread_mutex_unlock (&am->vlib_rp->mutex);
2942 vat_json_print (vam->ofp, &node);
2943 vat_json_free (&node);
2945 vam->retval = ntohl (mp->retval);
2946 vam->result_ready = 1;
2950 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2952 vat_main_t *vam = &vat_main;
2957 s = format (s, "%=16d%=16d%=16d",
2958 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2962 s = format (s, "%=16U%=16d%=16d",
2963 mp->is_ipv6 ? format_ip6_address :
2965 mp->ip_address, mp->priority, mp->weight);
2968 print (vam->ofp, "%v", s);
2973 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2975 vat_main_t *vam = &vat_main;
2976 vat_json_node_t *node = NULL;
2977 struct in6_addr ip6;
2980 if (VAT_JSON_ARRAY != vam->json_tree.type)
2982 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2983 vat_json_init_array (&vam->json_tree);
2985 node = vat_json_array_add (&vam->json_tree);
2986 vat_json_init_object (node);
2988 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2989 vat_json_object_add_uint (node, "priority", mp->priority);
2990 vat_json_object_add_uint (node, "weight", mp->weight);
2993 vat_json_object_add_uint (node, "sw_if_index",
2994 clib_net_to_host_u32 (mp->sw_if_index));
2999 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3000 vat_json_object_add_ip6 (node, "address", ip6);
3004 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3005 vat_json_object_add_ip4 (node, "address", ip4);
3011 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
3014 vat_main_t *vam = &vat_main;
3017 ls_name = format (0, "%s", mp->ls_name);
3019 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
3025 vl_api_one_locator_set_details_t_handler_json
3026 (vl_api_one_locator_set_details_t * mp)
3028 vat_main_t *vam = &vat_main;
3029 vat_json_node_t *node = 0;
3032 ls_name = format (0, "%s", mp->ls_name);
3033 vec_add1 (ls_name, 0);
3035 if (VAT_JSON_ARRAY != vam->json_tree.type)
3037 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3038 vat_json_init_array (&vam->json_tree);
3040 node = vat_json_array_add (&vam->json_tree);
3042 vat_json_init_object (node);
3043 vat_json_object_add_string_copy (node, "ls_name", ls_name);
3044 vat_json_object_add_uint (node, "ls_index",
3045 clib_net_to_host_u32 (mp->ls_index));
3053 } __attribute__ ((__packed__)) lisp_nsh_api_t;
3056 unformat_nsh_address (unformat_input_t * input, va_list * args)
3058 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
3059 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
3063 format_nsh_address_vat (u8 * s, va_list * args)
3065 nsh_t *a = va_arg (*args, nsh_t *);
3066 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
3070 format_lisp_flat_eid (u8 * s, va_list * args)
3072 u32 type = va_arg (*args, u32);
3073 u8 *eid = va_arg (*args, u8 *);
3074 u32 eid_len = va_arg (*args, u32);
3079 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3081 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3083 return format (s, "%U", format_ethernet_address, eid);
3085 return format (s, "%U", format_nsh_address_vat, eid);
3091 format_lisp_eid_vat (u8 * s, va_list * args)
3093 u32 type = va_arg (*args, u32);
3094 u8 *eid = va_arg (*args, u8 *);
3095 u32 eid_len = va_arg (*args, u32);
3096 u8 *seid = va_arg (*args, u8 *);
3097 u32 seid_len = va_arg (*args, u32);
3098 u32 is_src_dst = va_arg (*args, u32);
3101 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3103 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3109 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3111 vat_main_t *vam = &vat_main;
3112 u8 *s = 0, *eid = 0;
3114 if (~0 == mp->locator_set_index)
3115 s = format (0, "action: %d", mp->action);
3117 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3119 eid = format (0, "%U", format_lisp_eid_vat,
3123 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3126 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3127 clib_net_to_host_u32 (mp->vni),
3129 mp->is_local ? "local" : "remote",
3130 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3131 clib_net_to_host_u16 (mp->key_id), mp->key);
3138 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3141 vat_main_t *vam = &vat_main;
3142 vat_json_node_t *node = 0;
3145 if (VAT_JSON_ARRAY != vam->json_tree.type)
3147 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3148 vat_json_init_array (&vam->json_tree);
3150 node = vat_json_array_add (&vam->json_tree);
3152 vat_json_init_object (node);
3153 if (~0 == mp->locator_set_index)
3154 vat_json_object_add_uint (node, "action", mp->action);
3156 vat_json_object_add_uint (node, "locator_set_index",
3157 clib_net_to_host_u32 (mp->locator_set_index));
3159 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3160 if (mp->eid_type == 3)
3162 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3163 vat_json_init_object (nsh_json);
3164 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3165 vat_json_object_add_uint (nsh_json, "spi",
3166 clib_net_to_host_u32 (nsh->spi));
3167 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3171 eid = format (0, "%U", format_lisp_eid_vat,
3175 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3177 vat_json_object_add_string_copy (node, "eid", eid);
3180 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3181 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3182 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3186 vat_json_object_add_uint (node, "key_id",
3187 clib_net_to_host_u16 (mp->key_id));
3188 vat_json_object_add_string_copy (node, "key", mp->key);
3193 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3195 vat_main_t *vam = &vat_main;
3196 u8 *seid = 0, *deid = 0;
3197 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3199 deid = format (0, "%U", format_lisp_eid_vat,
3200 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3202 seid = format (0, "%U", format_lisp_eid_vat,
3203 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3209 format_ip_address_fcn = format_ip4_address;
3211 format_ip_address_fcn = format_ip6_address;
3214 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3215 clib_net_to_host_u32 (mp->vni),
3217 format_ip_address_fcn, mp->lloc,
3218 format_ip_address_fcn, mp->rloc,
3219 clib_net_to_host_u32 (mp->pkt_count),
3220 clib_net_to_host_u32 (mp->bytes));
3227 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3229 struct in6_addr ip6;
3231 vat_main_t *vam = &vat_main;
3232 vat_json_node_t *node = 0;
3233 u8 *deid = 0, *seid = 0;
3235 if (VAT_JSON_ARRAY != vam->json_tree.type)
3237 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3238 vat_json_init_array (&vam->json_tree);
3240 node = vat_json_array_add (&vam->json_tree);
3242 vat_json_init_object (node);
3243 deid = format (0, "%U", format_lisp_eid_vat,
3244 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3246 seid = format (0, "%U", format_lisp_eid_vat,
3247 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3252 vat_json_object_add_string_copy (node, "seid", seid);
3253 vat_json_object_add_string_copy (node, "deid", deid);
3254 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3258 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3259 vat_json_object_add_ip4 (node, "lloc", ip4);
3260 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3261 vat_json_object_add_ip4 (node, "rloc", ip4);
3265 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3266 vat_json_object_add_ip6 (node, "lloc", ip6);
3267 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3268 vat_json_object_add_ip6 (node, "rloc", ip6);
3270 vat_json_object_add_uint (node, "pkt_count",
3271 clib_net_to_host_u32 (mp->pkt_count));
3272 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3279 vl_api_one_eid_table_map_details_t_handler
3280 (vl_api_one_eid_table_map_details_t * mp)
3282 vat_main_t *vam = &vat_main;
3284 u8 *line = format (0, "%=10d%=10d",
3285 clib_net_to_host_u32 (mp->vni),
3286 clib_net_to_host_u32 (mp->dp_table));
3287 print (vam->ofp, "%v", line);
3292 vl_api_one_eid_table_map_details_t_handler_json
3293 (vl_api_one_eid_table_map_details_t * mp)
3295 vat_main_t *vam = &vat_main;
3296 vat_json_node_t *node = NULL;
3298 if (VAT_JSON_ARRAY != vam->json_tree.type)
3300 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3301 vat_json_init_array (&vam->json_tree);
3303 node = vat_json_array_add (&vam->json_tree);
3304 vat_json_init_object (node);
3305 vat_json_object_add_uint (node, "dp_table",
3306 clib_net_to_host_u32 (mp->dp_table));
3307 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3311 vl_api_one_eid_table_vni_details_t_handler
3312 (vl_api_one_eid_table_vni_details_t * mp)
3314 vat_main_t *vam = &vat_main;
3316 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3317 print (vam->ofp, "%v", line);
3322 vl_api_one_eid_table_vni_details_t_handler_json
3323 (vl_api_one_eid_table_vni_details_t * mp)
3325 vat_main_t *vam = &vat_main;
3326 vat_json_node_t *node = NULL;
3328 if (VAT_JSON_ARRAY != vam->json_tree.type)
3330 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3331 vat_json_init_array (&vam->json_tree);
3333 node = vat_json_array_add (&vam->json_tree);
3334 vat_json_init_object (node);
3335 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3339 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3340 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 int retval = clib_net_to_host_u32 (mp->retval);
3345 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3346 print (vam->ofp, "fallback threshold value: %d", mp->value);
3348 vam->retval = retval;
3349 vam->result_ready = 1;
3353 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3354 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3356 vat_main_t *vam = &vat_main;
3357 vat_json_node_t _node, *node = &_node;
3358 int retval = clib_net_to_host_u32 (mp->retval);
3360 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3361 vat_json_init_object (node);
3362 vat_json_object_add_uint (node, "value", mp->value);
3364 vat_json_print (vam->ofp, node);
3365 vat_json_free (node);
3367 vam->retval = retval;
3368 vam->result_ready = 1;
3372 vl_api_show_one_map_register_state_reply_t_handler
3373 (vl_api_show_one_map_register_state_reply_t * mp)
3375 vat_main_t *vam = &vat_main;
3376 int retval = clib_net_to_host_u32 (mp->retval);
3378 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3380 vam->retval = retval;
3381 vam->result_ready = 1;
3385 vl_api_show_one_map_register_state_reply_t_handler_json
3386 (vl_api_show_one_map_register_state_reply_t * mp)
3388 vat_main_t *vam = &vat_main;
3389 vat_json_node_t _node, *node = &_node;
3390 int retval = clib_net_to_host_u32 (mp->retval);
3392 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3394 vat_json_init_object (node);
3395 vat_json_object_add_string_copy (node, "state", s);
3397 vat_json_print (vam->ofp, node);
3398 vat_json_free (node);
3400 vam->retval = retval;
3401 vam->result_ready = 1;
3406 vl_api_show_one_rloc_probe_state_reply_t_handler
3407 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3409 vat_main_t *vam = &vat_main;
3410 int retval = clib_net_to_host_u32 (mp->retval);
3415 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3417 vam->retval = retval;
3418 vam->result_ready = 1;
3422 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3423 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3425 vat_main_t *vam = &vat_main;
3426 vat_json_node_t _node, *node = &_node;
3427 int retval = clib_net_to_host_u32 (mp->retval);
3429 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3430 vat_json_init_object (node);
3431 vat_json_object_add_string_copy (node, "state", s);
3433 vat_json_print (vam->ofp, node);
3434 vat_json_free (node);
3436 vam->retval = retval;
3437 vam->result_ready = 1;
3442 vl_api_show_one_stats_enable_disable_reply_t_handler
3443 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3445 vat_main_t *vam = &vat_main;
3446 int retval = clib_net_to_host_u32 (mp->retval);
3451 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3453 vam->retval = retval;
3454 vam->result_ready = 1;
3458 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3459 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3461 vat_main_t *vam = &vat_main;
3462 vat_json_node_t _node, *node = &_node;
3463 int retval = clib_net_to_host_u32 (mp->retval);
3465 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3466 vat_json_init_object (node);
3467 vat_json_object_add_string_copy (node, "state", s);
3469 vat_json_print (vam->ofp, node);
3470 vat_json_free (node);
3472 vam->retval = retval;
3473 vam->result_ready = 1;
3478 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3480 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3481 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3482 e->vni = clib_net_to_host_u32 (e->vni);
3486 gpe_fwd_entries_get_reply_t_net_to_host
3487 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3491 mp->count = clib_net_to_host_u32 (mp->count);
3492 for (i = 0; i < mp->count; i++)
3494 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3499 format_gpe_encap_mode (u8 * s, va_list * args)
3501 u32 mode = va_arg (*args, u32);
3506 return format (s, "lisp");
3508 return format (s, "vxlan");
3514 vl_api_gpe_get_encap_mode_reply_t_handler
3515 (vl_api_gpe_get_encap_mode_reply_t * mp)
3517 vat_main_t *vam = &vat_main;
3519 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3520 vam->retval = ntohl (mp->retval);
3521 vam->result_ready = 1;
3525 vl_api_gpe_get_encap_mode_reply_t_handler_json
3526 (vl_api_gpe_get_encap_mode_reply_t * mp)
3528 vat_main_t *vam = &vat_main;
3529 vat_json_node_t node;
3531 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3532 vec_add1 (encap_mode, 0);
3534 vat_json_init_object (&node);
3535 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3537 vec_free (encap_mode);
3538 vat_json_print (vam->ofp, &node);
3539 vat_json_free (&node);
3541 vam->retval = ntohl (mp->retval);
3542 vam->result_ready = 1;
3546 vl_api_gpe_fwd_entry_path_details_t_handler
3547 (vl_api_gpe_fwd_entry_path_details_t * mp)
3549 vat_main_t *vam = &vat_main;
3550 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3552 if (mp->lcl_loc.is_ip4)
3553 format_ip_address_fcn = format_ip4_address;
3555 format_ip_address_fcn = format_ip6_address;
3557 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3558 format_ip_address_fcn, &mp->lcl_loc,
3559 format_ip_address_fcn, &mp->rmt_loc);
3563 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3565 struct in6_addr ip6;
3570 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3571 vat_json_object_add_ip4 (n, "address", ip4);
3575 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3576 vat_json_object_add_ip6 (n, "address", ip6);
3578 vat_json_object_add_uint (n, "weight", loc->weight);
3582 vl_api_gpe_fwd_entry_path_details_t_handler_json
3583 (vl_api_gpe_fwd_entry_path_details_t * mp)
3585 vat_main_t *vam = &vat_main;
3586 vat_json_node_t *node = NULL;
3587 vat_json_node_t *loc_node;
3589 if (VAT_JSON_ARRAY != vam->json_tree.type)
3591 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3592 vat_json_init_array (&vam->json_tree);
3594 node = vat_json_array_add (&vam->json_tree);
3595 vat_json_init_object (node);
3597 loc_node = vat_json_object_add (node, "local_locator");
3598 vat_json_init_object (loc_node);
3599 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3601 loc_node = vat_json_object_add (node, "remote_locator");
3602 vat_json_init_object (loc_node);
3603 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3607 vl_api_gpe_fwd_entries_get_reply_t_handler
3608 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3610 vat_main_t *vam = &vat_main;
3612 int retval = clib_net_to_host_u32 (mp->retval);
3613 vl_api_gpe_fwd_entry_t *e;
3618 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3620 for (i = 0; i < mp->count; i++)
3622 e = &mp->entries[i];
3623 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3624 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3625 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3629 vam->retval = retval;
3630 vam->result_ready = 1;
3634 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3635 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3638 vat_main_t *vam = &vat_main;
3639 vat_json_node_t *e = 0, root;
3641 int retval = clib_net_to_host_u32 (mp->retval);
3642 vl_api_gpe_fwd_entry_t *fwd;
3647 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3648 vat_json_init_array (&root);
3650 for (i = 0; i < mp->count; i++)
3652 e = vat_json_array_add (&root);
3653 fwd = &mp->entries[i];
3655 vat_json_init_object (e);
3656 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3657 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3658 vat_json_object_add_int (e, "vni", fwd->vni);
3659 vat_json_object_add_int (e, "action", fwd->action);
3661 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3662 fwd->leid_prefix_len);
3664 vat_json_object_add_string_copy (e, "leid", s);
3667 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3668 fwd->reid_prefix_len);
3670 vat_json_object_add_string_copy (e, "reid", s);
3674 vat_json_print (vam->ofp, &root);
3675 vat_json_free (&root);
3678 vam->retval = retval;
3679 vam->result_ready = 1;
3683 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3684 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3686 vat_main_t *vam = &vat_main;
3688 int retval = clib_net_to_host_u32 (mp->retval);
3689 vl_api_gpe_native_fwd_rpath_t *r;
3694 n = clib_net_to_host_u32 (mp->count);
3696 for (i = 0; i < n; i++)
3698 r = &mp->entries[i];
3699 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3700 clib_net_to_host_u32 (r->fib_index),
3701 clib_net_to_host_u32 (r->nh_sw_if_index),
3702 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3706 vam->retval = retval;
3707 vam->result_ready = 1;
3711 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3712 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3714 vat_main_t *vam = &vat_main;
3715 vat_json_node_t root, *e;
3717 int retval = clib_net_to_host_u32 (mp->retval);
3718 vl_api_gpe_native_fwd_rpath_t *r;
3724 n = clib_net_to_host_u32 (mp->count);
3725 vat_json_init_array (&root);
3727 for (i = 0; i < n; i++)
3729 e = vat_json_array_add (&root);
3730 vat_json_init_object (e);
3731 r = &mp->entries[i];
3733 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3736 vat_json_object_add_string_copy (e, "ip4", s);
3739 vat_json_object_add_uint (e, "fib_index",
3740 clib_net_to_host_u32 (r->fib_index));
3741 vat_json_object_add_uint (e, "nh_sw_if_index",
3742 clib_net_to_host_u32 (r->nh_sw_if_index));
3745 vat_json_print (vam->ofp, &root);
3746 vat_json_free (&root);
3749 vam->retval = retval;
3750 vam->result_ready = 1;
3754 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3755 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3757 vat_main_t *vam = &vat_main;
3759 int retval = clib_net_to_host_u32 (mp->retval);
3764 n = clib_net_to_host_u32 (mp->count);
3766 for (i = 0; i < n; i++)
3767 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3770 vam->retval = retval;
3771 vam->result_ready = 1;
3775 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3776 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3778 vat_main_t *vam = &vat_main;
3779 vat_json_node_t root;
3781 int retval = clib_net_to_host_u32 (mp->retval);
3786 n = clib_net_to_host_u32 (mp->count);
3787 vat_json_init_array (&root);
3789 for (i = 0; i < n; i++)
3790 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3792 vat_json_print (vam->ofp, &root);
3793 vat_json_free (&root);
3796 vam->retval = retval;
3797 vam->result_ready = 1;
3801 vl_api_one_ndp_entries_get_reply_t_handler
3802 (vl_api_one_ndp_entries_get_reply_t * mp)
3804 vat_main_t *vam = &vat_main;
3806 int retval = clib_net_to_host_u32 (mp->retval);
3811 n = clib_net_to_host_u32 (mp->count);
3813 for (i = 0; i < n; i++)
3814 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3815 format_ethernet_address, mp->entries[i].mac);
3818 vam->retval = retval;
3819 vam->result_ready = 1;
3823 vl_api_one_ndp_entries_get_reply_t_handler_json
3824 (vl_api_one_ndp_entries_get_reply_t * mp)
3827 vat_main_t *vam = &vat_main;
3828 vat_json_node_t *e = 0, root;
3830 int retval = clib_net_to_host_u32 (mp->retval);
3831 vl_api_one_ndp_entry_t *arp_entry;
3836 n = clib_net_to_host_u32 (mp->count);
3837 vat_json_init_array (&root);
3839 for (i = 0; i < n; i++)
3841 e = vat_json_array_add (&root);
3842 arp_entry = &mp->entries[i];
3844 vat_json_init_object (e);
3845 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3848 vat_json_object_add_string_copy (e, "mac", s);
3851 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3853 vat_json_object_add_string_copy (e, "ip6", s);
3857 vat_json_print (vam->ofp, &root);
3858 vat_json_free (&root);
3861 vam->retval = retval;
3862 vam->result_ready = 1;
3866 vl_api_one_l2_arp_entries_get_reply_t_handler
3867 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3869 vat_main_t *vam = &vat_main;
3871 int retval = clib_net_to_host_u32 (mp->retval);
3876 n = clib_net_to_host_u32 (mp->count);
3878 for (i = 0; i < n; i++)
3879 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3880 format_ethernet_address, mp->entries[i].mac);
3883 vam->retval = retval;
3884 vam->result_ready = 1;
3888 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3889 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3892 vat_main_t *vam = &vat_main;
3893 vat_json_node_t *e = 0, root;
3895 int retval = clib_net_to_host_u32 (mp->retval);
3896 vl_api_one_l2_arp_entry_t *arp_entry;
3901 n = clib_net_to_host_u32 (mp->count);
3902 vat_json_init_array (&root);
3904 for (i = 0; i < n; i++)
3906 e = vat_json_array_add (&root);
3907 arp_entry = &mp->entries[i];
3909 vat_json_init_object (e);
3910 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3913 vat_json_object_add_string_copy (e, "mac", s);
3916 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3918 vat_json_object_add_string_copy (e, "ip4", s);
3922 vat_json_print (vam->ofp, &root);
3923 vat_json_free (&root);
3926 vam->retval = retval;
3927 vam->result_ready = 1;
3931 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3933 vat_main_t *vam = &vat_main;
3935 int retval = clib_net_to_host_u32 (mp->retval);
3940 n = clib_net_to_host_u32 (mp->count);
3942 for (i = 0; i < n; i++)
3944 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3948 vam->retval = retval;
3949 vam->result_ready = 1;
3953 vl_api_one_ndp_bd_get_reply_t_handler_json
3954 (vl_api_one_ndp_bd_get_reply_t * mp)
3956 vat_main_t *vam = &vat_main;
3957 vat_json_node_t root;
3959 int retval = clib_net_to_host_u32 (mp->retval);
3964 n = clib_net_to_host_u32 (mp->count);
3965 vat_json_init_array (&root);
3967 for (i = 0; i < n; i++)
3969 vat_json_array_add_uint (&root,
3970 clib_net_to_host_u32 (mp->bridge_domains[i]));
3973 vat_json_print (vam->ofp, &root);
3974 vat_json_free (&root);
3977 vam->retval = retval;
3978 vam->result_ready = 1;
3982 vl_api_one_l2_arp_bd_get_reply_t_handler
3983 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3985 vat_main_t *vam = &vat_main;
3987 int retval = clib_net_to_host_u32 (mp->retval);
3992 n = clib_net_to_host_u32 (mp->count);
3994 for (i = 0; i < n; i++)
3996 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
4000 vam->retval = retval;
4001 vam->result_ready = 1;
4005 vl_api_one_l2_arp_bd_get_reply_t_handler_json
4006 (vl_api_one_l2_arp_bd_get_reply_t * mp)
4008 vat_main_t *vam = &vat_main;
4009 vat_json_node_t root;
4011 int retval = clib_net_to_host_u32 (mp->retval);
4016 n = clib_net_to_host_u32 (mp->count);
4017 vat_json_init_array (&root);
4019 for (i = 0; i < n; i++)
4021 vat_json_array_add_uint (&root,
4022 clib_net_to_host_u32 (mp->bridge_domains[i]));
4025 vat_json_print (vam->ofp, &root);
4026 vat_json_free (&root);
4029 vam->retval = retval;
4030 vam->result_ready = 1;
4034 vl_api_one_adjacencies_get_reply_t_handler
4035 (vl_api_one_adjacencies_get_reply_t * mp)
4037 vat_main_t *vam = &vat_main;
4039 int retval = clib_net_to_host_u32 (mp->retval);
4040 vl_api_one_adjacency_t *a;
4045 n = clib_net_to_host_u32 (mp->count);
4047 for (i = 0; i < n; i++)
4049 a = &mp->adjacencies[i];
4050 print (vam->ofp, "%U %40U",
4051 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
4052 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
4056 vam->retval = retval;
4057 vam->result_ready = 1;
4061 vl_api_one_adjacencies_get_reply_t_handler_json
4062 (vl_api_one_adjacencies_get_reply_t * mp)
4065 vat_main_t *vam = &vat_main;
4066 vat_json_node_t *e = 0, root;
4068 int retval = clib_net_to_host_u32 (mp->retval);
4069 vl_api_one_adjacency_t *a;
4074 n = clib_net_to_host_u32 (mp->count);
4075 vat_json_init_array (&root);
4077 for (i = 0; i < n; i++)
4079 e = vat_json_array_add (&root);
4080 a = &mp->adjacencies[i];
4082 vat_json_init_object (e);
4083 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4084 a->leid_prefix_len);
4086 vat_json_object_add_string_copy (e, "leid", s);
4089 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4090 a->reid_prefix_len);
4092 vat_json_object_add_string_copy (e, "reid", s);
4096 vat_json_print (vam->ofp, &root);
4097 vat_json_free (&root);
4100 vam->retval = retval;
4101 vam->result_ready = 1;
4105 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4107 vat_main_t *vam = &vat_main;
4109 print (vam->ofp, "%=20U",
4110 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4115 vl_api_one_map_server_details_t_handler_json
4116 (vl_api_one_map_server_details_t * mp)
4118 vat_main_t *vam = &vat_main;
4119 vat_json_node_t *node = NULL;
4120 struct in6_addr ip6;
4123 if (VAT_JSON_ARRAY != vam->json_tree.type)
4125 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4126 vat_json_init_array (&vam->json_tree);
4128 node = vat_json_array_add (&vam->json_tree);
4130 vat_json_init_object (node);
4133 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4134 vat_json_object_add_ip6 (node, "map-server", ip6);
4138 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4139 vat_json_object_add_ip4 (node, "map-server", ip4);
4144 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4147 vat_main_t *vam = &vat_main;
4149 print (vam->ofp, "%=20U",
4150 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4155 vl_api_one_map_resolver_details_t_handler_json
4156 (vl_api_one_map_resolver_details_t * mp)
4158 vat_main_t *vam = &vat_main;
4159 vat_json_node_t *node = NULL;
4160 struct in6_addr ip6;
4163 if (VAT_JSON_ARRAY != vam->json_tree.type)
4165 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4166 vat_json_init_array (&vam->json_tree);
4168 node = vat_json_array_add (&vam->json_tree);
4170 vat_json_init_object (node);
4173 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4174 vat_json_object_add_ip6 (node, "map resolver", ip6);
4178 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4179 vat_json_object_add_ip4 (node, "map resolver", ip4);
4184 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4186 vat_main_t *vam = &vat_main;
4187 i32 retval = ntohl (mp->retval);
4191 print (vam->ofp, "feature: %s\ngpe: %s",
4192 mp->feature_status ? "enabled" : "disabled",
4193 mp->gpe_status ? "enabled" : "disabled");
4196 vam->retval = retval;
4197 vam->result_ready = 1;
4201 vl_api_show_one_status_reply_t_handler_json
4202 (vl_api_show_one_status_reply_t * mp)
4204 vat_main_t *vam = &vat_main;
4205 vat_json_node_t node;
4206 u8 *gpe_status = NULL;
4207 u8 *feature_status = NULL;
4209 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4210 feature_status = format (0, "%s",
4211 mp->feature_status ? "enabled" : "disabled");
4212 vec_add1 (gpe_status, 0);
4213 vec_add1 (feature_status, 0);
4215 vat_json_init_object (&node);
4216 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4217 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4219 vec_free (gpe_status);
4220 vec_free (feature_status);
4222 vat_json_print (vam->ofp, &node);
4223 vat_json_free (&node);
4225 vam->retval = ntohl (mp->retval);
4226 vam->result_ready = 1;
4230 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4231 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4233 vat_main_t *vam = &vat_main;
4234 i32 retval = ntohl (mp->retval);
4238 print (vam->ofp, "%=20s", mp->locator_set_name);
4241 vam->retval = retval;
4242 vam->result_ready = 1;
4246 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4247 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4249 vat_main_t *vam = &vat_main;
4250 vat_json_node_t *node = NULL;
4252 if (VAT_JSON_ARRAY != vam->json_tree.type)
4254 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4255 vat_json_init_array (&vam->json_tree);
4257 node = vat_json_array_add (&vam->json_tree);
4259 vat_json_init_object (node);
4260 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4262 vat_json_print (vam->ofp, node);
4263 vat_json_free (node);
4265 vam->retval = ntohl (mp->retval);
4266 vam->result_ready = 1;
4270 format_lisp_map_request_mode (u8 * s, va_list * args)
4272 u32 mode = va_arg (*args, u32);
4277 return format (0, "dst-only");
4279 return format (0, "src-dst");
4285 vl_api_show_one_map_request_mode_reply_t_handler
4286 (vl_api_show_one_map_request_mode_reply_t * mp)
4288 vat_main_t *vam = &vat_main;
4289 i32 retval = ntohl (mp->retval);
4293 u32 mode = mp->mode;
4294 print (vam->ofp, "map_request_mode: %U",
4295 format_lisp_map_request_mode, mode);
4298 vam->retval = retval;
4299 vam->result_ready = 1;
4303 vl_api_show_one_map_request_mode_reply_t_handler_json
4304 (vl_api_show_one_map_request_mode_reply_t * mp)
4306 vat_main_t *vam = &vat_main;
4307 vat_json_node_t node;
4312 s = format (0, "%U", format_lisp_map_request_mode, mode);
4315 vat_json_init_object (&node);
4316 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4317 vat_json_print (vam->ofp, &node);
4318 vat_json_free (&node);
4321 vam->retval = ntohl (mp->retval);
4322 vam->result_ready = 1;
4326 vl_api_one_show_xtr_mode_reply_t_handler
4327 (vl_api_one_show_xtr_mode_reply_t * mp)
4329 vat_main_t *vam = &vat_main;
4330 i32 retval = ntohl (mp->retval);
4334 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4337 vam->retval = retval;
4338 vam->result_ready = 1;
4342 vl_api_one_show_xtr_mode_reply_t_handler_json
4343 (vl_api_one_show_xtr_mode_reply_t * mp)
4345 vat_main_t *vam = &vat_main;
4346 vat_json_node_t node;
4349 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4350 vec_add1 (status, 0);
4352 vat_json_init_object (&node);
4353 vat_json_object_add_string_copy (&node, "status", status);
4357 vat_json_print (vam->ofp, &node);
4358 vat_json_free (&node);
4360 vam->retval = ntohl (mp->retval);
4361 vam->result_ready = 1;
4365 vl_api_one_show_pitr_mode_reply_t_handler
4366 (vl_api_one_show_pitr_mode_reply_t * mp)
4368 vat_main_t *vam = &vat_main;
4369 i32 retval = ntohl (mp->retval);
4373 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4376 vam->retval = retval;
4377 vam->result_ready = 1;
4381 vl_api_one_show_pitr_mode_reply_t_handler_json
4382 (vl_api_one_show_pitr_mode_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 vat_json_node_t node;
4388 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4389 vec_add1 (status, 0);
4391 vat_json_init_object (&node);
4392 vat_json_object_add_string_copy (&node, "status", status);
4396 vat_json_print (vam->ofp, &node);
4397 vat_json_free (&node);
4399 vam->retval = ntohl (mp->retval);
4400 vam->result_ready = 1;
4404 vl_api_one_show_petr_mode_reply_t_handler
4405 (vl_api_one_show_petr_mode_reply_t * mp)
4407 vat_main_t *vam = &vat_main;
4408 i32 retval = ntohl (mp->retval);
4412 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4415 vam->retval = retval;
4416 vam->result_ready = 1;
4420 vl_api_one_show_petr_mode_reply_t_handler_json
4421 (vl_api_one_show_petr_mode_reply_t * mp)
4423 vat_main_t *vam = &vat_main;
4424 vat_json_node_t node;
4427 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4428 vec_add1 (status, 0);
4430 vat_json_init_object (&node);
4431 vat_json_object_add_string_copy (&node, "status", status);
4435 vat_json_print (vam->ofp, &node);
4436 vat_json_free (&node);
4438 vam->retval = ntohl (mp->retval);
4439 vam->result_ready = 1;
4443 vl_api_show_one_use_petr_reply_t_handler
4444 (vl_api_show_one_use_petr_reply_t * mp)
4446 vat_main_t *vam = &vat_main;
4447 i32 retval = ntohl (mp->retval);
4451 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4454 print (vam->ofp, "Proxy-ETR address; %U",
4455 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4460 vam->retval = retval;
4461 vam->result_ready = 1;
4465 vl_api_show_one_use_petr_reply_t_handler_json
4466 (vl_api_show_one_use_petr_reply_t * mp)
4468 vat_main_t *vam = &vat_main;
4469 vat_json_node_t node;
4472 struct in6_addr ip6;
4474 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4475 vec_add1 (status, 0);
4477 vat_json_init_object (&node);
4478 vat_json_object_add_string_copy (&node, "status", status);
4483 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4484 vat_json_object_add_ip6 (&node, "address", ip6);
4488 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4489 vat_json_object_add_ip4 (&node, "address", ip4);
4495 vat_json_print (vam->ofp, &node);
4496 vat_json_free (&node);
4498 vam->retval = ntohl (mp->retval);
4499 vam->result_ready = 1;
4503 vl_api_show_one_nsh_mapping_reply_t_handler
4504 (vl_api_show_one_nsh_mapping_reply_t * mp)
4506 vat_main_t *vam = &vat_main;
4507 i32 retval = ntohl (mp->retval);
4511 print (vam->ofp, "%-20s%-16s",
4512 mp->is_set ? "set" : "not-set",
4513 mp->is_set ? (char *) mp->locator_set_name : "");
4516 vam->retval = retval;
4517 vam->result_ready = 1;
4521 vl_api_show_one_nsh_mapping_reply_t_handler_json
4522 (vl_api_show_one_nsh_mapping_reply_t * mp)
4524 vat_main_t *vam = &vat_main;
4525 vat_json_node_t node;
4528 status = format (0, "%s", mp->is_set ? "yes" : "no");
4529 vec_add1 (status, 0);
4531 vat_json_init_object (&node);
4532 vat_json_object_add_string_copy (&node, "is_set", status);
4535 vat_json_object_add_string_copy (&node, "locator_set",
4536 mp->locator_set_name);
4541 vat_json_print (vam->ofp, &node);
4542 vat_json_free (&node);
4544 vam->retval = ntohl (mp->retval);
4545 vam->result_ready = 1;
4549 vl_api_show_one_map_register_ttl_reply_t_handler
4550 (vl_api_show_one_map_register_ttl_reply_t * mp)
4552 vat_main_t *vam = &vat_main;
4553 i32 retval = ntohl (mp->retval);
4555 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4559 print (vam->ofp, "ttl: %u", mp->ttl);
4562 vam->retval = retval;
4563 vam->result_ready = 1;
4567 vl_api_show_one_map_register_ttl_reply_t_handler_json
4568 (vl_api_show_one_map_register_ttl_reply_t * mp)
4570 vat_main_t *vam = &vat_main;
4571 vat_json_node_t node;
4573 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4574 vat_json_init_object (&node);
4575 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4577 vat_json_print (vam->ofp, &node);
4578 vat_json_free (&node);
4580 vam->retval = ntohl (mp->retval);
4581 vam->result_ready = 1;
4585 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4587 vat_main_t *vam = &vat_main;
4588 i32 retval = ntohl (mp->retval);
4592 print (vam->ofp, "%-20s%-16s",
4593 mp->status ? "enabled" : "disabled",
4594 mp->status ? (char *) mp->locator_set_name : "");
4597 vam->retval = retval;
4598 vam->result_ready = 1;
4602 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4604 vat_main_t *vam = &vat_main;
4605 vat_json_node_t node;
4608 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4609 vec_add1 (status, 0);
4611 vat_json_init_object (&node);
4612 vat_json_object_add_string_copy (&node, "status", status);
4615 vat_json_object_add_string_copy (&node, "locator_set",
4616 mp->locator_set_name);
4621 vat_json_print (vam->ofp, &node);
4622 vat_json_free (&node);
4624 vam->retval = ntohl (mp->retval);
4625 vam->result_ready = 1;
4629 format_policer_type (u8 * s, va_list * va)
4631 u32 i = va_arg (*va, u32);
4633 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4634 s = format (s, "1r2c");
4635 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4636 s = format (s, "1r3c");
4637 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4638 s = format (s, "2r3c-2698");
4639 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4640 s = format (s, "2r3c-4115");
4641 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4642 s = format (s, "2r3c-mef5cf1");
4644 s = format (s, "ILLEGAL");
4649 format_policer_rate_type (u8 * s, va_list * va)
4651 u32 i = va_arg (*va, u32);
4653 if (i == SSE2_QOS_RATE_KBPS)
4654 s = format (s, "kbps");
4655 else if (i == SSE2_QOS_RATE_PPS)
4656 s = format (s, "pps");
4658 s = format (s, "ILLEGAL");
4663 format_policer_round_type (u8 * s, va_list * va)
4665 u32 i = va_arg (*va, u32);
4667 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4668 s = format (s, "closest");
4669 else if (i == SSE2_QOS_ROUND_TO_UP)
4670 s = format (s, "up");
4671 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4672 s = format (s, "down");
4674 s = format (s, "ILLEGAL");
4679 format_policer_action_type (u8 * s, va_list * va)
4681 u32 i = va_arg (*va, u32);
4683 if (i == SSE2_QOS_ACTION_DROP)
4684 s = format (s, "drop");
4685 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4686 s = format (s, "transmit");
4687 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4688 s = format (s, "mark-and-transmit");
4690 s = format (s, "ILLEGAL");
4695 format_dscp (u8 * s, va_list * va)
4697 u32 i = va_arg (*va, u32);
4702 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4706 return format (s, "ILLEGAL");
4708 s = format (s, "%s", t);
4713 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4715 vat_main_t *vam = &vat_main;
4716 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4718 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4719 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4721 conform_dscp_str = format (0, "");
4723 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4724 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4726 exceed_dscp_str = format (0, "");
4728 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4729 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4731 violate_dscp_str = format (0, "");
4733 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4734 "rate type %U, round type %U, %s rate, %s color-aware, "
4735 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4736 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4737 "conform action %U%s, exceed action %U%s, violate action %U%s",
4739 format_policer_type, mp->type,
4742 clib_net_to_host_u64 (mp->cb),
4743 clib_net_to_host_u64 (mp->eb),
4744 format_policer_rate_type, mp->rate_type,
4745 format_policer_round_type, mp->round_type,
4746 mp->single_rate ? "single" : "dual",
4747 mp->color_aware ? "is" : "not",
4748 ntohl (mp->cir_tokens_per_period),
4749 ntohl (mp->pir_tokens_per_period),
4751 ntohl (mp->current_limit),
4752 ntohl (mp->current_bucket),
4753 ntohl (mp->extended_limit),
4754 ntohl (mp->extended_bucket),
4755 clib_net_to_host_u64 (mp->last_update_time),
4756 format_policer_action_type, mp->conform_action_type,
4758 format_policer_action_type, mp->exceed_action_type,
4760 format_policer_action_type, mp->violate_action_type,
4763 vec_free (conform_dscp_str);
4764 vec_free (exceed_dscp_str);
4765 vec_free (violate_dscp_str);
4768 static void vl_api_policer_details_t_handler_json
4769 (vl_api_policer_details_t * mp)
4771 vat_main_t *vam = &vat_main;
4772 vat_json_node_t *node;
4773 u8 *rate_type_str, *round_type_str, *type_str;
4774 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4776 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4778 format (0, "%U", format_policer_round_type, mp->round_type);
4779 type_str = format (0, "%U", format_policer_type, mp->type);
4780 conform_action_str = format (0, "%U", format_policer_action_type,
4781 mp->conform_action_type);
4782 exceed_action_str = format (0, "%U", format_policer_action_type,
4783 mp->exceed_action_type);
4784 violate_action_str = format (0, "%U", format_policer_action_type,
4785 mp->violate_action_type);
4787 if (VAT_JSON_ARRAY != vam->json_tree.type)
4789 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4790 vat_json_init_array (&vam->json_tree);
4792 node = vat_json_array_add (&vam->json_tree);
4794 vat_json_init_object (node);
4795 vat_json_object_add_string_copy (node, "name", mp->name);
4796 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4797 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4798 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4799 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4800 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4801 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4802 vat_json_object_add_string_copy (node, "type", type_str);
4803 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4804 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4805 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4806 vat_json_object_add_uint (node, "cir_tokens_per_period",
4807 ntohl (mp->cir_tokens_per_period));
4808 vat_json_object_add_uint (node, "eir_tokens_per_period",
4809 ntohl (mp->pir_tokens_per_period));
4810 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4811 vat_json_object_add_uint (node, "current_bucket",
4812 ntohl (mp->current_bucket));
4813 vat_json_object_add_uint (node, "extended_limit",
4814 ntohl (mp->extended_limit));
4815 vat_json_object_add_uint (node, "extended_bucket",
4816 ntohl (mp->extended_bucket));
4817 vat_json_object_add_uint (node, "last_update_time",
4818 ntohl (mp->last_update_time));
4819 vat_json_object_add_string_copy (node, "conform_action",
4820 conform_action_str);
4821 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4823 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4824 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4825 vec_free (dscp_str);
4827 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4828 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4830 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4831 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4832 vec_free (dscp_str);
4834 vat_json_object_add_string_copy (node, "violate_action",
4835 violate_action_str);
4836 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4838 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4839 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4840 vec_free (dscp_str);
4843 vec_free (rate_type_str);
4844 vec_free (round_type_str);
4845 vec_free (type_str);
4846 vec_free (conform_action_str);
4847 vec_free (exceed_action_str);
4848 vec_free (violate_action_str);
4852 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4855 vat_main_t *vam = &vat_main;
4856 int i, count = ntohl (mp->count);
4859 print (vam->ofp, "classify table ids (%d) : ", count);
4860 for (i = 0; i < count; i++)
4862 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4863 print (vam->ofp, (i < count - 1) ? "," : "");
4865 vam->retval = ntohl (mp->retval);
4866 vam->result_ready = 1;
4870 vl_api_classify_table_ids_reply_t_handler_json
4871 (vl_api_classify_table_ids_reply_t * mp)
4873 vat_main_t *vam = &vat_main;
4874 int i, count = ntohl (mp->count);
4878 vat_json_node_t node;
4880 vat_json_init_object (&node);
4881 for (i = 0; i < count; i++)
4883 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4885 vat_json_print (vam->ofp, &node);
4886 vat_json_free (&node);
4888 vam->retval = ntohl (mp->retval);
4889 vam->result_ready = 1;
4893 vl_api_classify_table_by_interface_reply_t_handler
4894 (vl_api_classify_table_by_interface_reply_t * mp)
4896 vat_main_t *vam = &vat_main;
4899 table_id = ntohl (mp->l2_table_id);
4901 print (vam->ofp, "l2 table id : %d", table_id);
4903 print (vam->ofp, "l2 table id : No input ACL tables configured");
4904 table_id = ntohl (mp->ip4_table_id);
4906 print (vam->ofp, "ip4 table id : %d", table_id);
4908 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4909 table_id = ntohl (mp->ip6_table_id);
4911 print (vam->ofp, "ip6 table id : %d", table_id);
4913 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4914 vam->retval = ntohl (mp->retval);
4915 vam->result_ready = 1;
4919 vl_api_classify_table_by_interface_reply_t_handler_json
4920 (vl_api_classify_table_by_interface_reply_t * mp)
4922 vat_main_t *vam = &vat_main;
4923 vat_json_node_t node;
4925 vat_json_init_object (&node);
4927 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4928 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4929 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4931 vat_json_print (vam->ofp, &node);
4932 vat_json_free (&node);
4934 vam->retval = ntohl (mp->retval);
4935 vam->result_ready = 1;
4938 static void vl_api_policer_add_del_reply_t_handler
4939 (vl_api_policer_add_del_reply_t * mp)
4941 vat_main_t *vam = &vat_main;
4942 i32 retval = ntohl (mp->retval);
4943 if (vam->async_mode)
4945 vam->async_errors += (retval < 0);
4949 vam->retval = retval;
4950 vam->result_ready = 1;
4951 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4953 * Note: this is just barely thread-safe, depends on
4954 * the main thread spinning waiting for an answer...
4956 errmsg ("policer index %d", ntohl (mp->policer_index));
4960 static void vl_api_policer_add_del_reply_t_handler_json
4961 (vl_api_policer_add_del_reply_t * mp)
4963 vat_main_t *vam = &vat_main;
4964 vat_json_node_t node;
4966 vat_json_init_object (&node);
4967 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4968 vat_json_object_add_uint (&node, "policer_index",
4969 ntohl (mp->policer_index));
4971 vat_json_print (vam->ofp, &node);
4972 vat_json_free (&node);
4974 vam->retval = ntohl (mp->retval);
4975 vam->result_ready = 1;
4978 /* Format hex dump. */
4980 format_hex_bytes (u8 * s, va_list * va)
4982 u8 *bytes = va_arg (*va, u8 *);
4983 int n_bytes = va_arg (*va, int);
4986 /* Print short or long form depending on byte count. */
4987 uword short_form = n_bytes <= 32;
4988 u32 indent = format_get_indent (s);
4993 for (i = 0; i < n_bytes; i++)
4995 if (!short_form && (i % 32) == 0)
4996 s = format (s, "%08x: ", i);
4997 s = format (s, "%02x", bytes[i]);
4998 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4999 s = format (s, "\n%U", format_white_space, indent);
5006 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
5009 vat_main_t *vam = &vat_main;
5010 i32 retval = ntohl (mp->retval);
5013 print (vam->ofp, "classify table info :");
5014 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
5015 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
5016 ntohl (mp->miss_next_index));
5017 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
5018 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
5019 ntohl (mp->match_n_vectors));
5020 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
5021 ntohl (mp->mask_length));
5023 vam->retval = retval;
5024 vam->result_ready = 1;
5028 vl_api_classify_table_info_reply_t_handler_json
5029 (vl_api_classify_table_info_reply_t * mp)
5031 vat_main_t *vam = &vat_main;
5032 vat_json_node_t node;
5034 i32 retval = ntohl (mp->retval);
5037 vat_json_init_object (&node);
5039 vat_json_object_add_int (&node, "sessions",
5040 ntohl (mp->active_sessions));
5041 vat_json_object_add_int (&node, "nexttbl",
5042 ntohl (mp->next_table_index));
5043 vat_json_object_add_int (&node, "nextnode",
5044 ntohl (mp->miss_next_index));
5045 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
5046 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
5047 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
5048 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
5049 ntohl (mp->mask_length), 0);
5050 vat_json_object_add_string_copy (&node, "mask", s);
5052 vat_json_print (vam->ofp, &node);
5053 vat_json_free (&node);
5055 vam->retval = ntohl (mp->retval);
5056 vam->result_ready = 1;
5060 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
5063 vat_main_t *vam = &vat_main;
5065 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
5066 ntohl (mp->hit_next_index), ntohl (mp->advance),
5067 ntohl (mp->opaque_index));
5068 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
5069 ntohl (mp->match_length));
5073 vl_api_classify_session_details_t_handler_json
5074 (vl_api_classify_session_details_t * mp)
5076 vat_main_t *vam = &vat_main;
5077 vat_json_node_t *node = NULL;
5079 if (VAT_JSON_ARRAY != vam->json_tree.type)
5081 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5082 vat_json_init_array (&vam->json_tree);
5084 node = vat_json_array_add (&vam->json_tree);
5086 vat_json_init_object (node);
5087 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5088 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5089 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5091 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5093 vat_json_object_add_string_copy (node, "match", s);
5096 static void vl_api_pg_create_interface_reply_t_handler
5097 (vl_api_pg_create_interface_reply_t * mp)
5099 vat_main_t *vam = &vat_main;
5101 vam->retval = ntohl (mp->retval);
5102 vam->result_ready = 1;
5105 static void vl_api_pg_create_interface_reply_t_handler_json
5106 (vl_api_pg_create_interface_reply_t * mp)
5108 vat_main_t *vam = &vat_main;
5109 vat_json_node_t node;
5111 i32 retval = ntohl (mp->retval);
5114 vat_json_init_object (&node);
5116 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5118 vat_json_print (vam->ofp, &node);
5119 vat_json_free (&node);
5121 vam->retval = ntohl (mp->retval);
5122 vam->result_ready = 1;
5125 static void vl_api_policer_classify_details_t_handler
5126 (vl_api_policer_classify_details_t * mp)
5128 vat_main_t *vam = &vat_main;
5130 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5131 ntohl (mp->table_index));
5134 static void vl_api_policer_classify_details_t_handler_json
5135 (vl_api_policer_classify_details_t * mp)
5137 vat_main_t *vam = &vat_main;
5138 vat_json_node_t *node;
5140 if (VAT_JSON_ARRAY != vam->json_tree.type)
5142 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5143 vat_json_init_array (&vam->json_tree);
5145 node = vat_json_array_add (&vam->json_tree);
5147 vat_json_init_object (node);
5148 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5149 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5152 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5153 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5155 vat_main_t *vam = &vat_main;
5156 i32 retval = ntohl (mp->retval);
5157 if (vam->async_mode)
5159 vam->async_errors += (retval < 0);
5163 vam->retval = retval;
5164 vam->sw_if_index = ntohl (mp->sw_if_index);
5165 vam->result_ready = 1;
5167 vam->regenerate_interface_table = 1;
5170 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5171 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5173 vat_main_t *vam = &vat_main;
5174 vat_json_node_t node;
5176 vat_json_init_object (&node);
5177 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5178 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5180 vat_json_print (vam->ofp, &node);
5181 vat_json_free (&node);
5183 vam->retval = ntohl (mp->retval);
5184 vam->result_ready = 1;
5187 static void vl_api_flow_classify_details_t_handler
5188 (vl_api_flow_classify_details_t * mp)
5190 vat_main_t *vam = &vat_main;
5192 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5193 ntohl (mp->table_index));
5196 static void vl_api_flow_classify_details_t_handler_json
5197 (vl_api_flow_classify_details_t * mp)
5199 vat_main_t *vam = &vat_main;
5200 vat_json_node_t *node;
5202 if (VAT_JSON_ARRAY != vam->json_tree.type)
5204 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5205 vat_json_init_array (&vam->json_tree);
5207 node = vat_json_array_add (&vam->json_tree);
5209 vat_json_init_object (node);
5210 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5211 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5214 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5215 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5216 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5217 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5218 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5219 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5220 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5221 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5222 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5223 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5224 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5225 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5226 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5227 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5228 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5229 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5230 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5231 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5232 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5233 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5234 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5235 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5238 * Generate boilerplate reply handlers, which
5239 * dig the return value out of the xxx_reply_t API message,
5240 * stick it into vam->retval, and set vam->result_ready
5242 * Could also do this by pointing N message decode slots at
5243 * a single function, but that could break in subtle ways.
5246 #define foreach_standard_reply_retval_handler \
5247 _(sw_interface_set_flags_reply) \
5248 _(sw_interface_add_del_address_reply) \
5249 _(sw_interface_set_rx_mode_reply) \
5250 _(sw_interface_set_table_reply) \
5251 _(sw_interface_set_mpls_enable_reply) \
5252 _(sw_interface_set_vpath_reply) \
5253 _(sw_interface_set_vxlan_bypass_reply) \
5254 _(sw_interface_set_geneve_bypass_reply) \
5255 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5256 _(sw_interface_set_l2_bridge_reply) \
5257 _(bridge_domain_add_del_reply) \
5258 _(sw_interface_set_l2_xconnect_reply) \
5259 _(l2fib_add_del_reply) \
5260 _(l2fib_flush_int_reply) \
5261 _(l2fib_flush_bd_reply) \
5262 _(ip_add_del_route_reply) \
5263 _(ip_table_add_del_reply) \
5264 _(ip_mroute_add_del_reply) \
5265 _(mpls_route_add_del_reply) \
5266 _(mpls_table_add_del_reply) \
5267 _(mpls_ip_bind_unbind_reply) \
5268 _(bier_route_add_del_reply) \
5269 _(bier_table_add_del_reply) \
5270 _(proxy_arp_add_del_reply) \
5271 _(proxy_arp_intfc_enable_disable_reply) \
5272 _(sw_interface_set_unnumbered_reply) \
5273 _(ip_neighbor_add_del_reply) \
5274 _(oam_add_del_reply) \
5275 _(reset_fib_reply) \
5276 _(dhcp_proxy_config_reply) \
5277 _(dhcp_proxy_set_vss_reply) \
5278 _(dhcp_client_config_reply) \
5279 _(set_ip_flow_hash_reply) \
5280 _(sw_interface_ip6_enable_disable_reply) \
5281 _(sw_interface_ip6_set_link_local_address_reply) \
5282 _(ip6nd_proxy_add_del_reply) \
5283 _(sw_interface_ip6nd_ra_prefix_reply) \
5284 _(sw_interface_ip6nd_ra_config_reply) \
5285 _(set_arp_neighbor_limit_reply) \
5286 _(l2_patch_add_del_reply) \
5287 _(sr_policy_add_reply) \
5288 _(sr_policy_mod_reply) \
5289 _(sr_policy_del_reply) \
5290 _(sr_localsid_add_del_reply) \
5291 _(sr_steering_add_del_reply) \
5292 _(classify_add_del_session_reply) \
5293 _(classify_set_interface_ip_table_reply) \
5294 _(classify_set_interface_l2_tables_reply) \
5295 _(l2tpv3_set_tunnel_cookies_reply) \
5296 _(l2tpv3_interface_enable_disable_reply) \
5297 _(l2tpv3_set_lookup_key_reply) \
5298 _(l2_fib_clear_table_reply) \
5299 _(l2_interface_efp_filter_reply) \
5300 _(l2_interface_vlan_tag_rewrite_reply) \
5301 _(modify_vhost_user_if_reply) \
5302 _(delete_vhost_user_if_reply) \
5303 _(want_ip4_arp_events_reply) \
5304 _(want_ip6_nd_events_reply) \
5305 _(want_l2_macs_events_reply) \
5306 _(input_acl_set_interface_reply) \
5307 _(ipsec_spd_add_del_reply) \
5308 _(ipsec_interface_add_del_spd_reply) \
5309 _(ipsec_spd_add_del_entry_reply) \
5310 _(ipsec_sad_add_del_entry_reply) \
5311 _(ipsec_sa_set_key_reply) \
5312 _(ipsec_tunnel_if_add_del_reply) \
5313 _(ipsec_tunnel_if_set_key_reply) \
5314 _(ipsec_tunnel_if_set_sa_reply) \
5315 _(ikev2_profile_add_del_reply) \
5316 _(ikev2_profile_set_auth_reply) \
5317 _(ikev2_profile_set_id_reply) \
5318 _(ikev2_profile_set_ts_reply) \
5319 _(ikev2_set_local_key_reply) \
5320 _(ikev2_set_responder_reply) \
5321 _(ikev2_set_ike_transforms_reply) \
5322 _(ikev2_set_esp_transforms_reply) \
5323 _(ikev2_set_sa_lifetime_reply) \
5324 _(ikev2_initiate_sa_init_reply) \
5325 _(ikev2_initiate_del_ike_sa_reply) \
5326 _(ikev2_initiate_del_child_sa_reply) \
5327 _(ikev2_initiate_rekey_child_sa_reply) \
5328 _(delete_loopback_reply) \
5329 _(bd_ip_mac_add_del_reply) \
5330 _(map_del_domain_reply) \
5331 _(map_add_del_rule_reply) \
5332 _(want_interface_events_reply) \
5333 _(want_stats_reply) \
5334 _(cop_interface_enable_disable_reply) \
5335 _(cop_whitelist_enable_disable_reply) \
5336 _(sw_interface_clear_stats_reply) \
5337 _(ioam_enable_reply) \
5338 _(ioam_disable_reply) \
5339 _(one_add_del_locator_reply) \
5340 _(one_add_del_local_eid_reply) \
5341 _(one_add_del_remote_mapping_reply) \
5342 _(one_add_del_adjacency_reply) \
5343 _(one_add_del_map_resolver_reply) \
5344 _(one_add_del_map_server_reply) \
5345 _(one_enable_disable_reply) \
5346 _(one_rloc_probe_enable_disable_reply) \
5347 _(one_map_register_enable_disable_reply) \
5348 _(one_map_register_set_ttl_reply) \
5349 _(one_set_transport_protocol_reply) \
5350 _(one_map_register_fallback_threshold_reply) \
5351 _(one_pitr_set_locator_set_reply) \
5352 _(one_map_request_mode_reply) \
5353 _(one_add_del_map_request_itr_rlocs_reply) \
5354 _(one_eid_table_add_del_map_reply) \
5355 _(one_use_petr_reply) \
5356 _(one_stats_enable_disable_reply) \
5357 _(one_add_del_l2_arp_entry_reply) \
5358 _(one_add_del_ndp_entry_reply) \
5359 _(one_stats_flush_reply) \
5360 _(one_enable_disable_xtr_mode_reply) \
5361 _(one_enable_disable_pitr_mode_reply) \
5362 _(one_enable_disable_petr_mode_reply) \
5363 _(gpe_enable_disable_reply) \
5364 _(gpe_set_encap_mode_reply) \
5365 _(gpe_add_del_iface_reply) \
5366 _(gpe_add_del_native_fwd_rpath_reply) \
5367 _(af_packet_delete_reply) \
5368 _(policer_classify_set_interface_reply) \
5369 _(netmap_create_reply) \
5370 _(netmap_delete_reply) \
5371 _(set_ipfix_exporter_reply) \
5372 _(set_ipfix_classify_stream_reply) \
5373 _(ipfix_classify_table_add_del_reply) \
5374 _(flow_classify_set_interface_reply) \
5375 _(sw_interface_span_enable_disable_reply) \
5376 _(pg_capture_reply) \
5377 _(pg_enable_disable_reply) \
5378 _(ip_source_and_port_range_check_add_del_reply) \
5379 _(ip_source_and_port_range_check_interface_add_del_reply)\
5380 _(delete_subif_reply) \
5381 _(l2_interface_pbb_tag_rewrite_reply) \
5383 _(feature_enable_disable_reply) \
5384 _(sw_interface_tag_add_del_reply) \
5385 _(sw_interface_set_mtu_reply) \
5386 _(p2p_ethernet_add_reply) \
5387 _(p2p_ethernet_del_reply) \
5388 _(lldp_config_reply) \
5389 _(sw_interface_set_lldp_reply) \
5390 _(tcp_configure_src_addresses_reply) \
5391 _(dns_enable_disable_reply) \
5392 _(dns_name_server_add_del_reply) \
5393 _(session_rule_add_del_reply) \
5394 _(ip_container_proxy_add_del_reply)
5397 static void vl_api_##n##_t_handler \
5398 (vl_api_##n##_t * mp) \
5400 vat_main_t * vam = &vat_main; \
5401 i32 retval = ntohl(mp->retval); \
5402 if (vam->async_mode) { \
5403 vam->async_errors += (retval < 0); \
5405 vam->retval = retval; \
5406 vam->result_ready = 1; \
5409 foreach_standard_reply_retval_handler;
5413 static void vl_api_##n##_t_handler_json \
5414 (vl_api_##n##_t * mp) \
5416 vat_main_t * vam = &vat_main; \
5417 vat_json_node_t node; \
5418 vat_json_init_object(&node); \
5419 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5420 vat_json_print(vam->ofp, &node); \
5421 vam->retval = ntohl(mp->retval); \
5422 vam->result_ready = 1; \
5424 foreach_standard_reply_retval_handler;
5428 * Table of message reply handlers, must include boilerplate handlers
5432 #define foreach_vpe_api_reply_msg \
5433 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5434 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5435 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5436 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5437 _(CONTROL_PING_REPLY, control_ping_reply) \
5438 _(CLI_REPLY, cli_reply) \
5439 _(CLI_INBAND_REPLY, cli_inband_reply) \
5440 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5441 sw_interface_add_del_address_reply) \
5442 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5443 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5444 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5445 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5446 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5447 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5448 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5449 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5450 sw_interface_set_l2_xconnect_reply) \
5451 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5452 sw_interface_set_l2_bridge_reply) \
5453 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5454 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5455 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5456 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5457 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5458 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5459 _(L2_FLAGS_REPLY, l2_flags_reply) \
5460 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5461 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5462 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5463 _(TAP_DELETE_REPLY, tap_delete_reply) \
5464 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5465 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5466 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5467 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5468 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5469 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5470 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5471 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5472 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5473 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5474 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5475 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5476 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5477 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5478 proxy_arp_intfc_enable_disable_reply) \
5479 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5480 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5481 sw_interface_set_unnumbered_reply) \
5482 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5483 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5484 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5485 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5486 _(RESET_FIB_REPLY, reset_fib_reply) \
5487 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5488 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5489 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5490 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5491 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5492 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5493 sw_interface_ip6_enable_disable_reply) \
5494 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5495 sw_interface_ip6_set_link_local_address_reply) \
5496 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5497 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5498 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5499 sw_interface_ip6nd_ra_prefix_reply) \
5500 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5501 sw_interface_ip6nd_ra_config_reply) \
5502 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5503 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5504 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5505 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5506 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5507 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5508 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5509 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5510 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5511 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5512 classify_set_interface_ip_table_reply) \
5513 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5514 classify_set_interface_l2_tables_reply) \
5515 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5516 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5517 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5518 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5519 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5520 l2tpv3_interface_enable_disable_reply) \
5521 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5522 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5523 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5524 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5525 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5526 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5527 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5528 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5529 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5530 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5531 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5532 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5533 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5534 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5535 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5536 _(SHOW_VERSION_REPLY, show_version_reply) \
5537 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5538 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5539 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5540 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5541 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5542 _(IP4_ARP_EVENT, ip4_arp_event) \
5543 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5544 _(IP6_ND_EVENT, ip6_nd_event) \
5545 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5546 _(L2_MACS_EVENT, l2_macs_event) \
5547 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5548 _(IP_ADDRESS_DETAILS, ip_address_details) \
5549 _(IP_DETAILS, ip_details) \
5550 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5551 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5552 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5553 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5554 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5555 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5556 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5557 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5558 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5559 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5560 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5561 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5562 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5563 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5564 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5565 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5566 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5567 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5568 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5569 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5570 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5571 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5572 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5573 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5574 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5575 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5576 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5577 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5578 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5579 _(MAP_RULE_DETAILS, map_rule_details) \
5580 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5581 _(WANT_STATS_REPLY, want_stats_reply) \
5582 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5583 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5584 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5585 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5586 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5587 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5588 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5589 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5590 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5591 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5592 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5593 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5594 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5595 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5596 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5597 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5598 one_map_register_enable_disable_reply) \
5599 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5600 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5601 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5602 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5603 one_map_register_fallback_threshold_reply) \
5604 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5605 one_rloc_probe_enable_disable_reply) \
5606 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5607 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5608 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5609 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5610 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5611 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5612 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5613 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5614 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5615 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5616 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5617 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5618 _(ONE_STATS_DETAILS, one_stats_details) \
5619 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5620 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5621 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5622 show_one_stats_enable_disable_reply) \
5623 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5624 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5625 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5626 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5627 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5628 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5629 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5630 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5631 one_enable_disable_pitr_mode_reply) \
5632 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5633 one_enable_disable_petr_mode_reply) \
5634 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5635 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5636 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5637 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5638 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5639 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5640 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5641 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5642 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5643 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5644 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5645 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5646 gpe_add_del_native_fwd_rpath_reply) \
5647 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5648 gpe_fwd_entry_path_details) \
5649 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5650 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5651 one_add_del_map_request_itr_rlocs_reply) \
5652 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5653 one_get_map_request_itr_rlocs_reply) \
5654 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5655 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5656 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5657 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5658 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5659 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5660 show_one_map_register_state_reply) \
5661 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5662 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5663 show_one_map_register_fallback_threshold_reply) \
5664 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5665 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5666 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5667 _(POLICER_DETAILS, policer_details) \
5668 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5669 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5670 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5671 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5672 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5673 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5674 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5675 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5676 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5677 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5678 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5679 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5680 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5681 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5682 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5683 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5684 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5685 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5686 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5687 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5688 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5689 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5690 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5691 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5692 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5693 ip_source_and_port_range_check_add_del_reply) \
5694 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5695 ip_source_and_port_range_check_interface_add_del_reply) \
5696 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5697 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5698 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5699 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5700 _(PUNT_REPLY, punt_reply) \
5701 _(IP_FIB_DETAILS, ip_fib_details) \
5702 _(IP6_FIB_DETAILS, ip6_fib_details) \
5703 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5704 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5705 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5706 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5707 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5708 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5709 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5710 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5711 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5712 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5713 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5714 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5715 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5716 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5717 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5718 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5719 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5720 _(SESSION_RULES_DETAILS, session_rules_details) \
5721 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5723 #define foreach_standalone_reply_msg \
5724 _(SW_INTERFACE_EVENT, sw_interface_event) \
5725 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5726 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5727 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5728 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5729 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5730 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
5731 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
5740 #define STR_VTR_OP_CASE(op) \
5741 case L2_VTR_ ## op: \
5745 str_vtr_op (u32 vtr_op)
5749 STR_VTR_OP_CASE (DISABLED);
5750 STR_VTR_OP_CASE (PUSH_1);
5751 STR_VTR_OP_CASE (PUSH_2);
5752 STR_VTR_OP_CASE (POP_1);
5753 STR_VTR_OP_CASE (POP_2);
5754 STR_VTR_OP_CASE (TRANSLATE_1_1);
5755 STR_VTR_OP_CASE (TRANSLATE_1_2);
5756 STR_VTR_OP_CASE (TRANSLATE_2_1);
5757 STR_VTR_OP_CASE (TRANSLATE_2_2);
5764 dump_sub_interface_table (vat_main_t * vam)
5766 const sw_interface_subif_t *sub = NULL;
5768 if (vam->json_output)
5771 ("JSON output supported only for VPE API calls and dump_stats_table");
5776 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5777 "Interface", "sw_if_index",
5778 "sub id", "dot1ad", "tags", "outer id",
5779 "inner id", "exact", "default", "outer any", "inner any");
5781 vec_foreach (sub, vam->sw_if_subif_table)
5784 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5785 sub->interface_name,
5787 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5788 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5789 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5790 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5791 if (sub->vtr_op != L2_VTR_DISABLED)
5794 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5795 "tag1: %d tag2: %d ]",
5796 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5797 sub->vtr_tag1, sub->vtr_tag2);
5805 name_sort_cmp (void *a1, void *a2)
5807 name_sort_t *n1 = a1;
5808 name_sort_t *n2 = a2;
5810 return strcmp ((char *) n1->name, (char *) n2->name);
5814 dump_interface_table (vat_main_t * vam)
5817 name_sort_t *nses = 0, *ns;
5819 if (vam->json_output)
5822 ("JSON output supported only for VPE API calls and dump_stats_table");
5827 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5829 vec_add2 (nses, ns, 1);
5830 ns->name = (u8 *)(p->key);
5831 ns->value = (u32) p->value[0];
5835 vec_sort_with_function (nses, name_sort_cmp);
5837 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5838 vec_foreach (ns, nses)
5840 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5847 dump_ip_table (vat_main_t * vam, int is_ipv6)
5849 const ip_details_t *det = NULL;
5850 const ip_address_details_t *address = NULL;
5853 print (vam->ofp, "%-12s", "sw_if_index");
5855 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5862 print (vam->ofp, "%-12d", i);
5863 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5868 vec_foreach (address, det->addr)
5872 is_ipv6 ? format_ip6_address : format_ip4_address,
5873 address->ip, address->prefix_length);
5881 dump_ipv4_table (vat_main_t * vam)
5883 if (vam->json_output)
5886 ("JSON output supported only for VPE API calls and dump_stats_table");
5890 return dump_ip_table (vam, 0);
5894 dump_ipv6_table (vat_main_t * vam)
5896 if (vam->json_output)
5899 ("JSON output supported only for VPE API calls and dump_stats_table");
5903 return dump_ip_table (vam, 1);
5907 counter_type_to_str (u8 counter_type, u8 is_combined)
5911 switch (counter_type)
5913 case VNET_INTERFACE_COUNTER_DROP:
5915 case VNET_INTERFACE_COUNTER_PUNT:
5917 case VNET_INTERFACE_COUNTER_IP4:
5919 case VNET_INTERFACE_COUNTER_IP6:
5921 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5923 case VNET_INTERFACE_COUNTER_RX_MISS:
5925 case VNET_INTERFACE_COUNTER_RX_ERROR:
5927 case VNET_INTERFACE_COUNTER_TX_ERROR:
5930 return "INVALID-COUNTER-TYPE";
5935 switch (counter_type)
5937 case VNET_INTERFACE_COUNTER_RX:
5939 case VNET_INTERFACE_COUNTER_TX:
5942 return "INVALID-COUNTER-TYPE";
5948 dump_stats_table (vat_main_t * vam)
5950 vat_json_node_t node;
5951 vat_json_node_t *msg_array;
5952 vat_json_node_t *msg;
5953 vat_json_node_t *counter_array;
5954 vat_json_node_t *counter;
5955 interface_counter_t c;
5957 ip4_fib_counter_t *c4;
5958 ip6_fib_counter_t *c6;
5959 ip4_nbr_counter_t *n4;
5960 ip6_nbr_counter_t *n6;
5963 if (!vam->json_output)
5965 clib_warning ("dump_stats_table supported only in JSON format");
5969 vat_json_init_object (&node);
5971 /* interface counters */
5972 msg_array = vat_json_object_add (&node, "interface_counters");
5973 vat_json_init_array (msg_array);
5974 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5976 msg = vat_json_array_add (msg_array);
5977 vat_json_init_object (msg);
5978 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5979 (u8 *) counter_type_to_str (i, 0));
5980 vat_json_object_add_int (msg, "is_combined", 0);
5981 counter_array = vat_json_object_add (msg, "data");
5982 vat_json_init_array (counter_array);
5983 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5985 packets = vam->simple_interface_counters[i][j];
5986 vat_json_array_add_uint (counter_array, packets);
5989 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5991 msg = vat_json_array_add (msg_array);
5992 vat_json_init_object (msg);
5993 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5994 (u8 *) counter_type_to_str (i, 1));
5995 vat_json_object_add_int (msg, "is_combined", 1);
5996 counter_array = vat_json_object_add (msg, "data");
5997 vat_json_init_array (counter_array);
5998 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
6000 c = vam->combined_interface_counters[i][j];
6001 counter = vat_json_array_add (counter_array);
6002 vat_json_init_object (counter);
6003 vat_json_object_add_uint (counter, "packets", c.packets);
6004 vat_json_object_add_uint (counter, "bytes", c.bytes);
6008 /* ip4 fib counters */
6009 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
6010 vat_json_init_array (msg_array);
6011 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
6013 msg = vat_json_array_add (msg_array);
6014 vat_json_init_object (msg);
6015 vat_json_object_add_uint (msg, "vrf_id",
6016 vam->ip4_fib_counters_vrf_id_by_index[i]);
6017 counter_array = vat_json_object_add (msg, "c");
6018 vat_json_init_array (counter_array);
6019 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
6021 counter = vat_json_array_add (counter_array);
6022 vat_json_init_object (counter);
6023 c4 = &vam->ip4_fib_counters[i][j];
6024 vat_json_object_add_ip4 (counter, "address", c4->address);
6025 vat_json_object_add_uint (counter, "address_length",
6026 c4->address_length);
6027 vat_json_object_add_uint (counter, "packets", c4->packets);
6028 vat_json_object_add_uint (counter, "bytes", c4->bytes);
6032 /* ip6 fib counters */
6033 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
6034 vat_json_init_array (msg_array);
6035 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
6037 msg = vat_json_array_add (msg_array);
6038 vat_json_init_object (msg);
6039 vat_json_object_add_uint (msg, "vrf_id",
6040 vam->ip6_fib_counters_vrf_id_by_index[i]);
6041 counter_array = vat_json_object_add (msg, "c");
6042 vat_json_init_array (counter_array);
6043 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
6045 counter = vat_json_array_add (counter_array);
6046 vat_json_init_object (counter);
6047 c6 = &vam->ip6_fib_counters[i][j];
6048 vat_json_object_add_ip6 (counter, "address", c6->address);
6049 vat_json_object_add_uint (counter, "address_length",
6050 c6->address_length);
6051 vat_json_object_add_uint (counter, "packets", c6->packets);
6052 vat_json_object_add_uint (counter, "bytes", c6->bytes);
6056 /* ip4 nbr counters */
6057 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
6058 vat_json_init_array (msg_array);
6059 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
6061 msg = vat_json_array_add (msg_array);
6062 vat_json_init_object (msg);
6063 vat_json_object_add_uint (msg, "sw_if_index", i);
6064 counter_array = vat_json_object_add (msg, "c");
6065 vat_json_init_array (counter_array);
6066 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
6068 counter = vat_json_array_add (counter_array);
6069 vat_json_init_object (counter);
6070 n4 = &vam->ip4_nbr_counters[i][j];
6071 vat_json_object_add_ip4 (counter, "address", n4->address);
6072 vat_json_object_add_uint (counter, "link-type", n4->linkt);
6073 vat_json_object_add_uint (counter, "packets", n4->packets);
6074 vat_json_object_add_uint (counter, "bytes", n4->bytes);
6078 /* ip6 nbr counters */
6079 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
6080 vat_json_init_array (msg_array);
6081 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
6083 msg = vat_json_array_add (msg_array);
6084 vat_json_init_object (msg);
6085 vat_json_object_add_uint (msg, "sw_if_index", i);
6086 counter_array = vat_json_object_add (msg, "c");
6087 vat_json_init_array (counter_array);
6088 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
6090 counter = vat_json_array_add (counter_array);
6091 vat_json_init_object (counter);
6092 n6 = &vam->ip6_nbr_counters[i][j];
6093 vat_json_object_add_ip6 (counter, "address", n6->address);
6094 vat_json_object_add_uint (counter, "packets", n6->packets);
6095 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6099 vat_json_print (vam->ofp, &node);
6100 vat_json_free (&node);
6106 * Pass CLI buffers directly in the CLI_INBAND API message,
6107 * instead of an additional shared memory area.
6110 exec_inband (vat_main_t * vam)
6112 vl_api_cli_inband_t *mp;
6113 unformat_input_t *i = vam->input;
6116 if (vec_len (i->buffer) == 0)
6119 if (vam->exec_mode == 0 && unformat (i, "mode"))
6124 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6131 * In order for the CLI command to work, it
6132 * must be a vector ending in \n, not a C-string ending
6135 u32 len = vec_len (vam->input->buffer);
6136 M2 (CLI_INBAND, mp, len);
6137 clib_memcpy (mp->cmd, vam->input->buffer, len);
6138 mp->length = htonl (len);
6142 /* json responses may or may not include a useful reply... */
6143 if (vec_len (vam->cmd_reply))
6144 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6149 exec (vat_main_t * vam)
6151 return exec_inband (vam);
6155 api_create_loopback (vat_main_t * vam)
6157 unformat_input_t *i = vam->input;
6158 vl_api_create_loopback_t *mp;
6159 vl_api_create_loopback_instance_t *mp_lbi;
6162 u8 is_specified = 0;
6163 u32 user_instance = 0;
6166 memset (mac_address, 0, sizeof (mac_address));
6168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6170 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6172 if (unformat (i, "instance %d", &user_instance))
6180 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6181 mp_lbi->is_specified = is_specified;
6183 mp_lbi->user_instance = htonl (user_instance);
6185 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6190 /* Construct the API message */
6191 M (CREATE_LOOPBACK, mp);
6193 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6202 api_delete_loopback (vat_main_t * vam)
6204 unformat_input_t *i = vam->input;
6205 vl_api_delete_loopback_t *mp;
6206 u32 sw_if_index = ~0;
6209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6211 if (unformat (i, "sw_if_index %d", &sw_if_index))
6217 if (sw_if_index == ~0)
6219 errmsg ("missing sw_if_index");
6223 /* Construct the API message */
6224 M (DELETE_LOOPBACK, mp);
6225 mp->sw_if_index = ntohl (sw_if_index);
6233 api_want_stats (vat_main_t * vam)
6235 unformat_input_t *i = vam->input;
6236 vl_api_want_stats_t *mp;
6240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6242 if (unformat (i, "enable"))
6244 else if (unformat (i, "disable"))
6252 errmsg ("missing enable|disable");
6257 mp->enable_disable = enable;
6265 api_want_interface_events (vat_main_t * vam)
6267 unformat_input_t *i = vam->input;
6268 vl_api_want_interface_events_t *mp;
6272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6274 if (unformat (i, "enable"))
6276 else if (unformat (i, "disable"))
6284 errmsg ("missing enable|disable");
6288 M (WANT_INTERFACE_EVENTS, mp);
6289 mp->enable_disable = enable;
6291 vam->interface_event_display = enable;
6299 /* Note: non-static, called once to set up the initial intfc table */
6301 api_sw_interface_dump (vat_main_t * vam)
6303 vl_api_sw_interface_dump_t *mp;
6304 vl_api_control_ping_t *mp_ping;
6306 name_sort_t *nses = 0, *ns;
6307 sw_interface_subif_t *sub = NULL;
6310 /* Toss the old name table */
6312 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6314 vec_add2 (nses, ns, 1);
6315 ns->name = (u8 *)(p->key);
6316 ns->value = (u32) p->value[0];
6320 hash_free (vam->sw_if_index_by_interface_name);
6322 vec_foreach (ns, nses) vec_free (ns->name);
6326 vec_foreach (sub, vam->sw_if_subif_table)
6328 vec_free (sub->interface_name);
6330 vec_free (vam->sw_if_subif_table);
6332 /* recreate the interface name hash table */
6333 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6336 * Ask for all interface names. Otherwise, the epic catalog of
6337 * name filters becomes ridiculously long, and vat ends up needing
6338 * to be taught about new interface types.
6340 M (SW_INTERFACE_DUMP, mp);
6343 /* Use a control ping for synchronization */
6344 MPING (CONTROL_PING, mp_ping);
6352 api_sw_interface_set_flags (vat_main_t * vam)
6354 unformat_input_t *i = vam->input;
6355 vl_api_sw_interface_set_flags_t *mp;
6357 u8 sw_if_index_set = 0;
6361 /* Parse args required to build the message */
6362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6364 if (unformat (i, "admin-up"))
6366 else if (unformat (i, "admin-down"))
6369 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6370 sw_if_index_set = 1;
6371 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6372 sw_if_index_set = 1;
6377 if (sw_if_index_set == 0)
6379 errmsg ("missing interface name or sw_if_index");
6383 /* Construct the API message */
6384 M (SW_INTERFACE_SET_FLAGS, mp);
6385 mp->sw_if_index = ntohl (sw_if_index);
6386 mp->admin_up_down = admin_up;
6391 /* Wait for a reply, return the good/bad news... */
6397 api_sw_interface_set_rx_mode (vat_main_t * vam)
6399 unformat_input_t *i = vam->input;
6400 vl_api_sw_interface_set_rx_mode_t *mp;
6402 u8 sw_if_index_set = 0;
6404 u8 queue_id_valid = 0;
6406 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6408 /* Parse args required to build the message */
6409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6411 if (unformat (i, "queue %d", &queue_id))
6413 else if (unformat (i, "polling"))
6414 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6415 else if (unformat (i, "interrupt"))
6416 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6417 else if (unformat (i, "adaptive"))
6418 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6420 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6421 sw_if_index_set = 1;
6422 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6423 sw_if_index_set = 1;
6428 if (sw_if_index_set == 0)
6430 errmsg ("missing interface name or sw_if_index");
6433 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6435 errmsg ("missing rx-mode");
6439 /* Construct the API message */
6440 M (SW_INTERFACE_SET_RX_MODE, mp);
6441 mp->sw_if_index = ntohl (sw_if_index);
6443 mp->queue_id_valid = queue_id_valid;
6444 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6449 /* Wait for a reply, return the good/bad news... */
6455 api_sw_interface_clear_stats (vat_main_t * vam)
6457 unformat_input_t *i = vam->input;
6458 vl_api_sw_interface_clear_stats_t *mp;
6460 u8 sw_if_index_set = 0;
6463 /* Parse args required to build the message */
6464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6466 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6467 sw_if_index_set = 1;
6468 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6469 sw_if_index_set = 1;
6474 /* Construct the API message */
6475 M (SW_INTERFACE_CLEAR_STATS, mp);
6477 if (sw_if_index_set == 1)
6478 mp->sw_if_index = ntohl (sw_if_index);
6480 mp->sw_if_index = ~0;
6485 /* Wait for a reply, return the good/bad news... */
6491 api_sw_interface_add_del_address (vat_main_t * vam)
6493 unformat_input_t *i = vam->input;
6494 vl_api_sw_interface_add_del_address_t *mp;
6496 u8 sw_if_index_set = 0;
6497 u8 is_add = 1, del_all = 0;
6498 u32 address_length = 0;
6499 u8 v4_address_set = 0;
6500 u8 v6_address_set = 0;
6501 ip4_address_t v4address;
6502 ip6_address_t v6address;
6505 /* Parse args required to build the message */
6506 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6508 if (unformat (i, "del-all"))
6510 else if (unformat (i, "del"))
6513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6514 sw_if_index_set = 1;
6515 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6516 sw_if_index_set = 1;
6517 else if (unformat (i, "%U/%d",
6518 unformat_ip4_address, &v4address, &address_length))
6520 else if (unformat (i, "%U/%d",
6521 unformat_ip6_address, &v6address, &address_length))
6527 if (sw_if_index_set == 0)
6529 errmsg ("missing interface name or sw_if_index");
6532 if (v4_address_set && v6_address_set)
6534 errmsg ("both v4 and v6 addresses set");
6537 if (!v4_address_set && !v6_address_set && !del_all)
6539 errmsg ("no addresses set");
6543 /* Construct the API message */
6544 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6546 mp->sw_if_index = ntohl (sw_if_index);
6547 mp->is_add = is_add;
6548 mp->del_all = del_all;
6552 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6556 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6558 mp->address_length = address_length;
6563 /* Wait for a reply, return good/bad news */
6569 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6571 unformat_input_t *i = vam->input;
6572 vl_api_sw_interface_set_mpls_enable_t *mp;
6574 u8 sw_if_index_set = 0;
6578 /* Parse args required to build the message */
6579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6581 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6582 sw_if_index_set = 1;
6583 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6584 sw_if_index_set = 1;
6585 else if (unformat (i, "disable"))
6587 else if (unformat (i, "dis"))
6593 if (sw_if_index_set == 0)
6595 errmsg ("missing interface name or sw_if_index");
6599 /* Construct the API message */
6600 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6602 mp->sw_if_index = ntohl (sw_if_index);
6603 mp->enable = enable;
6608 /* Wait for a reply... */
6614 api_sw_interface_set_table (vat_main_t * vam)
6616 unformat_input_t *i = vam->input;
6617 vl_api_sw_interface_set_table_t *mp;
6618 u32 sw_if_index, vrf_id = 0;
6619 u8 sw_if_index_set = 0;
6623 /* Parse args required to build the message */
6624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6626 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6627 sw_if_index_set = 1;
6628 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6629 sw_if_index_set = 1;
6630 else if (unformat (i, "vrf %d", &vrf_id))
6632 else if (unformat (i, "ipv6"))
6638 if (sw_if_index_set == 0)
6640 errmsg ("missing interface name or sw_if_index");
6644 /* Construct the API message */
6645 M (SW_INTERFACE_SET_TABLE, mp);
6647 mp->sw_if_index = ntohl (sw_if_index);
6648 mp->is_ipv6 = is_ipv6;
6649 mp->vrf_id = ntohl (vrf_id);
6654 /* Wait for a reply... */
6659 static void vl_api_sw_interface_get_table_reply_t_handler
6660 (vl_api_sw_interface_get_table_reply_t * mp)
6662 vat_main_t *vam = &vat_main;
6664 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6666 vam->retval = ntohl (mp->retval);
6667 vam->result_ready = 1;
6671 static void vl_api_sw_interface_get_table_reply_t_handler_json
6672 (vl_api_sw_interface_get_table_reply_t * mp)
6674 vat_main_t *vam = &vat_main;
6675 vat_json_node_t node;
6677 vat_json_init_object (&node);
6678 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6679 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6681 vat_json_print (vam->ofp, &node);
6682 vat_json_free (&node);
6684 vam->retval = ntohl (mp->retval);
6685 vam->result_ready = 1;
6689 api_sw_interface_get_table (vat_main_t * vam)
6691 unformat_input_t *i = vam->input;
6692 vl_api_sw_interface_get_table_t *mp;
6694 u8 sw_if_index_set = 0;
6698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6700 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6701 sw_if_index_set = 1;
6702 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6703 sw_if_index_set = 1;
6704 else if (unformat (i, "ipv6"))
6710 if (sw_if_index_set == 0)
6712 errmsg ("missing interface name or sw_if_index");
6716 M (SW_INTERFACE_GET_TABLE, mp);
6717 mp->sw_if_index = htonl (sw_if_index);
6718 mp->is_ipv6 = is_ipv6;
6726 api_sw_interface_set_vpath (vat_main_t * vam)
6728 unformat_input_t *i = vam->input;
6729 vl_api_sw_interface_set_vpath_t *mp;
6730 u32 sw_if_index = 0;
6731 u8 sw_if_index_set = 0;
6735 /* Parse args required to build the message */
6736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6738 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6739 sw_if_index_set = 1;
6740 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6741 sw_if_index_set = 1;
6742 else if (unformat (i, "enable"))
6744 else if (unformat (i, "disable"))
6750 if (sw_if_index_set == 0)
6752 errmsg ("missing interface name or sw_if_index");
6756 /* Construct the API message */
6757 M (SW_INTERFACE_SET_VPATH, mp);
6759 mp->sw_if_index = ntohl (sw_if_index);
6760 mp->enable = is_enable;
6765 /* Wait for a reply... */
6771 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6773 unformat_input_t *i = vam->input;
6774 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6775 u32 sw_if_index = 0;
6776 u8 sw_if_index_set = 0;
6781 /* Parse args required to build the message */
6782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6784 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6785 sw_if_index_set = 1;
6786 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6787 sw_if_index_set = 1;
6788 else if (unformat (i, "enable"))
6790 else if (unformat (i, "disable"))
6792 else if (unformat (i, "ip4"))
6794 else if (unformat (i, "ip6"))
6800 if (sw_if_index_set == 0)
6802 errmsg ("missing interface name or sw_if_index");
6806 /* Construct the API message */
6807 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6809 mp->sw_if_index = ntohl (sw_if_index);
6810 mp->enable = is_enable;
6811 mp->is_ipv6 = is_ipv6;
6816 /* Wait for a reply... */
6822 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6824 unformat_input_t *i = vam->input;
6825 vl_api_sw_interface_set_geneve_bypass_t *mp;
6826 u32 sw_if_index = 0;
6827 u8 sw_if_index_set = 0;
6832 /* Parse args required to build the message */
6833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6835 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6836 sw_if_index_set = 1;
6837 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6838 sw_if_index_set = 1;
6839 else if (unformat (i, "enable"))
6841 else if (unformat (i, "disable"))
6843 else if (unformat (i, "ip4"))
6845 else if (unformat (i, "ip6"))
6851 if (sw_if_index_set == 0)
6853 errmsg ("missing interface name or sw_if_index");
6857 /* Construct the API message */
6858 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6860 mp->sw_if_index = ntohl (sw_if_index);
6861 mp->enable = is_enable;
6862 mp->is_ipv6 = is_ipv6;
6867 /* Wait for a reply... */
6873 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6875 unformat_input_t *i = vam->input;
6876 vl_api_sw_interface_set_l2_xconnect_t *mp;
6878 u8 rx_sw_if_index_set = 0;
6880 u8 tx_sw_if_index_set = 0;
6884 /* Parse args required to build the message */
6885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6887 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6888 rx_sw_if_index_set = 1;
6889 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6890 tx_sw_if_index_set = 1;
6891 else if (unformat (i, "rx"))
6893 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6895 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6897 rx_sw_if_index_set = 1;
6902 else if (unformat (i, "tx"))
6904 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6906 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6908 tx_sw_if_index_set = 1;
6913 else if (unformat (i, "enable"))
6915 else if (unformat (i, "disable"))
6921 if (rx_sw_if_index_set == 0)
6923 errmsg ("missing rx interface name or rx_sw_if_index");
6927 if (enable && (tx_sw_if_index_set == 0))
6929 errmsg ("missing tx interface name or tx_sw_if_index");
6933 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6935 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6936 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6937 mp->enable = enable;
6945 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6947 unformat_input_t *i = vam->input;
6948 vl_api_sw_interface_set_l2_bridge_t *mp;
6950 u8 rx_sw_if_index_set = 0;
6958 /* Parse args required to build the message */
6959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6961 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6962 rx_sw_if_index_set = 1;
6963 else if (unformat (i, "bd_id %d", &bd_id))
6967 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6968 rx_sw_if_index_set = 1;
6969 else if (unformat (i, "shg %d", &shg))
6971 else if (unformat (i, "bvi"))
6973 else if (unformat (i, "enable"))
6975 else if (unformat (i, "disable"))
6981 if (rx_sw_if_index_set == 0)
6983 errmsg ("missing rx interface name or sw_if_index");
6987 if (enable && (bd_id_set == 0))
6989 errmsg ("missing bridge domain");
6993 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6995 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6996 mp->bd_id = ntohl (bd_id);
6999 mp->enable = enable;
7007 api_bridge_domain_dump (vat_main_t * vam)
7009 unformat_input_t *i = vam->input;
7010 vl_api_bridge_domain_dump_t *mp;
7011 vl_api_control_ping_t *mp_ping;
7015 /* Parse args required to build the message */
7016 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7018 if (unformat (i, "bd_id %d", &bd_id))
7024 M (BRIDGE_DOMAIN_DUMP, mp);
7025 mp->bd_id = ntohl (bd_id);
7028 /* Use a control ping for synchronization */
7029 MPING (CONTROL_PING, mp_ping);
7037 api_bridge_domain_add_del (vat_main_t * vam)
7039 unformat_input_t *i = vam->input;
7040 vl_api_bridge_domain_add_del_t *mp;
7043 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7048 /* Parse args required to build the message */
7049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7051 if (unformat (i, "bd_id %d", &bd_id))
7053 else if (unformat (i, "flood %d", &flood))
7055 else if (unformat (i, "uu-flood %d", &uu_flood))
7057 else if (unformat (i, "forward %d", &forward))
7059 else if (unformat (i, "learn %d", &learn))
7061 else if (unformat (i, "arp-term %d", &arp_term))
7063 else if (unformat (i, "mac-age %d", &mac_age))
7065 else if (unformat (i, "bd-tag %s", &bd_tag))
7067 else if (unformat (i, "del"))
7070 flood = uu_flood = forward = learn = 0;
7078 errmsg ("missing bridge domain");
7085 errmsg ("mac age must be less than 256 ");
7090 if ((bd_tag) && (vec_len (bd_tag) > 63))
7092 errmsg ("bd-tag cannot be longer than 63");
7097 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7099 mp->bd_id = ntohl (bd_id);
7101 mp->uu_flood = uu_flood;
7102 mp->forward = forward;
7104 mp->arp_term = arp_term;
7105 mp->is_add = is_add;
7106 mp->mac_age = (u8) mac_age;
7109 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
7110 mp->bd_tag[vec_len (bd_tag)] = 0;
7121 api_l2fib_flush_bd (vat_main_t * vam)
7123 unformat_input_t *i = vam->input;
7124 vl_api_l2fib_flush_bd_t *mp;
7128 /* Parse args required to build the message */
7129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7131 if (unformat (i, "bd_id %d", &bd_id));
7138 errmsg ("missing bridge domain");
7142 M (L2FIB_FLUSH_BD, mp);
7144 mp->bd_id = htonl (bd_id);
7152 api_l2fib_flush_int (vat_main_t * vam)
7154 unformat_input_t *i = vam->input;
7155 vl_api_l2fib_flush_int_t *mp;
7156 u32 sw_if_index = ~0;
7159 /* Parse args required to build the message */
7160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7162 if (unformat (i, "sw_if_index %d", &sw_if_index));
7164 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7169 if (sw_if_index == ~0)
7171 errmsg ("missing interface name or sw_if_index");
7175 M (L2FIB_FLUSH_INT, mp);
7177 mp->sw_if_index = ntohl (sw_if_index);
7185 api_l2fib_add_del (vat_main_t * vam)
7187 unformat_input_t *i = vam->input;
7188 vl_api_l2fib_add_del_t *mp;
7194 u32 sw_if_index = ~0;
7195 u8 sw_if_index_set = 0;
7204 /* Parse args required to build the message */
7205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7207 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7209 else if (unformat (i, "bd_id %d", &bd_id))
7211 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7212 sw_if_index_set = 1;
7213 else if (unformat (i, "sw_if"))
7215 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7218 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7219 sw_if_index_set = 1;
7224 else if (unformat (i, "static"))
7226 else if (unformat (i, "filter"))
7231 else if (unformat (i, "bvi"))
7236 else if (unformat (i, "del"))
7238 else if (unformat (i, "count %d", &count))
7246 errmsg ("missing mac address");
7252 errmsg ("missing bridge domain");
7256 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7258 errmsg ("missing interface name or sw_if_index");
7264 /* Turn on async mode */
7265 vam->async_mode = 1;
7266 vam->async_errors = 0;
7267 before = vat_time_now (vam);
7270 for (j = 0; j < count; j++)
7272 M (L2FIB_ADD_DEL, mp);
7274 clib_memcpy (mp->mac, mac, 6);
7275 mp->bd_id = ntohl (bd_id);
7276 mp->is_add = is_add;
7280 mp->sw_if_index = ntohl (sw_if_index);
7281 mp->static_mac = static_mac;
7282 mp->filter_mac = filter_mac;
7283 mp->bvi_mac = bvi_mac;
7285 increment_mac_address (mac);
7292 vl_api_control_ping_t *mp_ping;
7295 /* Shut off async mode */
7296 vam->async_mode = 0;
7298 MPING (CONTROL_PING, mp_ping);
7301 timeout = vat_time_now (vam) + 1.0;
7302 while (vat_time_now (vam) < timeout)
7303 if (vam->result_ready == 1)
7308 if (vam->retval == -99)
7311 if (vam->async_errors > 0)
7313 errmsg ("%d asynchronous errors", vam->async_errors);
7316 vam->async_errors = 0;
7317 after = vat_time_now (vam);
7319 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7320 count, after - before, count / (after - before));
7326 /* Wait for a reply... */
7330 /* Return the good/bad news */
7331 return (vam->retval);
7335 api_bridge_domain_set_mac_age (vat_main_t * vam)
7337 unformat_input_t *i = vam->input;
7338 vl_api_bridge_domain_set_mac_age_t *mp;
7343 /* Parse args required to build the message */
7344 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7346 if (unformat (i, "bd_id %d", &bd_id));
7347 else if (unformat (i, "mac-age %d", &mac_age));
7354 errmsg ("missing bridge domain");
7360 errmsg ("mac age must be less than 256 ");
7364 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7366 mp->bd_id = htonl (bd_id);
7367 mp->mac_age = (u8) mac_age;
7375 api_l2_flags (vat_main_t * vam)
7377 unformat_input_t *i = vam->input;
7378 vl_api_l2_flags_t *mp;
7381 u8 sw_if_index_set = 0;
7385 /* Parse args required to build the message */
7386 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7388 if (unformat (i, "sw_if_index %d", &sw_if_index))
7389 sw_if_index_set = 1;
7390 else if (unformat (i, "sw_if"))
7392 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7395 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7396 sw_if_index_set = 1;
7401 else if (unformat (i, "learn"))
7403 else if (unformat (i, "forward"))
7405 else if (unformat (i, "flood"))
7407 else if (unformat (i, "uu-flood"))
7408 flags |= L2_UU_FLOOD;
7409 else if (unformat (i, "arp-term"))
7410 flags |= L2_ARP_TERM;
7411 else if (unformat (i, "off"))
7413 else if (unformat (i, "disable"))
7419 if (sw_if_index_set == 0)
7421 errmsg ("missing interface name or sw_if_index");
7427 mp->sw_if_index = ntohl (sw_if_index);
7428 mp->feature_bitmap = ntohl (flags);
7429 mp->is_set = is_set;
7437 api_bridge_flags (vat_main_t * vam)
7439 unformat_input_t *i = vam->input;
7440 vl_api_bridge_flags_t *mp;
7447 /* Parse args required to build the message */
7448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7450 if (unformat (i, "bd_id %d", &bd_id))
7452 else if (unformat (i, "learn"))
7454 else if (unformat (i, "forward"))
7456 else if (unformat (i, "flood"))
7458 else if (unformat (i, "uu-flood"))
7459 flags |= L2_UU_FLOOD;
7460 else if (unformat (i, "arp-term"))
7461 flags |= L2_ARP_TERM;
7462 else if (unformat (i, "off"))
7464 else if (unformat (i, "disable"))
7472 errmsg ("missing bridge domain");
7476 M (BRIDGE_FLAGS, mp);
7478 mp->bd_id = ntohl (bd_id);
7479 mp->feature_bitmap = ntohl (flags);
7480 mp->is_set = is_set;
7488 api_bd_ip_mac_add_del (vat_main_t * vam)
7490 unformat_input_t *i = vam->input;
7491 vl_api_bd_ip_mac_add_del_t *mp;
7498 ip4_address_t v4addr;
7499 ip6_address_t v6addr;
7504 /* Parse args required to build the message */
7505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7507 if (unformat (i, "bd_id %d", &bd_id))
7511 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7515 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7520 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7524 else if (unformat (i, "del"))
7532 errmsg ("missing bridge domain");
7535 else if (ip_set == 0)
7537 errmsg ("missing IP address");
7540 else if (mac_set == 0)
7542 errmsg ("missing MAC address");
7546 M (BD_IP_MAC_ADD_DEL, mp);
7548 mp->bd_id = ntohl (bd_id);
7549 mp->is_ipv6 = is_ipv6;
7550 mp->is_add = is_add;
7552 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7554 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7555 clib_memcpy (mp->mac_address, macaddr, 6);
7562 api_tap_connect (vat_main_t * vam)
7564 unformat_input_t *i = vam->input;
7565 vl_api_tap_connect_t *mp;
7571 ip4_address_t ip4_address;
7573 int ip4_address_set = 0;
7574 ip6_address_t ip6_address;
7576 int ip6_address_set = 0;
7579 memset (mac_address, 0, sizeof (mac_address));
7581 /* Parse args required to build the message */
7582 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7584 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7588 else if (unformat (i, "random-mac"))
7590 else if (unformat (i, "tapname %s", &tap_name))
7592 else if (unformat (i, "tag %s", &tag))
7594 else if (unformat (i, "address %U/%d",
7595 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7596 ip4_address_set = 1;
7597 else if (unformat (i, "address %U/%d",
7598 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7599 ip6_address_set = 1;
7606 errmsg ("missing tap name");
7609 if (vec_len (tap_name) > 63)
7611 errmsg ("tap name too long");
7614 vec_add1 (tap_name, 0);
7616 if (vec_len (tag) > 63)
7618 errmsg ("tag too long");
7622 /* Construct the API message */
7623 M (TAP_CONNECT, mp);
7625 mp->use_random_mac = random_mac;
7626 clib_memcpy (mp->mac_address, mac_address, 6);
7627 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7629 clib_memcpy (mp->tag, tag, vec_len (tag));
7631 if (ip4_address_set)
7633 mp->ip4_address_set = 1;
7634 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7635 mp->ip4_mask_width = ip4_mask_width;
7637 if (ip6_address_set)
7639 mp->ip6_address_set = 1;
7640 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7641 mp->ip6_mask_width = ip6_mask_width;
7644 vec_free (tap_name);
7650 /* Wait for a reply... */
7656 api_tap_modify (vat_main_t * vam)
7658 unformat_input_t *i = vam->input;
7659 vl_api_tap_modify_t *mp;
7664 u32 sw_if_index = ~0;
7665 u8 sw_if_index_set = 0;
7668 memset (mac_address, 0, sizeof (mac_address));
7670 /* Parse args required to build the message */
7671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7673 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7674 sw_if_index_set = 1;
7675 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7676 sw_if_index_set = 1;
7677 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7681 else if (unformat (i, "random-mac"))
7683 else if (unformat (i, "tapname %s", &tap_name))
7689 if (sw_if_index_set == 0)
7691 errmsg ("missing vpp interface name");
7696 errmsg ("missing tap name");
7699 if (vec_len (tap_name) > 63)
7701 errmsg ("tap name too long");
7703 vec_add1 (tap_name, 0);
7705 /* Construct the API message */
7708 mp->use_random_mac = random_mac;
7709 mp->sw_if_index = ntohl (sw_if_index);
7710 clib_memcpy (mp->mac_address, mac_address, 6);
7711 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7712 vec_free (tap_name);
7717 /* Wait for a reply... */
7723 api_tap_delete (vat_main_t * vam)
7725 unformat_input_t *i = vam->input;
7726 vl_api_tap_delete_t *mp;
7727 u32 sw_if_index = ~0;
7728 u8 sw_if_index_set = 0;
7731 /* Parse args required to build the message */
7732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7734 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7735 sw_if_index_set = 1;
7736 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7737 sw_if_index_set = 1;
7742 if (sw_if_index_set == 0)
7744 errmsg ("missing vpp interface name");
7748 /* Construct the API message */
7751 mp->sw_if_index = ntohl (sw_if_index);
7756 /* Wait for a reply... */
7762 api_tap_create_v2 (vat_main_t * vam)
7764 unformat_input_t *i = vam->input;
7765 vl_api_tap_create_v2_t *mp;
7769 u8 *host_if_name = 0;
7771 u8 host_mac_addr[6];
7772 u8 host_mac_addr_set = 0;
7773 u8 *host_bridge = 0;
7774 ip4_address_t host_ip4_addr;
7775 ip4_address_t host_ip4_gw;
7776 u8 host_ip4_gw_set = 0;
7777 u32 host_ip4_prefix_len = 0;
7778 ip6_address_t host_ip6_addr;
7779 ip6_address_t host_ip6_gw;
7780 u8 host_ip6_gw_set = 0;
7781 u32 host_ip6_prefix_len = 0;
7783 int rx_ring_sz = 0, tx_ring_sz = 0;
7785 memset (mac_address, 0, sizeof (mac_address));
7787 /* Parse args required to build the message */
7788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7790 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7794 else if (unformat (i, "id %s", &id))
7796 else if (unformat (i, "host-if-name %s", &host_if_name))
7798 else if (unformat (i, "host-ns %s", &host_ns))
7800 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7802 host_mac_addr_set = 1;
7803 else if (unformat (i, "host-bridge %s", &host_bridge))
7805 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7806 &host_ip4_addr, &host_ip4_prefix_len))
7808 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7809 &host_ip6_addr, &host_ip6_prefix_len))
7811 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7813 host_ip4_gw_set = 1;
7814 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7816 host_ip6_gw_set = 1;
7817 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7819 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7825 if (vec_len (host_if_name) > 63)
7827 errmsg ("tap name too long. ");
7830 if (vec_len (host_ns) > 63)
7832 errmsg ("host name space too long. ");
7835 if (vec_len (host_bridge) > 63)
7837 errmsg ("host bridge name too long. ");
7840 if (host_ip4_prefix_len > 32)
7842 errmsg ("host ip4 prefix length not valid. ");
7845 if (host_ip6_prefix_len > 128)
7847 errmsg ("host ip6 prefix length not valid. ");
7850 if (!is_pow2 (rx_ring_sz))
7852 errmsg ("rx ring size must be power of 2. ");
7855 if (rx_ring_sz > 32768)
7857 errmsg ("rx ring size must be 32768 or lower. ");
7860 if (!is_pow2 (tx_ring_sz))
7862 errmsg ("tx ring size must be power of 2. ");
7865 if (tx_ring_sz > 32768)
7867 errmsg ("tx ring size must be 32768 or lower. ");
7871 /* Construct the API message */
7872 M (TAP_CREATE_V2, mp);
7874 mp->use_random_mac = random_mac;
7877 mp->host_namespace_set = host_ns != 0;
7878 mp->host_bridge_set = host_bridge != 0;
7879 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7880 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7881 mp->rx_ring_sz = rx_ring_sz;
7882 mp->tx_ring_sz = tx_ring_sz;
7885 clib_memcpy (mp->mac_address, mac_address, 6);
7886 if (host_mac_addr_set)
7887 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7889 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7891 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7893 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7894 if (host_ip4_prefix_len)
7895 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7896 if (host_ip4_prefix_len)
7897 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7898 if (host_ip4_gw_set)
7899 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7900 if (host_ip6_gw_set)
7901 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7904 vec_free (host_if_name);
7905 vec_free (host_bridge);
7910 /* Wait for a reply... */
7916 api_tap_delete_v2 (vat_main_t * vam)
7918 unformat_input_t *i = vam->input;
7919 vl_api_tap_delete_v2_t *mp;
7920 u32 sw_if_index = ~0;
7921 u8 sw_if_index_set = 0;
7924 /* Parse args required to build the message */
7925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7927 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7928 sw_if_index_set = 1;
7929 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7930 sw_if_index_set = 1;
7935 if (sw_if_index_set == 0)
7937 errmsg ("missing vpp interface name. ");
7941 /* Construct the API message */
7942 M (TAP_DELETE_V2, mp);
7944 mp->sw_if_index = ntohl (sw_if_index);
7949 /* Wait for a reply... */
7955 api_ip_table_add_del (vat_main_t * vam)
7957 unformat_input_t *i = vam->input;
7958 vl_api_ip_table_add_del_t *mp;
7964 /* Parse args required to build the message */
7965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7967 if (unformat (i, "ipv6"))
7969 else if (unformat (i, "del"))
7971 else if (unformat (i, "add"))
7973 else if (unformat (i, "table %d", &table_id))
7977 clib_warning ("parse error '%U'", format_unformat_error, i);
7984 errmsg ("missing table-ID");
7988 /* Construct the API message */
7989 M (IP_TABLE_ADD_DEL, mp);
7991 mp->table_id = ntohl (table_id);
7992 mp->is_ipv6 = is_ipv6;
7993 mp->is_add = is_add;
7998 /* Wait for a reply... */
8005 api_ip_add_del_route (vat_main_t * vam)
8007 unformat_input_t *i = vam->input;
8008 vl_api_ip_add_del_route_t *mp;
8009 u32 sw_if_index = ~0, vrf_id = 0;
8011 u8 is_local = 0, is_drop = 0;
8012 u8 is_unreach = 0, is_prohibit = 0;
8014 u32 next_hop_weight = 1;
8015 u8 is_multipath = 0;
8017 u8 address_length_set = 0;
8018 u32 next_hop_table_id = 0;
8019 u32 resolve_attempts = 0;
8020 u32 dst_address_length = 0;
8021 u8 next_hop_set = 0;
8022 ip4_address_t v4_dst_address, v4_next_hop_address;
8023 ip6_address_t v6_dst_address, v6_next_hop_address;
8027 u32 random_add_del = 0;
8028 u32 *random_vector = 0;
8030 u32 random_seed = 0xdeaddabe;
8031 u32 classify_table_index = ~0;
8033 u8 resolve_host = 0, resolve_attached = 0;
8034 mpls_label_t *next_hop_out_label_stack = NULL;
8035 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8036 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8038 /* Parse args required to build the message */
8039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8041 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8043 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8045 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8050 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8055 else if (unformat (i, "/%d", &dst_address_length))
8057 address_length_set = 1;
8060 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8061 &v4_next_hop_address))
8065 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8066 &v6_next_hop_address))
8070 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8072 else if (unformat (i, "weight %d", &next_hop_weight))
8074 else if (unformat (i, "drop"))
8078 else if (unformat (i, "null-send-unreach"))
8082 else if (unformat (i, "null-send-prohibit"))
8086 else if (unformat (i, "local"))
8090 else if (unformat (i, "classify %d", &classify_table_index))
8094 else if (unformat (i, "del"))
8096 else if (unformat (i, "add"))
8098 else if (unformat (i, "resolve-via-host"))
8100 else if (unformat (i, "resolve-via-attached"))
8101 resolve_attached = 1;
8102 else if (unformat (i, "multipath"))
8104 else if (unformat (i, "vrf %d", &vrf_id))
8106 else if (unformat (i, "count %d", &count))
8108 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8110 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8112 else if (unformat (i, "out-label %d", &next_hop_out_label))
8113 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8114 else if (unformat (i, "via-label %d", &next_hop_via_label))
8116 else if (unformat (i, "random"))
8118 else if (unformat (i, "seed %d", &random_seed))
8122 clib_warning ("parse error '%U'", format_unformat_error, i);
8127 if (!next_hop_set && !is_drop && !is_local &&
8128 !is_classify && !is_unreach && !is_prohibit &&
8129 MPLS_LABEL_INVALID == next_hop_via_label)
8132 ("next hop / local / drop / unreach / prohibit / classify not set");
8136 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8138 errmsg ("next hop and next-hop via label set");
8141 if (address_set == 0)
8143 errmsg ("missing addresses");
8147 if (address_length_set == 0)
8149 errmsg ("missing address length");
8153 /* Generate a pile of unique, random routes */
8156 u32 this_random_address;
8157 random_hash = hash_create (count, sizeof (uword));
8159 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8160 for (j = 0; j <= count; j++)
8164 this_random_address = random_u32 (&random_seed);
8165 this_random_address =
8166 clib_host_to_net_u32 (this_random_address);
8168 while (hash_get (random_hash, this_random_address));
8169 vec_add1 (random_vector, this_random_address);
8170 hash_set (random_hash, this_random_address, 1);
8172 hash_free (random_hash);
8173 v4_dst_address.as_u32 = random_vector[0];
8178 /* Turn on async mode */
8179 vam->async_mode = 1;
8180 vam->async_errors = 0;
8181 before = vat_time_now (vam);
8184 for (j = 0; j < count; j++)
8186 /* Construct the API message */
8187 M2 (IP_ADD_DEL_ROUTE, mp,
8188 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8190 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8191 mp->table_id = ntohl (vrf_id);
8193 mp->is_add = is_add;
8194 mp->is_drop = is_drop;
8195 mp->is_unreach = is_unreach;
8196 mp->is_prohibit = is_prohibit;
8197 mp->is_ipv6 = is_ipv6;
8198 mp->is_local = is_local;
8199 mp->is_classify = is_classify;
8200 mp->is_multipath = is_multipath;
8201 mp->is_resolve_host = resolve_host;
8202 mp->is_resolve_attached = resolve_attached;
8203 mp->next_hop_weight = next_hop_weight;
8204 mp->dst_address_length = dst_address_length;
8205 mp->next_hop_table_id = ntohl (next_hop_table_id);
8206 mp->classify_table_index = ntohl (classify_table_index);
8207 mp->next_hop_via_label = ntohl (next_hop_via_label);
8208 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8209 if (0 != mp->next_hop_n_out_labels)
8211 memcpy (mp->next_hop_out_label_stack,
8212 next_hop_out_label_stack,
8213 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8214 vec_free (next_hop_out_label_stack);
8219 clib_memcpy (mp->dst_address, &v6_dst_address,
8220 sizeof (v6_dst_address));
8222 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8223 sizeof (v6_next_hop_address));
8224 increment_v6_address (&v6_dst_address);
8228 clib_memcpy (mp->dst_address, &v4_dst_address,
8229 sizeof (v4_dst_address));
8231 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8232 sizeof (v4_next_hop_address));
8234 v4_dst_address.as_u32 = random_vector[j + 1];
8236 increment_v4_address (&v4_dst_address);
8240 /* If we receive SIGTERM, stop now... */
8245 /* When testing multiple add/del ops, use a control-ping to sync */
8248 vl_api_control_ping_t *mp_ping;
8252 /* Shut off async mode */
8253 vam->async_mode = 0;
8255 MPING (CONTROL_PING, mp_ping);
8258 timeout = vat_time_now (vam) + 1.0;
8259 while (vat_time_now (vam) < timeout)
8260 if (vam->result_ready == 1)
8265 if (vam->retval == -99)
8268 if (vam->async_errors > 0)
8270 errmsg ("%d asynchronous errors", vam->async_errors);
8273 vam->async_errors = 0;
8274 after = vat_time_now (vam);
8276 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8280 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8281 count, after - before, count / (after - before));
8287 /* Wait for a reply... */
8292 /* Return the good/bad news */
8293 return (vam->retval);
8297 api_ip_mroute_add_del (vat_main_t * vam)
8299 unformat_input_t *i = vam->input;
8300 vl_api_ip_mroute_add_del_t *mp;
8301 u32 sw_if_index = ~0, vrf_id = 0;
8306 u32 grp_address_length = 0;
8307 ip4_address_t v4_grp_address, v4_src_address;
8308 ip6_address_t v6_grp_address, v6_src_address;
8309 mfib_itf_flags_t iflags = 0;
8310 mfib_entry_flags_t eflags = 0;
8313 /* Parse args required to build the message */
8314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8316 if (unformat (i, "sw_if_index %d", &sw_if_index))
8318 else if (unformat (i, "%U %U",
8319 unformat_ip4_address, &v4_src_address,
8320 unformat_ip4_address, &v4_grp_address))
8322 grp_address_length = 64;
8326 else if (unformat (i, "%U %U",
8327 unformat_ip6_address, &v6_src_address,
8328 unformat_ip6_address, &v6_grp_address))
8330 grp_address_length = 256;
8334 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8336 memset (&v4_src_address, 0, sizeof (v4_src_address));
8337 grp_address_length = 32;
8341 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8343 memset (&v6_src_address, 0, sizeof (v6_src_address));
8344 grp_address_length = 128;
8348 else if (unformat (i, "/%d", &grp_address_length))
8350 else if (unformat (i, "local"))
8354 else if (unformat (i, "del"))
8356 else if (unformat (i, "add"))
8358 else if (unformat (i, "vrf %d", &vrf_id))
8360 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8362 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8366 clib_warning ("parse error '%U'", format_unformat_error, i);
8371 if (address_set == 0)
8373 errmsg ("missing addresses\n");
8377 /* Construct the API message */
8378 M (IP_MROUTE_ADD_DEL, mp);
8380 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8381 mp->table_id = ntohl (vrf_id);
8383 mp->is_add = is_add;
8384 mp->is_ipv6 = is_ipv6;
8385 mp->is_local = is_local;
8386 mp->itf_flags = ntohl (iflags);
8387 mp->entry_flags = ntohl (eflags);
8388 mp->grp_address_length = grp_address_length;
8389 mp->grp_address_length = ntohs (mp->grp_address_length);
8393 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8394 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8398 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8399 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8405 /* Wait for a reply... */
8411 api_mpls_table_add_del (vat_main_t * vam)
8413 unformat_input_t *i = vam->input;
8414 vl_api_mpls_table_add_del_t *mp;
8419 /* Parse args required to build the message */
8420 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8422 if (unformat (i, "table %d", &table_id))
8424 else if (unformat (i, "del"))
8426 else if (unformat (i, "add"))
8430 clib_warning ("parse error '%U'", format_unformat_error, i);
8437 errmsg ("missing table-ID");
8441 /* Construct the API message */
8442 M (MPLS_TABLE_ADD_DEL, mp);
8444 mp->mt_table_id = ntohl (table_id);
8445 mp->mt_is_add = is_add;
8450 /* Wait for a reply... */
8457 api_mpls_route_add_del (vat_main_t * vam)
8459 unformat_input_t *i = vam->input;
8460 vl_api_mpls_route_add_del_t *mp;
8461 u32 sw_if_index = ~0, table_id = 0;
8463 u32 next_hop_weight = 1;
8464 u8 is_multipath = 0;
8465 u32 next_hop_table_id = 0;
8466 u8 next_hop_set = 0;
8467 ip4_address_t v4_next_hop_address = {
8470 ip6_address_t v6_next_hop_address = { {0} };
8474 u32 classify_table_index = ~0;
8476 u8 resolve_host = 0, resolve_attached = 0;
8477 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8478 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8479 mpls_label_t *next_hop_out_label_stack = NULL;
8480 mpls_label_t local_label = MPLS_LABEL_INVALID;
8482 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8484 /* Parse args required to build the message */
8485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8487 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8489 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8491 else if (unformat (i, "%d", &local_label))
8493 else if (unformat (i, "eos"))
8495 else if (unformat (i, "non-eos"))
8497 else if (unformat (i, "via %U", unformat_ip4_address,
8498 &v4_next_hop_address))
8501 next_hop_proto = DPO_PROTO_IP4;
8503 else if (unformat (i, "via %U", unformat_ip6_address,
8504 &v6_next_hop_address))
8507 next_hop_proto = DPO_PROTO_IP6;
8509 else if (unformat (i, "weight %d", &next_hop_weight))
8511 else if (unformat (i, "classify %d", &classify_table_index))
8515 else if (unformat (i, "del"))
8517 else if (unformat (i, "add"))
8519 else if (unformat (i, "resolve-via-host"))
8521 else if (unformat (i, "resolve-via-attached"))
8522 resolve_attached = 1;
8523 else if (unformat (i, "multipath"))
8525 else if (unformat (i, "count %d", &count))
8527 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8530 next_hop_proto = DPO_PROTO_IP4;
8532 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8535 next_hop_proto = DPO_PROTO_IP6;
8537 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8539 else if (unformat (i, "via-label %d", &next_hop_via_label))
8541 else if (unformat (i, "out-label %d", &next_hop_out_label))
8542 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8545 clib_warning ("parse error '%U'", format_unformat_error, i);
8550 if (!next_hop_set && !is_classify)
8552 errmsg ("next hop / classify not set");
8556 if (MPLS_LABEL_INVALID == local_label)
8558 errmsg ("missing label");
8564 /* Turn on async mode */
8565 vam->async_mode = 1;
8566 vam->async_errors = 0;
8567 before = vat_time_now (vam);
8570 for (j = 0; j < count; j++)
8572 /* Construct the API message */
8573 M2 (MPLS_ROUTE_ADD_DEL, mp,
8574 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8576 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8577 mp->mr_table_id = ntohl (table_id);
8579 mp->mr_is_add = is_add;
8580 mp->mr_next_hop_proto = next_hop_proto;
8581 mp->mr_is_classify = is_classify;
8582 mp->mr_is_multipath = is_multipath;
8583 mp->mr_is_resolve_host = resolve_host;
8584 mp->mr_is_resolve_attached = resolve_attached;
8585 mp->mr_next_hop_weight = next_hop_weight;
8586 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8587 mp->mr_classify_table_index = ntohl (classify_table_index);
8588 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8589 mp->mr_label = ntohl (local_label);
8590 mp->mr_eos = is_eos;
8592 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8593 if (0 != mp->mr_next_hop_n_out_labels)
8595 memcpy (mp->mr_next_hop_out_label_stack,
8596 next_hop_out_label_stack,
8597 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8598 vec_free (next_hop_out_label_stack);
8603 if (DPO_PROTO_IP4 == next_hop_proto)
8605 clib_memcpy (mp->mr_next_hop,
8606 &v4_next_hop_address,
8607 sizeof (v4_next_hop_address));
8609 else if (DPO_PROTO_IP6 == next_hop_proto)
8612 clib_memcpy (mp->mr_next_hop,
8613 &v6_next_hop_address,
8614 sizeof (v6_next_hop_address));
8621 /* If we receive SIGTERM, stop now... */
8626 /* When testing multiple add/del ops, use a control-ping to sync */
8629 vl_api_control_ping_t *mp_ping;
8633 /* Shut off async mode */
8634 vam->async_mode = 0;
8636 MPING (CONTROL_PING, mp_ping);
8639 timeout = vat_time_now (vam) + 1.0;
8640 while (vat_time_now (vam) < timeout)
8641 if (vam->result_ready == 1)
8646 if (vam->retval == -99)
8649 if (vam->async_errors > 0)
8651 errmsg ("%d asynchronous errors", vam->async_errors);
8654 vam->async_errors = 0;
8655 after = vat_time_now (vam);
8657 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8661 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8662 count, after - before, count / (after - before));
8668 /* Wait for a reply... */
8673 /* Return the good/bad news */
8674 return (vam->retval);
8678 api_mpls_ip_bind_unbind (vat_main_t * vam)
8680 unformat_input_t *i = vam->input;
8681 vl_api_mpls_ip_bind_unbind_t *mp;
8682 u32 ip_table_id = 0;
8685 ip4_address_t v4_address;
8686 ip6_address_t v6_address;
8689 mpls_label_t local_label = MPLS_LABEL_INVALID;
8692 /* Parse args required to build the message */
8693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8695 if (unformat (i, "%U/%d", unformat_ip4_address,
8696 &v4_address, &address_length))
8701 else if (unformat (i, "%U/%d", unformat_ip6_address,
8702 &v6_address, &address_length))
8707 else if (unformat (i, "%d", &local_label))
8709 else if (unformat (i, "table-id %d", &ip_table_id))
8711 else if (unformat (i, "unbind"))
8713 else if (unformat (i, "bind"))
8717 clib_warning ("parse error '%U'", format_unformat_error, i);
8724 errmsg ("IP addres not set");
8728 if (MPLS_LABEL_INVALID == local_label)
8730 errmsg ("missing label");
8734 /* Construct the API message */
8735 M (MPLS_IP_BIND_UNBIND, mp);
8737 mp->mb_is_bind = is_bind;
8738 mp->mb_is_ip4 = is_ip4;
8739 mp->mb_ip_table_id = ntohl (ip_table_id);
8740 mp->mb_mpls_table_id = 0;
8741 mp->mb_label = ntohl (local_label);
8742 mp->mb_address_length = address_length;
8745 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8747 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8752 /* Wait for a reply... */
8758 api_bier_table_add_del (vat_main_t * vam)
8760 unformat_input_t *i = vam->input;
8761 vl_api_bier_table_add_del_t *mp;
8763 u32 set = 0, sub_domain = 0, hdr_len = 3;
8764 mpls_label_t local_label = MPLS_LABEL_INVALID;
8767 /* Parse args required to build the message */
8768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8770 if (unformat (i, "sub-domain %d", &sub_domain))
8772 else if (unformat (i, "set %d", &set))
8774 else if (unformat (i, "label %d", &local_label))
8776 else if (unformat (i, "hdr-len %d", &hdr_len))
8778 else if (unformat (i, "add"))
8780 else if (unformat (i, "del"))
8784 clib_warning ("parse error '%U'", format_unformat_error, i);
8789 if (MPLS_LABEL_INVALID == local_label)
8791 errmsg ("missing label\n");
8795 /* Construct the API message */
8796 M (BIER_TABLE_ADD_DEL, mp);
8798 mp->bt_is_add = is_add;
8799 mp->bt_label = ntohl (local_label);
8800 mp->bt_tbl_id.bt_set = set;
8801 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8802 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8807 /* Wait for a reply... */
8814 api_bier_route_add_del (vat_main_t * vam)
8816 unformat_input_t *i = vam->input;
8817 vl_api_bier_route_add_del_t *mp;
8819 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8820 ip4_address_t v4_next_hop_address;
8821 ip6_address_t v6_next_hop_address;
8822 u8 next_hop_set = 0;
8823 u8 next_hop_proto_is_ip4 = 1;
8824 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8827 /* Parse args required to build the message */
8828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8830 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8832 next_hop_proto_is_ip4 = 1;
8835 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8837 next_hop_proto_is_ip4 = 0;
8840 if (unformat (i, "sub-domain %d", &sub_domain))
8842 else if (unformat (i, "set %d", &set))
8844 else if (unformat (i, "hdr-len %d", &hdr_len))
8846 else if (unformat (i, "bp %d", &bp))
8848 else if (unformat (i, "add"))
8850 else if (unformat (i, "del"))
8852 else if (unformat (i, "out-label %d", &next_hop_out_label))
8856 clib_warning ("parse error '%U'", format_unformat_error, i);
8861 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8863 errmsg ("next hop / label set\n");
8868 errmsg ("bit=position not set\n");
8872 /* Construct the API message */
8873 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8875 mp->br_is_add = is_add;
8876 mp->br_tbl_id.bt_set = set;
8877 mp->br_tbl_id.bt_sub_domain = sub_domain;
8878 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8879 mp->br_bp = ntohs (bp);
8881 mp->br_paths[0].n_labels = 1;
8882 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8883 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8885 if (next_hop_proto_is_ip4)
8887 clib_memcpy (mp->br_paths[0].next_hop,
8888 &v4_next_hop_address, sizeof (v4_next_hop_address));
8892 clib_memcpy (mp->br_paths[0].next_hop,
8893 &v6_next_hop_address, sizeof (v6_next_hop_address));
8899 /* Wait for a reply... */
8906 api_proxy_arp_add_del (vat_main_t * vam)
8908 unformat_input_t *i = vam->input;
8909 vl_api_proxy_arp_add_del_t *mp;
8912 ip4_address_t lo, hi;
8916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8918 if (unformat (i, "vrf %d", &vrf_id))
8920 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8921 unformat_ip4_address, &hi))
8923 else if (unformat (i, "del"))
8927 clib_warning ("parse error '%U'", format_unformat_error, i);
8934 errmsg ("address range not set");
8938 M (PROXY_ARP_ADD_DEL, mp);
8940 mp->vrf_id = ntohl (vrf_id);
8941 mp->is_add = is_add;
8942 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8943 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8951 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8953 unformat_input_t *i = vam->input;
8954 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8957 u8 sw_if_index_set = 0;
8960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8962 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8963 sw_if_index_set = 1;
8964 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8965 sw_if_index_set = 1;
8966 else if (unformat (i, "enable"))
8968 else if (unformat (i, "disable"))
8972 clib_warning ("parse error '%U'", format_unformat_error, i);
8977 if (sw_if_index_set == 0)
8979 errmsg ("missing interface name or sw_if_index");
8983 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8985 mp->sw_if_index = ntohl (sw_if_index);
8986 mp->enable_disable = enable;
8994 api_mpls_tunnel_add_del (vat_main_t * vam)
8996 unformat_input_t *i = vam->input;
8997 vl_api_mpls_tunnel_add_del_t *mp;
9001 u32 sw_if_index = ~0;
9002 u32 next_hop_sw_if_index = ~0;
9003 u32 next_hop_proto_is_ip4 = 1;
9005 u32 next_hop_table_id = 0;
9006 ip4_address_t v4_next_hop_address = {
9009 ip6_address_t v6_next_hop_address = { {0} };
9010 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9015 if (unformat (i, "add"))
9017 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9019 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9021 else if (unformat (i, "via %U",
9022 unformat_ip4_address, &v4_next_hop_address))
9024 next_hop_proto_is_ip4 = 1;
9026 else if (unformat (i, "via %U",
9027 unformat_ip6_address, &v6_next_hop_address))
9029 next_hop_proto_is_ip4 = 0;
9031 else if (unformat (i, "l2-only"))
9033 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9035 else if (unformat (i, "out-label %d", &next_hop_out_label))
9036 vec_add1 (labels, ntohl (next_hop_out_label));
9039 clib_warning ("parse error '%U'", format_unformat_error, i);
9044 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9046 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9047 mp->mt_sw_if_index = ntohl (sw_if_index);
9048 mp->mt_is_add = is_add;
9049 mp->mt_l2_only = l2_only;
9050 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9051 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9053 mp->mt_next_hop_n_out_labels = vec_len (labels);
9055 if (0 != mp->mt_next_hop_n_out_labels)
9057 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9058 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9062 if (next_hop_proto_is_ip4)
9064 clib_memcpy (mp->mt_next_hop,
9065 &v4_next_hop_address, sizeof (v4_next_hop_address));
9069 clib_memcpy (mp->mt_next_hop,
9070 &v6_next_hop_address, sizeof (v6_next_hop_address));
9079 api_sw_interface_set_unnumbered (vat_main_t * vam)
9081 unformat_input_t *i = vam->input;
9082 vl_api_sw_interface_set_unnumbered_t *mp;
9084 u32 unnum_sw_index = ~0;
9086 u8 sw_if_index_set = 0;
9089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9091 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9092 sw_if_index_set = 1;
9093 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9094 sw_if_index_set = 1;
9095 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9097 else if (unformat (i, "del"))
9101 clib_warning ("parse error '%U'", format_unformat_error, i);
9106 if (sw_if_index_set == 0)
9108 errmsg ("missing interface name or sw_if_index");
9112 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9114 mp->sw_if_index = ntohl (sw_if_index);
9115 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9116 mp->is_add = is_add;
9124 api_ip_neighbor_add_del (vat_main_t * vam)
9126 unformat_input_t *i = vam->input;
9127 vl_api_ip_neighbor_add_del_t *mp;
9129 u8 sw_if_index_set = 0;
9132 u8 is_no_fib_entry = 0;
9135 u8 v4_address_set = 0;
9136 u8 v6_address_set = 0;
9137 ip4_address_t v4address;
9138 ip6_address_t v6address;
9141 memset (mac_address, 0, sizeof (mac_address));
9143 /* Parse args required to build the message */
9144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9146 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9150 else if (unformat (i, "del"))
9153 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9154 sw_if_index_set = 1;
9155 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9156 sw_if_index_set = 1;
9157 else if (unformat (i, "is_static"))
9159 else if (unformat (i, "no-fib-entry"))
9160 is_no_fib_entry = 1;
9161 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9163 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9167 clib_warning ("parse error '%U'", format_unformat_error, i);
9172 if (sw_if_index_set == 0)
9174 errmsg ("missing interface name or sw_if_index");
9177 if (v4_address_set && v6_address_set)
9179 errmsg ("both v4 and v6 addresses set");
9182 if (!v4_address_set && !v6_address_set)
9184 errmsg ("no address set");
9188 /* Construct the API message */
9189 M (IP_NEIGHBOR_ADD_DEL, mp);
9191 mp->sw_if_index = ntohl (sw_if_index);
9192 mp->is_add = is_add;
9193 mp->is_static = is_static;
9194 mp->is_no_adj_fib = is_no_fib_entry;
9196 clib_memcpy (mp->mac_address, mac_address, 6);
9200 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9204 /* mp->is_ipv6 = 0; via memset in M macro above */
9205 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9211 /* Wait for a reply, return good/bad news */
9217 api_create_vlan_subif (vat_main_t * vam)
9219 unformat_input_t *i = vam->input;
9220 vl_api_create_vlan_subif_t *mp;
9222 u8 sw_if_index_set = 0;
9227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9229 if (unformat (i, "sw_if_index %d", &sw_if_index))
9230 sw_if_index_set = 1;
9232 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9233 sw_if_index_set = 1;
9234 else if (unformat (i, "vlan %d", &vlan_id))
9238 clib_warning ("parse error '%U'", format_unformat_error, i);
9243 if (sw_if_index_set == 0)
9245 errmsg ("missing interface name or sw_if_index");
9249 if (vlan_id_set == 0)
9251 errmsg ("missing vlan_id");
9254 M (CREATE_VLAN_SUBIF, mp);
9256 mp->sw_if_index = ntohl (sw_if_index);
9257 mp->vlan_id = ntohl (vlan_id);
9264 #define foreach_create_subif_bit \
9271 _(outer_vlan_id_any) \
9272 _(inner_vlan_id_any)
9275 api_create_subif (vat_main_t * vam)
9277 unformat_input_t *i = vam->input;
9278 vl_api_create_subif_t *mp;
9280 u8 sw_if_index_set = 0;
9287 u32 exact_match = 0;
9288 u32 default_sub = 0;
9289 u32 outer_vlan_id_any = 0;
9290 u32 inner_vlan_id_any = 0;
9292 u16 outer_vlan_id = 0;
9293 u16 inner_vlan_id = 0;
9296 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9298 if (unformat (i, "sw_if_index %d", &sw_if_index))
9299 sw_if_index_set = 1;
9301 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9302 sw_if_index_set = 1;
9303 else if (unformat (i, "sub_id %d", &sub_id))
9305 else if (unformat (i, "outer_vlan_id %d", &tmp))
9306 outer_vlan_id = tmp;
9307 else if (unformat (i, "inner_vlan_id %d", &tmp))
9308 inner_vlan_id = tmp;
9310 #define _(a) else if (unformat (i, #a)) a = 1 ;
9311 foreach_create_subif_bit
9315 clib_warning ("parse error '%U'", format_unformat_error, i);
9320 if (sw_if_index_set == 0)
9322 errmsg ("missing interface name or sw_if_index");
9326 if (sub_id_set == 0)
9328 errmsg ("missing sub_id");
9331 M (CREATE_SUBIF, mp);
9333 mp->sw_if_index = ntohl (sw_if_index);
9334 mp->sub_id = ntohl (sub_id);
9336 #define _(a) mp->a = a;
9337 foreach_create_subif_bit;
9340 mp->outer_vlan_id = ntohs (outer_vlan_id);
9341 mp->inner_vlan_id = ntohs (inner_vlan_id);
9349 api_oam_add_del (vat_main_t * vam)
9351 unformat_input_t *i = vam->input;
9352 vl_api_oam_add_del_t *mp;
9355 ip4_address_t src, dst;
9360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9362 if (unformat (i, "vrf %d", &vrf_id))
9364 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9366 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9368 else if (unformat (i, "del"))
9372 clib_warning ("parse error '%U'", format_unformat_error, i);
9379 errmsg ("missing src addr");
9385 errmsg ("missing dst addr");
9389 M (OAM_ADD_DEL, mp);
9391 mp->vrf_id = ntohl (vrf_id);
9392 mp->is_add = is_add;
9393 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9394 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9402 api_reset_fib (vat_main_t * vam)
9404 unformat_input_t *i = vam->input;
9405 vl_api_reset_fib_t *mp;
9411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9413 if (unformat (i, "vrf %d", &vrf_id))
9415 else if (unformat (i, "ipv6"))
9419 clib_warning ("parse error '%U'", format_unformat_error, i);
9424 if (vrf_id_set == 0)
9426 errmsg ("missing vrf id");
9432 mp->vrf_id = ntohl (vrf_id);
9433 mp->is_ipv6 = is_ipv6;
9441 api_dhcp_proxy_config (vat_main_t * vam)
9443 unformat_input_t *i = vam->input;
9444 vl_api_dhcp_proxy_config_t *mp;
9446 u32 server_vrf_id = 0;
9448 u8 v4_address_set = 0;
9449 u8 v6_address_set = 0;
9450 ip4_address_t v4address;
9451 ip6_address_t v6address;
9452 u8 v4_src_address_set = 0;
9453 u8 v6_src_address_set = 0;
9454 ip4_address_t v4srcaddress;
9455 ip6_address_t v6srcaddress;
9458 /* Parse args required to build the message */
9459 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9461 if (unformat (i, "del"))
9463 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9465 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9467 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9469 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9471 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9472 v4_src_address_set = 1;
9473 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9474 v6_src_address_set = 1;
9479 if (v4_address_set && v6_address_set)
9481 errmsg ("both v4 and v6 server addresses set");
9484 if (!v4_address_set && !v6_address_set)
9486 errmsg ("no server addresses set");
9490 if (v4_src_address_set && v6_src_address_set)
9492 errmsg ("both v4 and v6 src addresses set");
9495 if (!v4_src_address_set && !v6_src_address_set)
9497 errmsg ("no src addresses set");
9501 if (!(v4_src_address_set && v4_address_set) &&
9502 !(v6_src_address_set && v6_address_set))
9504 errmsg ("no matching server and src addresses set");
9508 /* Construct the API message */
9509 M (DHCP_PROXY_CONFIG, mp);
9511 mp->is_add = is_add;
9512 mp->rx_vrf_id = ntohl (rx_vrf_id);
9513 mp->server_vrf_id = ntohl (server_vrf_id);
9517 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9518 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9522 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9523 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9529 /* Wait for a reply, return good/bad news */
9534 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9535 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9538 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9540 vat_main_t *vam = &vat_main;
9541 u32 i, count = mp->count;
9542 vl_api_dhcp_server_t *s;
9546 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9547 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9548 ntohl (mp->rx_vrf_id),
9549 format_ip6_address, mp->dhcp_src_address,
9550 mp->vss_type, mp->vss_vpn_ascii_id,
9551 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9554 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9555 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9556 ntohl (mp->rx_vrf_id),
9557 format_ip4_address, mp->dhcp_src_address,
9558 mp->vss_type, mp->vss_vpn_ascii_id,
9559 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9561 for (i = 0; i < count; i++)
9563 s = &mp->servers[i];
9567 " Server Table-ID %d, Server Address %U",
9568 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9571 " Server Table-ID %d, Server Address %U",
9572 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9576 static void vl_api_dhcp_proxy_details_t_handler_json
9577 (vl_api_dhcp_proxy_details_t * mp)
9579 vat_main_t *vam = &vat_main;
9580 vat_json_node_t *node = NULL;
9581 u32 i, count = mp->count;
9583 struct in6_addr ip6;
9584 vl_api_dhcp_server_t *s;
9586 if (VAT_JSON_ARRAY != vam->json_tree.type)
9588 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9589 vat_json_init_array (&vam->json_tree);
9591 node = vat_json_array_add (&vam->json_tree);
9593 vat_json_init_object (node);
9594 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9595 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9596 sizeof (mp->vss_type));
9597 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9598 mp->vss_vpn_ascii_id);
9599 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9600 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9604 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9605 vat_json_object_add_ip6 (node, "src_address", ip6);
9609 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9610 vat_json_object_add_ip4 (node, "src_address", ip4);
9613 for (i = 0; i < count; i++)
9615 s = &mp->servers[i];
9617 vat_json_object_add_uint (node, "server-table-id",
9618 ntohl (s->server_vrf_id));
9622 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9623 vat_json_object_add_ip4 (node, "src_address", ip4);
9627 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9628 vat_json_object_add_ip6 (node, "server_address", ip6);
9634 api_dhcp_proxy_dump (vat_main_t * vam)
9636 unformat_input_t *i = vam->input;
9637 vl_api_control_ping_t *mp_ping;
9638 vl_api_dhcp_proxy_dump_t *mp;
9642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9644 if (unformat (i, "ipv6"))
9648 clib_warning ("parse error '%U'", format_unformat_error, i);
9653 M (DHCP_PROXY_DUMP, mp);
9655 mp->is_ip6 = is_ipv6;
9658 /* Use a control ping for synchronization */
9659 MPING (CONTROL_PING, mp_ping);
9667 api_dhcp_proxy_set_vss (vat_main_t * vam)
9669 unformat_input_t *i = vam->input;
9670 vl_api_dhcp_proxy_set_vss_t *mp;
9674 u8 vss_type = VSS_TYPE_DEFAULT;
9675 u8 *vpn_ascii_id = 0;
9680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9682 if (unformat (i, "tbl_id %d", &tbl_id))
9684 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9685 vss_type = VSS_TYPE_ASCII;
9686 else if (unformat (i, "fib_id %d", &fib_id))
9687 vss_type = VSS_TYPE_VPN_ID;
9688 else if (unformat (i, "oui %d", &oui))
9689 vss_type = VSS_TYPE_VPN_ID;
9690 else if (unformat (i, "ipv6"))
9692 else if (unformat (i, "del"))
9700 errmsg ("missing tbl_id ");
9701 vec_free (vpn_ascii_id);
9705 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9707 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9708 vec_free (vpn_ascii_id);
9712 M (DHCP_PROXY_SET_VSS, mp);
9713 mp->tbl_id = ntohl (tbl_id);
9714 mp->vss_type = vss_type;
9717 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9718 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9720 mp->vpn_index = ntohl (fib_id);
9721 mp->oui = ntohl (oui);
9722 mp->is_ipv6 = is_ipv6;
9723 mp->is_add = is_add;
9728 vec_free (vpn_ascii_id);
9733 api_dhcp_client_config (vat_main_t * vam)
9735 unformat_input_t *i = vam->input;
9736 vl_api_dhcp_client_config_t *mp;
9738 u8 sw_if_index_set = 0;
9741 u8 disable_event = 0;
9744 /* Parse args required to build the message */
9745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9747 if (unformat (i, "del"))
9750 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9751 sw_if_index_set = 1;
9752 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9753 sw_if_index_set = 1;
9754 else if (unformat (i, "hostname %s", &hostname))
9756 else if (unformat (i, "disable_event"))
9762 if (sw_if_index_set == 0)
9764 errmsg ("missing interface name or sw_if_index");
9768 if (vec_len (hostname) > 63)
9770 errmsg ("hostname too long");
9772 vec_add1 (hostname, 0);
9774 /* Construct the API message */
9775 M (DHCP_CLIENT_CONFIG, mp);
9777 mp->sw_if_index = htonl (sw_if_index);
9778 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9779 vec_free (hostname);
9780 mp->is_add = is_add;
9781 mp->want_dhcp_event = disable_event ? 0 : 1;
9782 mp->pid = htonl (getpid ());
9787 /* Wait for a reply, return good/bad news */
9793 api_set_ip_flow_hash (vat_main_t * vam)
9795 unformat_input_t *i = vam->input;
9796 vl_api_set_ip_flow_hash_t *mp;
9808 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9810 if (unformat (i, "vrf %d", &vrf_id))
9812 else if (unformat (i, "ipv6"))
9814 else if (unformat (i, "src"))
9816 else if (unformat (i, "dst"))
9818 else if (unformat (i, "sport"))
9820 else if (unformat (i, "dport"))
9822 else if (unformat (i, "proto"))
9824 else if (unformat (i, "reverse"))
9829 clib_warning ("parse error '%U'", format_unformat_error, i);
9834 if (vrf_id_set == 0)
9836 errmsg ("missing vrf id");
9840 M (SET_IP_FLOW_HASH, mp);
9846 mp->reverse = reverse;
9847 mp->vrf_id = ntohl (vrf_id);
9848 mp->is_ipv6 = is_ipv6;
9856 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9858 unformat_input_t *i = vam->input;
9859 vl_api_sw_interface_ip6_enable_disable_t *mp;
9861 u8 sw_if_index_set = 0;
9865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9867 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9868 sw_if_index_set = 1;
9869 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9870 sw_if_index_set = 1;
9871 else if (unformat (i, "enable"))
9873 else if (unformat (i, "disable"))
9877 clib_warning ("parse error '%U'", format_unformat_error, i);
9882 if (sw_if_index_set == 0)
9884 errmsg ("missing interface name or sw_if_index");
9888 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9890 mp->sw_if_index = ntohl (sw_if_index);
9891 mp->enable = enable;
9899 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9901 unformat_input_t *i = vam->input;
9902 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9904 u8 sw_if_index_set = 0;
9905 u8 v6_address_set = 0;
9906 ip6_address_t v6address;
9909 /* Parse args required to build the message */
9910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9913 sw_if_index_set = 1;
9914 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9915 sw_if_index_set = 1;
9916 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9922 if (sw_if_index_set == 0)
9924 errmsg ("missing interface name or sw_if_index");
9927 if (!v6_address_set)
9929 errmsg ("no address set");
9933 /* Construct the API message */
9934 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9936 mp->sw_if_index = ntohl (sw_if_index);
9937 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9942 /* Wait for a reply, return good/bad news */
9948 api_ip6nd_proxy_add_del (vat_main_t * vam)
9950 unformat_input_t *i = vam->input;
9951 vl_api_ip6nd_proxy_add_del_t *mp;
9952 u32 sw_if_index = ~0;
9953 u8 v6_address_set = 0;
9954 ip6_address_t v6address;
9958 /* Parse args required to build the message */
9959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9961 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9963 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9965 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9967 if (unformat (i, "del"))
9971 clib_warning ("parse error '%U'", format_unformat_error, i);
9976 if (sw_if_index == ~0)
9978 errmsg ("missing interface name or sw_if_index");
9981 if (!v6_address_set)
9983 errmsg ("no address set");
9987 /* Construct the API message */
9988 M (IP6ND_PROXY_ADD_DEL, mp);
9990 mp->is_del = is_del;
9991 mp->sw_if_index = ntohl (sw_if_index);
9992 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9997 /* Wait for a reply, return good/bad news */
10003 api_ip6nd_proxy_dump (vat_main_t * vam)
10005 vl_api_ip6nd_proxy_dump_t *mp;
10006 vl_api_control_ping_t *mp_ping;
10009 M (IP6ND_PROXY_DUMP, mp);
10013 /* Use a control ping for synchronization */
10014 MPING (CONTROL_PING, mp_ping);
10021 static void vl_api_ip6nd_proxy_details_t_handler
10022 (vl_api_ip6nd_proxy_details_t * mp)
10024 vat_main_t *vam = &vat_main;
10026 print (vam->ofp, "host %U sw_if_index %d",
10027 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10030 static void vl_api_ip6nd_proxy_details_t_handler_json
10031 (vl_api_ip6nd_proxy_details_t * mp)
10033 vat_main_t *vam = &vat_main;
10034 struct in6_addr ip6;
10035 vat_json_node_t *node = NULL;
10037 if (VAT_JSON_ARRAY != vam->json_tree.type)
10039 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10040 vat_json_init_array (&vam->json_tree);
10042 node = vat_json_array_add (&vam->json_tree);
10044 vat_json_init_object (node);
10045 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10047 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10048 vat_json_object_add_ip6 (node, "host", ip6);
10052 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10054 unformat_input_t *i = vam->input;
10055 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10057 u8 sw_if_index_set = 0;
10058 u32 address_length = 0;
10059 u8 v6_address_set = 0;
10060 ip6_address_t v6address;
10061 u8 use_default = 0;
10062 u8 no_advertise = 0;
10064 u8 no_autoconfig = 0;
10067 u32 val_lifetime = 0;
10068 u32 pref_lifetime = 0;
10071 /* Parse args required to build the message */
10072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10074 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10075 sw_if_index_set = 1;
10076 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10077 sw_if_index_set = 1;
10078 else if (unformat (i, "%U/%d",
10079 unformat_ip6_address, &v6address, &address_length))
10080 v6_address_set = 1;
10081 else if (unformat (i, "val_life %d", &val_lifetime))
10083 else if (unformat (i, "pref_life %d", &pref_lifetime))
10085 else if (unformat (i, "def"))
10087 else if (unformat (i, "noadv"))
10089 else if (unformat (i, "offl"))
10091 else if (unformat (i, "noauto"))
10093 else if (unformat (i, "nolink"))
10095 else if (unformat (i, "isno"))
10099 clib_warning ("parse error '%U'", format_unformat_error, i);
10104 if (sw_if_index_set == 0)
10106 errmsg ("missing interface name or sw_if_index");
10109 if (!v6_address_set)
10111 errmsg ("no address set");
10115 /* Construct the API message */
10116 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10118 mp->sw_if_index = ntohl (sw_if_index);
10119 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10120 mp->address_length = address_length;
10121 mp->use_default = use_default;
10122 mp->no_advertise = no_advertise;
10123 mp->off_link = off_link;
10124 mp->no_autoconfig = no_autoconfig;
10125 mp->no_onlink = no_onlink;
10127 mp->val_lifetime = ntohl (val_lifetime);
10128 mp->pref_lifetime = ntohl (pref_lifetime);
10133 /* Wait for a reply, return good/bad news */
10139 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10141 unformat_input_t *i = vam->input;
10142 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10144 u8 sw_if_index_set = 0;
10149 u8 send_unicast = 0;
10152 u8 default_router = 0;
10153 u32 max_interval = 0;
10154 u32 min_interval = 0;
10156 u32 initial_count = 0;
10157 u32 initial_interval = 0;
10161 /* Parse args required to build the message */
10162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10164 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10165 sw_if_index_set = 1;
10166 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10167 sw_if_index_set = 1;
10168 else if (unformat (i, "maxint %d", &max_interval))
10170 else if (unformat (i, "minint %d", &min_interval))
10172 else if (unformat (i, "life %d", &lifetime))
10174 else if (unformat (i, "count %d", &initial_count))
10176 else if (unformat (i, "interval %d", &initial_interval))
10178 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10180 else if (unformat (i, "managed"))
10182 else if (unformat (i, "other"))
10184 else if (unformat (i, "ll"))
10186 else if (unformat (i, "send"))
10188 else if (unformat (i, "cease"))
10190 else if (unformat (i, "isno"))
10192 else if (unformat (i, "def"))
10193 default_router = 1;
10196 clib_warning ("parse error '%U'", format_unformat_error, i);
10201 if (sw_if_index_set == 0)
10203 errmsg ("missing interface name or sw_if_index");
10207 /* Construct the API message */
10208 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10210 mp->sw_if_index = ntohl (sw_if_index);
10211 mp->max_interval = ntohl (max_interval);
10212 mp->min_interval = ntohl (min_interval);
10213 mp->lifetime = ntohl (lifetime);
10214 mp->initial_count = ntohl (initial_count);
10215 mp->initial_interval = ntohl (initial_interval);
10216 mp->suppress = suppress;
10217 mp->managed = managed;
10219 mp->ll_option = ll_option;
10220 mp->send_unicast = send_unicast;
10223 mp->default_router = default_router;
10228 /* Wait for a reply, return good/bad news */
10234 api_set_arp_neighbor_limit (vat_main_t * vam)
10236 unformat_input_t *i = vam->input;
10237 vl_api_set_arp_neighbor_limit_t *mp;
10243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10245 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10247 else if (unformat (i, "ipv6"))
10251 clib_warning ("parse error '%U'", format_unformat_error, i);
10256 if (limit_set == 0)
10258 errmsg ("missing limit value");
10262 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10264 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10265 mp->is_ipv6 = is_ipv6;
10273 api_l2_patch_add_del (vat_main_t * vam)
10275 unformat_input_t *i = vam->input;
10276 vl_api_l2_patch_add_del_t *mp;
10277 u32 rx_sw_if_index;
10278 u8 rx_sw_if_index_set = 0;
10279 u32 tx_sw_if_index;
10280 u8 tx_sw_if_index_set = 0;
10284 /* Parse args required to build the message */
10285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10287 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10288 rx_sw_if_index_set = 1;
10289 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10290 tx_sw_if_index_set = 1;
10291 else if (unformat (i, "rx"))
10293 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10295 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10297 rx_sw_if_index_set = 1;
10302 else if (unformat (i, "tx"))
10304 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10306 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10308 tx_sw_if_index_set = 1;
10313 else if (unformat (i, "del"))
10319 if (rx_sw_if_index_set == 0)
10321 errmsg ("missing rx interface name or rx_sw_if_index");
10325 if (tx_sw_if_index_set == 0)
10327 errmsg ("missing tx interface name or tx_sw_if_index");
10331 M (L2_PATCH_ADD_DEL, mp);
10333 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10334 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10335 mp->is_add = is_add;
10343 u8 localsid_addr[16];
10352 api_sr_localsid_add_del (vat_main_t * vam)
10354 unformat_input_t *i = vam->input;
10355 vl_api_sr_localsid_add_del_t *mp;
10358 ip6_address_t localsid;
10362 u32 fib_table = ~(u32) 0;
10363 ip6_address_t next_hop;
10365 bool nexthop_set = 0;
10369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10371 if (unformat (i, "del"))
10373 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10374 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10376 else if (unformat (i, "behavior %u", &behavior));
10377 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10378 else if (unformat (i, "fib-table %u", &fib_table));
10379 else if (unformat (i, "end.psp %u", &behavior));
10384 M (SR_LOCALSID_ADD_DEL, mp);
10386 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10388 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10389 mp->behavior = behavior;
10390 mp->sw_if_index = ntohl (sw_if_index);
10391 mp->fib_table = ntohl (fib_table);
10392 mp->end_psp = end_psp;
10393 mp->is_del = is_del;
10401 api_ioam_enable (vat_main_t * vam)
10403 unformat_input_t *input = vam->input;
10404 vl_api_ioam_enable_t *mp;
10406 int has_trace_option = 0;
10407 int has_pot_option = 0;
10408 int has_seqno_option = 0;
10409 int has_analyse_option = 0;
10412 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10414 if (unformat (input, "trace"))
10415 has_trace_option = 1;
10416 else if (unformat (input, "pot"))
10417 has_pot_option = 1;
10418 else if (unformat (input, "seqno"))
10419 has_seqno_option = 1;
10420 else if (unformat (input, "analyse"))
10421 has_analyse_option = 1;
10425 M (IOAM_ENABLE, mp);
10426 mp->id = htons (id);
10427 mp->seqno = has_seqno_option;
10428 mp->analyse = has_analyse_option;
10429 mp->pot_enable = has_pot_option;
10430 mp->trace_enable = has_trace_option;
10439 api_ioam_disable (vat_main_t * vam)
10441 vl_api_ioam_disable_t *mp;
10444 M (IOAM_DISABLE, mp);
10450 #define foreach_tcp_proto_field \
10454 #define foreach_udp_proto_field \
10458 #define foreach_ip4_proto_field \
10470 u16 src_port, dst_port;
10473 #if VPP_API_TEST_BUILTIN == 0
10475 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10477 u8 **maskp = va_arg (*args, u8 **);
10479 u8 found_something = 0;
10482 #define _(a) u8 a=0;
10483 foreach_tcp_proto_field;
10486 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10489 #define _(a) else if (unformat (input, #a)) a=1;
10490 foreach_tcp_proto_field
10496 #define _(a) found_something += a;
10497 foreach_tcp_proto_field;
10500 if (found_something == 0)
10503 vec_validate (mask, sizeof (*tcp) - 1);
10505 tcp = (tcp_header_t *) mask;
10507 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10508 foreach_tcp_proto_field;
10516 unformat_udp_mask (unformat_input_t * input, va_list * args)
10518 u8 **maskp = va_arg (*args, u8 **);
10520 u8 found_something = 0;
10523 #define _(a) u8 a=0;
10524 foreach_udp_proto_field;
10527 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10530 #define _(a) else if (unformat (input, #a)) a=1;
10531 foreach_udp_proto_field
10537 #define _(a) found_something += a;
10538 foreach_udp_proto_field;
10541 if (found_something == 0)
10544 vec_validate (mask, sizeof (*udp) - 1);
10546 udp = (udp_header_t *) mask;
10548 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10549 foreach_udp_proto_field;
10557 unformat_l4_mask (unformat_input_t * input, va_list * args)
10559 u8 **maskp = va_arg (*args, u8 **);
10560 u16 src_port = 0, dst_port = 0;
10561 tcpudp_header_t *tcpudp;
10563 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10565 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10567 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10569 else if (unformat (input, "src_port"))
10571 else if (unformat (input, "dst_port"))
10577 if (!src_port && !dst_port)
10581 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10583 tcpudp = (tcpudp_header_t *) mask;
10584 tcpudp->src_port = src_port;
10585 tcpudp->dst_port = dst_port;
10593 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10595 u8 **maskp = va_arg (*args, u8 **);
10597 u8 found_something = 0;
10600 #define _(a) u8 a=0;
10601 foreach_ip4_proto_field;
10607 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10609 if (unformat (input, "version"))
10611 else if (unformat (input, "hdr_length"))
10613 else if (unformat (input, "src"))
10615 else if (unformat (input, "dst"))
10617 else if (unformat (input, "proto"))
10620 #define _(a) else if (unformat (input, #a)) a=1;
10621 foreach_ip4_proto_field
10627 #define _(a) found_something += a;
10628 foreach_ip4_proto_field;
10631 if (found_something == 0)
10634 vec_validate (mask, sizeof (*ip) - 1);
10636 ip = (ip4_header_t *) mask;
10638 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10639 foreach_ip4_proto_field;
10642 ip->ip_version_and_header_length = 0;
10645 ip->ip_version_and_header_length |= 0xF0;
10648 ip->ip_version_and_header_length |= 0x0F;
10654 #define foreach_ip6_proto_field \
10657 _(payload_length) \
10662 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10664 u8 **maskp = va_arg (*args, u8 **);
10666 u8 found_something = 0;
10668 u32 ip_version_traffic_class_and_flow_label;
10670 #define _(a) u8 a=0;
10671 foreach_ip6_proto_field;
10674 u8 traffic_class = 0;
10677 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10679 if (unformat (input, "version"))
10681 else if (unformat (input, "traffic-class"))
10683 else if (unformat (input, "flow-label"))
10685 else if (unformat (input, "src"))
10687 else if (unformat (input, "dst"))
10689 else if (unformat (input, "proto"))
10692 #define _(a) else if (unformat (input, #a)) a=1;
10693 foreach_ip6_proto_field
10699 #define _(a) found_something += a;
10700 foreach_ip6_proto_field;
10703 if (found_something == 0)
10706 vec_validate (mask, sizeof (*ip) - 1);
10708 ip = (ip6_header_t *) mask;
10710 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10711 foreach_ip6_proto_field;
10714 ip_version_traffic_class_and_flow_label = 0;
10717 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10720 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10723 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10725 ip->ip_version_traffic_class_and_flow_label =
10726 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10733 unformat_l3_mask (unformat_input_t * input, va_list * args)
10735 u8 **maskp = va_arg (*args, u8 **);
10737 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10739 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10741 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10750 unformat_l2_mask (unformat_input_t * input, va_list * args)
10752 u8 **maskp = va_arg (*args, u8 **);
10759 u8 ignore_tag1 = 0;
10760 u8 ignore_tag2 = 0;
10767 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10769 if (unformat (input, "src"))
10771 else if (unformat (input, "dst"))
10773 else if (unformat (input, "proto"))
10775 else if (unformat (input, "tag1"))
10777 else if (unformat (input, "tag2"))
10779 else if (unformat (input, "ignore-tag1"))
10781 else if (unformat (input, "ignore-tag2"))
10783 else if (unformat (input, "cos1"))
10785 else if (unformat (input, "cos2"))
10787 else if (unformat (input, "dot1q"))
10789 else if (unformat (input, "dot1ad"))
10794 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10795 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10798 if (tag1 || ignore_tag1 || cos1 || dot1q)
10800 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10803 vec_validate (mask, len - 1);
10806 memset (mask, 0xff, 6);
10809 memset (mask + 6, 0xff, 6);
10811 if (tag2 || dot1ad)
10813 /* inner vlan tag */
10822 mask[21] = mask[20] = 0xff;
10843 mask[16] = mask[17] = 0xff;
10853 mask[12] = mask[13] = 0xff;
10860 unformat_classify_mask (unformat_input_t * input, va_list * args)
10862 u8 **maskp = va_arg (*args, u8 **);
10863 u32 *skipp = va_arg (*args, u32 *);
10864 u32 *matchp = va_arg (*args, u32 *);
10872 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10874 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10876 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10878 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10880 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10894 if (mask || l2 || l3 || l4)
10896 if (l2 || l3 || l4)
10898 /* "With a free Ethernet header in every package" */
10900 vec_validate (l2, 13);
10904 vec_append (mask, l3);
10909 vec_append (mask, l4);
10914 /* Scan forward looking for the first significant mask octet */
10915 for (i = 0; i < vec_len (mask); i++)
10919 /* compute (skip, match) params */
10920 *skipp = i / sizeof (u32x4);
10921 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10923 /* Pad mask to an even multiple of the vector size */
10924 while (vec_len (mask) % sizeof (u32x4))
10925 vec_add1 (mask, 0);
10927 match = vec_len (mask) / sizeof (u32x4);
10929 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10931 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10932 if (*tmp || *(tmp + 1))
10937 clib_warning ("BUG: match 0");
10939 _vec_len (mask) = match * sizeof (u32x4);
10949 #endif /* VPP_API_TEST_BUILTIN */
10951 #define foreach_l2_next \
10953 _(ethernet, ETHERNET_INPUT) \
10954 _(ip4, IP4_INPUT) \
10958 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10960 u32 *miss_next_indexp = va_arg (*args, u32 *);
10961 u32 next_index = 0;
10965 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10969 if (unformat (input, "%d", &tmp))
10978 *miss_next_indexp = next_index;
10982 #define foreach_ip_next \
10985 _(rewrite, REWRITE)
10988 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10990 u32 *miss_next_indexp = va_arg (*args, u32 *);
10991 u32 next_index = 0;
10995 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10999 if (unformat (input, "%d", &tmp))
11008 *miss_next_indexp = next_index;
11012 #define foreach_acl_next \
11016 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11018 u32 *miss_next_indexp = va_arg (*args, u32 *);
11019 u32 next_index = 0;
11023 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11027 if (unformat (input, "permit"))
11032 else if (unformat (input, "%d", &tmp))
11041 *miss_next_indexp = next_index;
11046 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11048 u32 *r = va_arg (*args, u32 *);
11050 if (unformat (input, "conform-color"))
11051 *r = POLICE_CONFORM;
11052 else if (unformat (input, "exceed-color"))
11053 *r = POLICE_EXCEED;
11061 api_classify_add_del_table (vat_main_t * vam)
11063 unformat_input_t *i = vam->input;
11064 vl_api_classify_add_del_table_t *mp;
11071 u32 table_index = ~0;
11072 u32 next_table_index = ~0;
11073 u32 miss_next_index = ~0;
11074 u32 memory_size = 32 << 20;
11076 u32 current_data_flag = 0;
11077 int current_data_offset = 0;
11080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11082 if (unformat (i, "del"))
11084 else if (unformat (i, "del-chain"))
11089 else if (unformat (i, "buckets %d", &nbuckets))
11091 else if (unformat (i, "memory_size %d", &memory_size))
11093 else if (unformat (i, "skip %d", &skip))
11095 else if (unformat (i, "match %d", &match))
11097 else if (unformat (i, "table %d", &table_index))
11099 else if (unformat (i, "mask %U", unformat_classify_mask,
11100 &mask, &skip, &match))
11102 else if (unformat (i, "next-table %d", &next_table_index))
11104 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11107 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11110 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11113 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11115 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11121 if (is_add && mask == 0)
11123 errmsg ("Mask required");
11127 if (is_add && skip == ~0)
11129 errmsg ("skip count required");
11133 if (is_add && match == ~0)
11135 errmsg ("match count required");
11139 if (!is_add && table_index == ~0)
11141 errmsg ("table index required for delete");
11145 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11147 mp->is_add = is_add;
11148 mp->del_chain = del_chain;
11149 mp->table_index = ntohl (table_index);
11150 mp->nbuckets = ntohl (nbuckets);
11151 mp->memory_size = ntohl (memory_size);
11152 mp->skip_n_vectors = ntohl (skip);
11153 mp->match_n_vectors = ntohl (match);
11154 mp->next_table_index = ntohl (next_table_index);
11155 mp->miss_next_index = ntohl (miss_next_index);
11156 mp->current_data_flag = ntohl (current_data_flag);
11157 mp->current_data_offset = ntohl (current_data_offset);
11158 clib_memcpy (mp->mask, mask, vec_len (mask));
11167 #if VPP_API_TEST_BUILTIN == 0
11169 unformat_l4_match (unformat_input_t * input, va_list * args)
11171 u8 **matchp = va_arg (*args, u8 **);
11173 u8 *proto_header = 0;
11179 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11181 if (unformat (input, "src_port %d", &src_port))
11183 else if (unformat (input, "dst_port %d", &dst_port))
11189 h.src_port = clib_host_to_net_u16 (src_port);
11190 h.dst_port = clib_host_to_net_u16 (dst_port);
11191 vec_validate (proto_header, sizeof (h) - 1);
11192 memcpy (proto_header, &h, sizeof (h));
11194 *matchp = proto_header;
11200 unformat_ip4_match (unformat_input_t * input, va_list * args)
11202 u8 **matchp = va_arg (*args, u8 **);
11207 int hdr_length = 0;
11208 u32 hdr_length_val;
11209 int src = 0, dst = 0;
11210 ip4_address_t src_val, dst_val;
11217 int fragment_id = 0;
11218 u32 fragment_id_val;
11224 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11226 if (unformat (input, "version %d", &version_val))
11228 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11230 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11232 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11234 else if (unformat (input, "proto %d", &proto_val))
11236 else if (unformat (input, "tos %d", &tos_val))
11238 else if (unformat (input, "length %d", &length_val))
11240 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11242 else if (unformat (input, "ttl %d", &ttl_val))
11244 else if (unformat (input, "checksum %d", &checksum_val))
11250 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11251 + ttl + checksum == 0)
11255 * Aligned because we use the real comparison functions
11257 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11259 ip = (ip4_header_t *) match;
11261 /* These are realistically matched in practice */
11263 ip->src_address.as_u32 = src_val.as_u32;
11266 ip->dst_address.as_u32 = dst_val.as_u32;
11269 ip->protocol = proto_val;
11272 /* These are not, but they're included for completeness */
11274 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11277 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11283 ip->length = clib_host_to_net_u16 (length_val);
11289 ip->checksum = clib_host_to_net_u16 (checksum_val);
11296 unformat_ip6_match (unformat_input_t * input, va_list * args)
11298 u8 **matchp = va_arg (*args, u8 **);
11303 u8 traffic_class = 0;
11304 u32 traffic_class_val = 0;
11307 int src = 0, dst = 0;
11308 ip6_address_t src_val, dst_val;
11311 int payload_length = 0;
11312 u32 payload_length_val;
11315 u32 ip_version_traffic_class_and_flow_label;
11317 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11319 if (unformat (input, "version %d", &version_val))
11321 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11323 else if (unformat (input, "flow_label %d", &flow_label_val))
11325 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11327 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11329 else if (unformat (input, "proto %d", &proto_val))
11331 else if (unformat (input, "payload_length %d", &payload_length_val))
11332 payload_length = 1;
11333 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11339 if (version + traffic_class + flow_label + src + dst + proto +
11340 payload_length + hop_limit == 0)
11344 * Aligned because we use the real comparison functions
11346 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11348 ip = (ip6_header_t *) match;
11351 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11354 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11357 ip->protocol = proto_val;
11359 ip_version_traffic_class_and_flow_label = 0;
11362 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11365 ip_version_traffic_class_and_flow_label |=
11366 (traffic_class_val & 0xFF) << 20;
11369 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11371 ip->ip_version_traffic_class_and_flow_label =
11372 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11374 if (payload_length)
11375 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11378 ip->hop_limit = hop_limit_val;
11385 unformat_l3_match (unformat_input_t * input, va_list * args)
11387 u8 **matchp = va_arg (*args, u8 **);
11389 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11391 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11393 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11402 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11404 u8 *tagp = va_arg (*args, u8 *);
11407 if (unformat (input, "%d", &tag))
11409 tagp[0] = (tag >> 8) & 0x0F;
11410 tagp[1] = tag & 0xFF;
11418 unformat_l2_match (unformat_input_t * input, va_list * args)
11420 u8 **matchp = va_arg (*args, u8 **);
11433 u8 ignore_tag1 = 0;
11434 u8 ignore_tag2 = 0;
11440 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11442 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11445 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11447 else if (unformat (input, "proto %U",
11448 unformat_ethernet_type_host_byte_order, &proto_val))
11450 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11452 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11454 else if (unformat (input, "ignore-tag1"))
11456 else if (unformat (input, "ignore-tag2"))
11458 else if (unformat (input, "cos1 %d", &cos1_val))
11460 else if (unformat (input, "cos2 %d", &cos2_val))
11465 if ((src + dst + proto + tag1 + tag2 +
11466 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11469 if (tag1 || ignore_tag1 || cos1)
11471 if (tag2 || ignore_tag2 || cos2)
11474 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11477 clib_memcpy (match, dst_val, 6);
11480 clib_memcpy (match + 6, src_val, 6);
11484 /* inner vlan tag */
11485 match[19] = tag2_val[1];
11486 match[18] = tag2_val[0];
11488 match[18] |= (cos2_val & 0x7) << 5;
11491 match[21] = proto_val & 0xff;
11492 match[20] = proto_val >> 8;
11496 match[15] = tag1_val[1];
11497 match[14] = tag1_val[0];
11500 match[14] |= (cos1_val & 0x7) << 5;
11506 match[15] = tag1_val[1];
11507 match[14] = tag1_val[0];
11510 match[17] = proto_val & 0xff;
11511 match[16] = proto_val >> 8;
11514 match[14] |= (cos1_val & 0x7) << 5;
11520 match[18] |= (cos2_val & 0x7) << 5;
11522 match[14] |= (cos1_val & 0x7) << 5;
11525 match[13] = proto_val & 0xff;
11526 match[12] = proto_val >> 8;
11535 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11537 u8 **matchp = va_arg (*args, u8 **);
11538 u32 skip_n_vectors = va_arg (*args, u32);
11539 u32 match_n_vectors = va_arg (*args, u32);
11546 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11548 if (unformat (input, "hex %U", unformat_hex_string, &match))
11550 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11552 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11554 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11568 if (match || l2 || l3 || l4)
11570 if (l2 || l3 || l4)
11572 /* "Win a free Ethernet header in every packet" */
11574 vec_validate_aligned (l2, 13, sizeof (u32x4));
11578 vec_append_aligned (match, l3, sizeof (u32x4));
11583 vec_append_aligned (match, l4, sizeof (u32x4));
11588 /* Make sure the vector is big enough even if key is all 0's */
11589 vec_validate_aligned
11590 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11593 /* Set size, include skipped vectors */
11594 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11605 api_classify_add_del_session (vat_main_t * vam)
11607 unformat_input_t *i = vam->input;
11608 vl_api_classify_add_del_session_t *mp;
11610 u32 table_index = ~0;
11611 u32 hit_next_index = ~0;
11612 u32 opaque_index = ~0;
11615 u32 skip_n_vectors = 0;
11616 u32 match_n_vectors = 0;
11622 * Warning: you have to supply skip_n and match_n
11623 * because the API client cant simply look at the classify
11627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11629 if (unformat (i, "del"))
11631 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11634 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11637 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11640 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11642 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11644 else if (unformat (i, "opaque-index %d", &opaque_index))
11646 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11648 else if (unformat (i, "match_n %d", &match_n_vectors))
11650 else if (unformat (i, "match %U", api_unformat_classify_match,
11651 &match, skip_n_vectors, match_n_vectors))
11653 else if (unformat (i, "advance %d", &advance))
11655 else if (unformat (i, "table-index %d", &table_index))
11657 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11659 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11661 else if (unformat (i, "action %d", &action))
11663 else if (unformat (i, "metadata %d", &metadata))
11669 if (table_index == ~0)
11671 errmsg ("Table index required");
11675 if (is_add && match == 0)
11677 errmsg ("Match value required");
11681 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11683 mp->is_add = is_add;
11684 mp->table_index = ntohl (table_index);
11685 mp->hit_next_index = ntohl (hit_next_index);
11686 mp->opaque_index = ntohl (opaque_index);
11687 mp->advance = ntohl (advance);
11688 mp->action = action;
11689 mp->metadata = ntohl (metadata);
11690 clib_memcpy (mp->match, match, vec_len (match));
11699 api_classify_set_interface_ip_table (vat_main_t * vam)
11701 unformat_input_t *i = vam->input;
11702 vl_api_classify_set_interface_ip_table_t *mp;
11704 int sw_if_index_set;
11705 u32 table_index = ~0;
11709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11711 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11712 sw_if_index_set = 1;
11713 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11714 sw_if_index_set = 1;
11715 else if (unformat (i, "table %d", &table_index))
11719 clib_warning ("parse error '%U'", format_unformat_error, i);
11724 if (sw_if_index_set == 0)
11726 errmsg ("missing interface name or sw_if_index");
11731 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11733 mp->sw_if_index = ntohl (sw_if_index);
11734 mp->table_index = ntohl (table_index);
11735 mp->is_ipv6 = is_ipv6;
11743 api_classify_set_interface_l2_tables (vat_main_t * vam)
11745 unformat_input_t *i = vam->input;
11746 vl_api_classify_set_interface_l2_tables_t *mp;
11748 int sw_if_index_set;
11749 u32 ip4_table_index = ~0;
11750 u32 ip6_table_index = ~0;
11751 u32 other_table_index = ~0;
11755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11757 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11758 sw_if_index_set = 1;
11759 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11760 sw_if_index_set = 1;
11761 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11763 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11765 else if (unformat (i, "other-table %d", &other_table_index))
11767 else if (unformat (i, "is-input %d", &is_input))
11771 clib_warning ("parse error '%U'", format_unformat_error, i);
11776 if (sw_if_index_set == 0)
11778 errmsg ("missing interface name or sw_if_index");
11783 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11785 mp->sw_if_index = ntohl (sw_if_index);
11786 mp->ip4_table_index = ntohl (ip4_table_index);
11787 mp->ip6_table_index = ntohl (ip6_table_index);
11788 mp->other_table_index = ntohl (other_table_index);
11789 mp->is_input = (u8) is_input;
11797 api_set_ipfix_exporter (vat_main_t * vam)
11799 unformat_input_t *i = vam->input;
11800 vl_api_set_ipfix_exporter_t *mp;
11801 ip4_address_t collector_address;
11802 u8 collector_address_set = 0;
11803 u32 collector_port = ~0;
11804 ip4_address_t src_address;
11805 u8 src_address_set = 0;
11808 u32 template_interval = ~0;
11809 u8 udp_checksum = 0;
11812 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11814 if (unformat (i, "collector_address %U", unformat_ip4_address,
11815 &collector_address))
11816 collector_address_set = 1;
11817 else if (unformat (i, "collector_port %d", &collector_port))
11819 else if (unformat (i, "src_address %U", unformat_ip4_address,
11821 src_address_set = 1;
11822 else if (unformat (i, "vrf_id %d", &vrf_id))
11824 else if (unformat (i, "path_mtu %d", &path_mtu))
11826 else if (unformat (i, "template_interval %d", &template_interval))
11828 else if (unformat (i, "udp_checksum"))
11834 if (collector_address_set == 0)
11836 errmsg ("collector_address required");
11840 if (src_address_set == 0)
11842 errmsg ("src_address required");
11846 M (SET_IPFIX_EXPORTER, mp);
11848 memcpy (mp->collector_address, collector_address.data,
11849 sizeof (collector_address.data));
11850 mp->collector_port = htons ((u16) collector_port);
11851 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11852 mp->vrf_id = htonl (vrf_id);
11853 mp->path_mtu = htonl (path_mtu);
11854 mp->template_interval = htonl (template_interval);
11855 mp->udp_checksum = udp_checksum;
11863 api_set_ipfix_classify_stream (vat_main_t * vam)
11865 unformat_input_t *i = vam->input;
11866 vl_api_set_ipfix_classify_stream_t *mp;
11868 u32 src_port = UDP_DST_PORT_ipfix;
11871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11873 if (unformat (i, "domain %d", &domain_id))
11875 else if (unformat (i, "src_port %d", &src_port))
11879 errmsg ("unknown input `%U'", format_unformat_error, i);
11884 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11886 mp->domain_id = htonl (domain_id);
11887 mp->src_port = htons ((u16) src_port);
11895 api_ipfix_classify_table_add_del (vat_main_t * vam)
11897 unformat_input_t *i = vam->input;
11898 vl_api_ipfix_classify_table_add_del_t *mp;
11900 u32 classify_table_index = ~0;
11902 u8 transport_protocol = 255;
11905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11907 if (unformat (i, "add"))
11909 else if (unformat (i, "del"))
11911 else if (unformat (i, "table %d", &classify_table_index))
11913 else if (unformat (i, "ip4"))
11915 else if (unformat (i, "ip6"))
11917 else if (unformat (i, "tcp"))
11918 transport_protocol = 6;
11919 else if (unformat (i, "udp"))
11920 transport_protocol = 17;
11923 errmsg ("unknown input `%U'", format_unformat_error, i);
11930 errmsg ("expecting: add|del");
11933 if (classify_table_index == ~0)
11935 errmsg ("classifier table not specified");
11938 if (ip_version == 0)
11940 errmsg ("IP version not specified");
11944 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11946 mp->is_add = is_add;
11947 mp->table_id = htonl (classify_table_index);
11948 mp->ip_version = ip_version;
11949 mp->transport_protocol = transport_protocol;
11957 api_get_node_index (vat_main_t * vam)
11959 unformat_input_t *i = vam->input;
11960 vl_api_get_node_index_t *mp;
11964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11966 if (unformat (i, "node %s", &name))
11973 errmsg ("node name required");
11976 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11978 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11982 M (GET_NODE_INDEX, mp);
11983 clib_memcpy (mp->node_name, name, vec_len (name));
11992 api_get_next_index (vat_main_t * vam)
11994 unformat_input_t *i = vam->input;
11995 vl_api_get_next_index_t *mp;
11996 u8 *node_name = 0, *next_node_name = 0;
11999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12001 if (unformat (i, "node-name %s", &node_name))
12003 else if (unformat (i, "next-node-name %s", &next_node_name))
12007 if (node_name == 0)
12009 errmsg ("node name required");
12012 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12014 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12018 if (next_node_name == 0)
12020 errmsg ("next node name required");
12023 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12025 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12029 M (GET_NEXT_INDEX, mp);
12030 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12031 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12032 vec_free (node_name);
12033 vec_free (next_node_name);
12041 api_add_node_next (vat_main_t * vam)
12043 unformat_input_t *i = vam->input;
12044 vl_api_add_node_next_t *mp;
12049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12051 if (unformat (i, "node %s", &name))
12053 else if (unformat (i, "next %s", &next))
12060 errmsg ("node name required");
12063 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12065 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12070 errmsg ("next node required");
12073 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12075 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12079 M (ADD_NODE_NEXT, mp);
12080 clib_memcpy (mp->node_name, name, vec_len (name));
12081 clib_memcpy (mp->next_name, next, vec_len (next));
12091 api_l2tpv3_create_tunnel (vat_main_t * vam)
12093 unformat_input_t *i = vam->input;
12094 ip6_address_t client_address, our_address;
12095 int client_address_set = 0;
12096 int our_address_set = 0;
12097 u32 local_session_id = 0;
12098 u32 remote_session_id = 0;
12099 u64 local_cookie = 0;
12100 u64 remote_cookie = 0;
12101 u8 l2_sublayer_present = 0;
12102 vl_api_l2tpv3_create_tunnel_t *mp;
12105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12107 if (unformat (i, "client_address %U", unformat_ip6_address,
12109 client_address_set = 1;
12110 else if (unformat (i, "our_address %U", unformat_ip6_address,
12112 our_address_set = 1;
12113 else if (unformat (i, "local_session_id %d", &local_session_id))
12115 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12117 else if (unformat (i, "local_cookie %lld", &local_cookie))
12119 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12121 else if (unformat (i, "l2-sublayer-present"))
12122 l2_sublayer_present = 1;
12127 if (client_address_set == 0)
12129 errmsg ("client_address required");
12133 if (our_address_set == 0)
12135 errmsg ("our_address required");
12139 M (L2TPV3_CREATE_TUNNEL, mp);
12141 clib_memcpy (mp->client_address, client_address.as_u8,
12142 sizeof (mp->client_address));
12144 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12146 mp->local_session_id = ntohl (local_session_id);
12147 mp->remote_session_id = ntohl (remote_session_id);
12148 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12149 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12150 mp->l2_sublayer_present = l2_sublayer_present;
12159 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12161 unformat_input_t *i = vam->input;
12163 u8 sw_if_index_set = 0;
12164 u64 new_local_cookie = 0;
12165 u64 new_remote_cookie = 0;
12166 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12171 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12172 sw_if_index_set = 1;
12173 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12174 sw_if_index_set = 1;
12175 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12177 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12183 if (sw_if_index_set == 0)
12185 errmsg ("missing interface name or sw_if_index");
12189 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12191 mp->sw_if_index = ntohl (sw_if_index);
12192 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12193 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12201 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12203 unformat_input_t *i = vam->input;
12204 vl_api_l2tpv3_interface_enable_disable_t *mp;
12206 u8 sw_if_index_set = 0;
12207 u8 enable_disable = 1;
12210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12212 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12213 sw_if_index_set = 1;
12214 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12215 sw_if_index_set = 1;
12216 else if (unformat (i, "enable"))
12217 enable_disable = 1;
12218 else if (unformat (i, "disable"))
12219 enable_disable = 0;
12224 if (sw_if_index_set == 0)
12226 errmsg ("missing interface name or sw_if_index");
12230 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12232 mp->sw_if_index = ntohl (sw_if_index);
12233 mp->enable_disable = enable_disable;
12241 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12243 unformat_input_t *i = vam->input;
12244 vl_api_l2tpv3_set_lookup_key_t *mp;
12248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12250 if (unformat (i, "lookup_v6_src"))
12251 key = L2T_LOOKUP_SRC_ADDRESS;
12252 else if (unformat (i, "lookup_v6_dst"))
12253 key = L2T_LOOKUP_DST_ADDRESS;
12254 else if (unformat (i, "lookup_session_id"))
12255 key = L2T_LOOKUP_SESSION_ID;
12260 if (key == (u8) ~ 0)
12262 errmsg ("l2tp session lookup key unset");
12266 M (L2TPV3_SET_LOOKUP_KEY, mp);
12275 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12276 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12278 vat_main_t *vam = &vat_main;
12280 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12281 format_ip6_address, mp->our_address,
12282 format_ip6_address, mp->client_address,
12283 clib_net_to_host_u32 (mp->sw_if_index));
12286 " local cookies %016llx %016llx remote cookie %016llx",
12287 clib_net_to_host_u64 (mp->local_cookie[0]),
12288 clib_net_to_host_u64 (mp->local_cookie[1]),
12289 clib_net_to_host_u64 (mp->remote_cookie));
12291 print (vam->ofp, " local session-id %d remote session-id %d",
12292 clib_net_to_host_u32 (mp->local_session_id),
12293 clib_net_to_host_u32 (mp->remote_session_id));
12295 print (vam->ofp, " l2 specific sublayer %s\n",
12296 mp->l2_sublayer_present ? "preset" : "absent");
12300 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12301 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12303 vat_main_t *vam = &vat_main;
12304 vat_json_node_t *node = NULL;
12305 struct in6_addr addr;
12307 if (VAT_JSON_ARRAY != vam->json_tree.type)
12309 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12310 vat_json_init_array (&vam->json_tree);
12312 node = vat_json_array_add (&vam->json_tree);
12314 vat_json_init_object (node);
12316 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12317 vat_json_object_add_ip6 (node, "our_address", addr);
12318 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12319 vat_json_object_add_ip6 (node, "client_address", addr);
12321 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12322 vat_json_init_array (lc);
12323 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12324 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12325 vat_json_object_add_uint (node, "remote_cookie",
12326 clib_net_to_host_u64 (mp->remote_cookie));
12328 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12329 vat_json_object_add_uint (node, "local_session_id",
12330 clib_net_to_host_u32 (mp->local_session_id));
12331 vat_json_object_add_uint (node, "remote_session_id",
12332 clib_net_to_host_u32 (mp->remote_session_id));
12333 vat_json_object_add_string_copy (node, "l2_sublayer",
12334 mp->l2_sublayer_present ? (u8 *) "present"
12335 : (u8 *) "absent");
12339 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12341 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12342 vl_api_control_ping_t *mp_ping;
12345 /* Get list of l2tpv3-tunnel interfaces */
12346 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12349 /* Use a control ping for synchronization */
12350 MPING (CONTROL_PING, mp_ping);
12358 static void vl_api_sw_interface_tap_details_t_handler
12359 (vl_api_sw_interface_tap_details_t * mp)
12361 vat_main_t *vam = &vat_main;
12363 print (vam->ofp, "%-16s %d",
12364 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12367 static void vl_api_sw_interface_tap_details_t_handler_json
12368 (vl_api_sw_interface_tap_details_t * mp)
12370 vat_main_t *vam = &vat_main;
12371 vat_json_node_t *node = NULL;
12373 if (VAT_JSON_ARRAY != vam->json_tree.type)
12375 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12376 vat_json_init_array (&vam->json_tree);
12378 node = vat_json_array_add (&vam->json_tree);
12380 vat_json_init_object (node);
12381 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12382 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12386 api_sw_interface_tap_dump (vat_main_t * vam)
12388 vl_api_sw_interface_tap_dump_t *mp;
12389 vl_api_control_ping_t *mp_ping;
12392 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12393 /* Get list of tap interfaces */
12394 M (SW_INTERFACE_TAP_DUMP, mp);
12397 /* Use a control ping for synchronization */
12398 MPING (CONTROL_PING, mp_ping);
12405 static void vl_api_sw_interface_tap_v2_details_t_handler
12406 (vl_api_sw_interface_tap_v2_details_t * mp)
12408 vat_main_t *vam = &vat_main;
12410 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12411 mp->host_ip4_prefix_len);
12412 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12413 mp->host_ip6_prefix_len);
12416 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s",
12417 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12418 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12419 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12420 mp->host_bridge, ip4, ip6);
12426 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12427 (vl_api_sw_interface_tap_v2_details_t * mp)
12429 vat_main_t *vam = &vat_main;
12430 vat_json_node_t *node = NULL;
12432 if (VAT_JSON_ARRAY != vam->json_tree.type)
12434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12435 vat_json_init_array (&vam->json_tree);
12437 node = vat_json_array_add (&vam->json_tree);
12439 vat_json_init_object (node);
12440 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12441 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12442 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12443 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12444 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12445 vat_json_object_add_string_copy (node, "host_mac_addr",
12446 format (0, "%U", format_ethernet_address,
12447 &mp->host_mac_addr));
12448 vat_json_object_add_string_copy (node, "host_namespace",
12449 mp->host_namespace);
12450 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12451 vat_json_object_add_string_copy (node, "host_ip4_addr",
12452 format (0, "%U/%d", format_ip4_address,
12454 mp->host_ip4_prefix_len));
12455 vat_json_object_add_string_copy (node, "host_ip6_addr",
12456 format (0, "%U/%d", format_ip6_address,
12458 mp->host_ip6_prefix_len));
12463 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12465 vl_api_sw_interface_tap_v2_dump_t *mp;
12466 vl_api_control_ping_t *mp_ping;
12470 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12471 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12472 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12475 /* Get list of tap interfaces */
12476 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12479 /* Use a control ping for synchronization */
12480 MPING (CONTROL_PING, mp_ping);
12487 static uword unformat_vxlan_decap_next
12488 (unformat_input_t * input, va_list * args)
12490 u32 *result = va_arg (*args, u32 *);
12493 if (unformat (input, "l2"))
12494 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12495 else if (unformat (input, "%d", &tmp))
12503 api_vxlan_add_del_tunnel (vat_main_t * vam)
12505 unformat_input_t *line_input = vam->input;
12506 vl_api_vxlan_add_del_tunnel_t *mp;
12507 ip46_address_t src, dst;
12509 u8 ipv4_set = 0, ipv6_set = 0;
12513 u32 mcast_sw_if_index = ~0;
12514 u32 encap_vrf_id = 0;
12515 u32 decap_next_index = ~0;
12519 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12520 memset (&src, 0, sizeof src);
12521 memset (&dst, 0, sizeof dst);
12523 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12525 if (unformat (line_input, "del"))
12528 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12534 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12540 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12546 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12551 else if (unformat (line_input, "group %U %U",
12552 unformat_ip4_address, &dst.ip4,
12553 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12555 grp_set = dst_set = 1;
12558 else if (unformat (line_input, "group %U",
12559 unformat_ip4_address, &dst.ip4))
12561 grp_set = dst_set = 1;
12564 else if (unformat (line_input, "group %U %U",
12565 unformat_ip6_address, &dst.ip6,
12566 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12568 grp_set = dst_set = 1;
12571 else if (unformat (line_input, "group %U",
12572 unformat_ip6_address, &dst.ip6))
12574 grp_set = dst_set = 1;
12578 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12580 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12582 else if (unformat (line_input, "decap-next %U",
12583 unformat_vxlan_decap_next, &decap_next_index))
12585 else if (unformat (line_input, "vni %d", &vni))
12589 errmsg ("parse error '%U'", format_unformat_error, line_input);
12596 errmsg ("tunnel src address not specified");
12601 errmsg ("tunnel dst address not specified");
12605 if (grp_set && !ip46_address_is_multicast (&dst))
12607 errmsg ("tunnel group address not multicast");
12610 if (grp_set && mcast_sw_if_index == ~0)
12612 errmsg ("tunnel nonexistent multicast device");
12615 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12617 errmsg ("tunnel dst address must be unicast");
12622 if (ipv4_set && ipv6_set)
12624 errmsg ("both IPv4 and IPv6 addresses specified");
12628 if ((vni == 0) || (vni >> 24))
12630 errmsg ("vni not specified or out of range");
12634 M (VXLAN_ADD_DEL_TUNNEL, mp);
12638 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12639 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12643 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12644 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12646 mp->encap_vrf_id = ntohl (encap_vrf_id);
12647 mp->decap_next_index = ntohl (decap_next_index);
12648 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12649 mp->vni = ntohl (vni);
12650 mp->is_add = is_add;
12651 mp->is_ipv6 = ipv6_set;
12658 static void vl_api_vxlan_tunnel_details_t_handler
12659 (vl_api_vxlan_tunnel_details_t * mp)
12661 vat_main_t *vam = &vat_main;
12662 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12663 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12665 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12666 ntohl (mp->sw_if_index),
12667 format_ip46_address, &src, IP46_TYPE_ANY,
12668 format_ip46_address, &dst, IP46_TYPE_ANY,
12669 ntohl (mp->encap_vrf_id),
12670 ntohl (mp->decap_next_index), ntohl (mp->vni),
12671 ntohl (mp->mcast_sw_if_index));
12674 static void vl_api_vxlan_tunnel_details_t_handler_json
12675 (vl_api_vxlan_tunnel_details_t * mp)
12677 vat_main_t *vam = &vat_main;
12678 vat_json_node_t *node = NULL;
12680 if (VAT_JSON_ARRAY != vam->json_tree.type)
12682 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12683 vat_json_init_array (&vam->json_tree);
12685 node = vat_json_array_add (&vam->json_tree);
12687 vat_json_init_object (node);
12688 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12691 struct in6_addr ip6;
12693 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12694 vat_json_object_add_ip6 (node, "src_address", ip6);
12695 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12696 vat_json_object_add_ip6 (node, "dst_address", ip6);
12700 struct in_addr ip4;
12702 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12703 vat_json_object_add_ip4 (node, "src_address", ip4);
12704 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12705 vat_json_object_add_ip4 (node, "dst_address", ip4);
12707 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12708 vat_json_object_add_uint (node, "decap_next_index",
12709 ntohl (mp->decap_next_index));
12710 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12711 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12712 vat_json_object_add_uint (node, "mcast_sw_if_index",
12713 ntohl (mp->mcast_sw_if_index));
12717 api_vxlan_tunnel_dump (vat_main_t * vam)
12719 unformat_input_t *i = vam->input;
12720 vl_api_vxlan_tunnel_dump_t *mp;
12721 vl_api_control_ping_t *mp_ping;
12723 u8 sw_if_index_set = 0;
12726 /* Parse args required to build the message */
12727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12729 if (unformat (i, "sw_if_index %d", &sw_if_index))
12730 sw_if_index_set = 1;
12735 if (sw_if_index_set == 0)
12740 if (!vam->json_output)
12742 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12743 "sw_if_index", "src_address", "dst_address",
12744 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12747 /* Get list of vxlan-tunnel interfaces */
12748 M (VXLAN_TUNNEL_DUMP, mp);
12750 mp->sw_if_index = htonl (sw_if_index);
12754 /* Use a control ping for synchronization */
12755 MPING (CONTROL_PING, mp_ping);
12762 static uword unformat_geneve_decap_next
12763 (unformat_input_t * input, va_list * args)
12765 u32 *result = va_arg (*args, u32 *);
12768 if (unformat (input, "l2"))
12769 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12770 else if (unformat (input, "%d", &tmp))
12778 api_geneve_add_del_tunnel (vat_main_t * vam)
12780 unformat_input_t *line_input = vam->input;
12781 vl_api_geneve_add_del_tunnel_t *mp;
12782 ip46_address_t src, dst;
12784 u8 ipv4_set = 0, ipv6_set = 0;
12788 u32 mcast_sw_if_index = ~0;
12789 u32 encap_vrf_id = 0;
12790 u32 decap_next_index = ~0;
12794 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12795 memset (&src, 0, sizeof src);
12796 memset (&dst, 0, sizeof dst);
12798 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12800 if (unformat (line_input, "del"))
12803 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12809 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12815 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12821 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12826 else if (unformat (line_input, "group %U %U",
12827 unformat_ip4_address, &dst.ip4,
12828 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12830 grp_set = dst_set = 1;
12833 else if (unformat (line_input, "group %U",
12834 unformat_ip4_address, &dst.ip4))
12836 grp_set = dst_set = 1;
12839 else if (unformat (line_input, "group %U %U",
12840 unformat_ip6_address, &dst.ip6,
12841 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12843 grp_set = dst_set = 1;
12846 else if (unformat (line_input, "group %U",
12847 unformat_ip6_address, &dst.ip6))
12849 grp_set = dst_set = 1;
12853 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12855 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12857 else if (unformat (line_input, "decap-next %U",
12858 unformat_geneve_decap_next, &decap_next_index))
12860 else if (unformat (line_input, "vni %d", &vni))
12864 errmsg ("parse error '%U'", format_unformat_error, line_input);
12871 errmsg ("tunnel src address not specified");
12876 errmsg ("tunnel dst address not specified");
12880 if (grp_set && !ip46_address_is_multicast (&dst))
12882 errmsg ("tunnel group address not multicast");
12885 if (grp_set && mcast_sw_if_index == ~0)
12887 errmsg ("tunnel nonexistent multicast device");
12890 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12892 errmsg ("tunnel dst address must be unicast");
12897 if (ipv4_set && ipv6_set)
12899 errmsg ("both IPv4 and IPv6 addresses specified");
12903 if ((vni == 0) || (vni >> 24))
12905 errmsg ("vni not specified or out of range");
12909 M (GENEVE_ADD_DEL_TUNNEL, mp);
12913 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12914 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12918 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12919 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12921 mp->encap_vrf_id = ntohl (encap_vrf_id);
12922 mp->decap_next_index = ntohl (decap_next_index);
12923 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12924 mp->vni = ntohl (vni);
12925 mp->is_add = is_add;
12926 mp->is_ipv6 = ipv6_set;
12933 static void vl_api_geneve_tunnel_details_t_handler
12934 (vl_api_geneve_tunnel_details_t * mp)
12936 vat_main_t *vam = &vat_main;
12937 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12938 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12940 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12941 ntohl (mp->sw_if_index),
12942 format_ip46_address, &src, IP46_TYPE_ANY,
12943 format_ip46_address, &dst, IP46_TYPE_ANY,
12944 ntohl (mp->encap_vrf_id),
12945 ntohl (mp->decap_next_index), ntohl (mp->vni),
12946 ntohl (mp->mcast_sw_if_index));
12949 static void vl_api_geneve_tunnel_details_t_handler_json
12950 (vl_api_geneve_tunnel_details_t * mp)
12952 vat_main_t *vam = &vat_main;
12953 vat_json_node_t *node = NULL;
12955 if (VAT_JSON_ARRAY != vam->json_tree.type)
12957 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12958 vat_json_init_array (&vam->json_tree);
12960 node = vat_json_array_add (&vam->json_tree);
12962 vat_json_init_object (node);
12963 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12966 struct in6_addr ip6;
12968 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12969 vat_json_object_add_ip6 (node, "src_address", ip6);
12970 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12971 vat_json_object_add_ip6 (node, "dst_address", ip6);
12975 struct in_addr ip4;
12977 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12978 vat_json_object_add_ip4 (node, "src_address", ip4);
12979 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12980 vat_json_object_add_ip4 (node, "dst_address", ip4);
12982 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12983 vat_json_object_add_uint (node, "decap_next_index",
12984 ntohl (mp->decap_next_index));
12985 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12986 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12987 vat_json_object_add_uint (node, "mcast_sw_if_index",
12988 ntohl (mp->mcast_sw_if_index));
12992 api_geneve_tunnel_dump (vat_main_t * vam)
12994 unformat_input_t *i = vam->input;
12995 vl_api_geneve_tunnel_dump_t *mp;
12996 vl_api_control_ping_t *mp_ping;
12998 u8 sw_if_index_set = 0;
13001 /* Parse args required to build the message */
13002 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13004 if (unformat (i, "sw_if_index %d", &sw_if_index))
13005 sw_if_index_set = 1;
13010 if (sw_if_index_set == 0)
13015 if (!vam->json_output)
13017 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13018 "sw_if_index", "local_address", "remote_address",
13019 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13022 /* Get list of geneve-tunnel interfaces */
13023 M (GENEVE_TUNNEL_DUMP, mp);
13025 mp->sw_if_index = htonl (sw_if_index);
13029 /* Use a control ping for synchronization */
13030 M (CONTROL_PING, mp_ping);
13038 api_gre_add_del_tunnel (vat_main_t * vam)
13040 unformat_input_t *line_input = vam->input;
13041 vl_api_gre_add_del_tunnel_t *mp;
13042 ip4_address_t src4, dst4;
13043 ip6_address_t src6, dst6;
13050 u32 outer_fib_id = 0;
13053 memset (&src4, 0, sizeof src4);
13054 memset (&dst4, 0, sizeof dst4);
13055 memset (&src6, 0, sizeof src6);
13056 memset (&dst6, 0, sizeof dst6);
13058 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13060 if (unformat (line_input, "del"))
13062 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13067 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13072 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13077 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13082 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13084 else if (unformat (line_input, "teb"))
13088 errmsg ("parse error '%U'", format_unformat_error, line_input);
13095 errmsg ("tunnel src address not specified");
13100 errmsg ("tunnel dst address not specified");
13103 if (ipv4_set && ipv6_set)
13105 errmsg ("both IPv4 and IPv6 addresses specified");
13110 M (GRE_ADD_DEL_TUNNEL, mp);
13114 clib_memcpy (&mp->src_address, &src4, 4);
13115 clib_memcpy (&mp->dst_address, &dst4, 4);
13119 clib_memcpy (&mp->src_address, &src6, 16);
13120 clib_memcpy (&mp->dst_address, &dst6, 16);
13122 mp->outer_fib_id = ntohl (outer_fib_id);
13123 mp->is_add = is_add;
13125 mp->is_ipv6 = ipv6_set;
13132 static void vl_api_gre_tunnel_details_t_handler
13133 (vl_api_gre_tunnel_details_t * mp)
13135 vat_main_t *vam = &vat_main;
13136 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13137 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13139 print (vam->ofp, "%11d%24U%24U%6d%14d",
13140 ntohl (mp->sw_if_index),
13141 format_ip46_address, &src, IP46_TYPE_ANY,
13142 format_ip46_address, &dst, IP46_TYPE_ANY,
13143 mp->teb, ntohl (mp->outer_fib_id));
13146 static void vl_api_gre_tunnel_details_t_handler_json
13147 (vl_api_gre_tunnel_details_t * mp)
13149 vat_main_t *vam = &vat_main;
13150 vat_json_node_t *node = NULL;
13151 struct in_addr ip4;
13152 struct in6_addr ip6;
13154 if (VAT_JSON_ARRAY != vam->json_tree.type)
13156 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13157 vat_json_init_array (&vam->json_tree);
13159 node = vat_json_array_add (&vam->json_tree);
13161 vat_json_init_object (node);
13162 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13165 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13166 vat_json_object_add_ip4 (node, "src_address", ip4);
13167 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13168 vat_json_object_add_ip4 (node, "dst_address", ip4);
13172 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13173 vat_json_object_add_ip6 (node, "src_address", ip6);
13174 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13175 vat_json_object_add_ip6 (node, "dst_address", ip6);
13177 vat_json_object_add_uint (node, "teb", mp->teb);
13178 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13179 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13183 api_gre_tunnel_dump (vat_main_t * vam)
13185 unformat_input_t *i = vam->input;
13186 vl_api_gre_tunnel_dump_t *mp;
13187 vl_api_control_ping_t *mp_ping;
13189 u8 sw_if_index_set = 0;
13192 /* Parse args required to build the message */
13193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13195 if (unformat (i, "sw_if_index %d", &sw_if_index))
13196 sw_if_index_set = 1;
13201 if (sw_if_index_set == 0)
13206 if (!vam->json_output)
13208 print (vam->ofp, "%11s%24s%24s%6s%14s",
13209 "sw_if_index", "src_address", "dst_address", "teb",
13213 /* Get list of gre-tunnel interfaces */
13214 M (GRE_TUNNEL_DUMP, mp);
13216 mp->sw_if_index = htonl (sw_if_index);
13220 /* Use a control ping for synchronization */
13221 MPING (CONTROL_PING, mp_ping);
13229 api_l2_fib_clear_table (vat_main_t * vam)
13231 // unformat_input_t * i = vam->input;
13232 vl_api_l2_fib_clear_table_t *mp;
13235 M (L2_FIB_CLEAR_TABLE, mp);
13243 api_l2_interface_efp_filter (vat_main_t * vam)
13245 unformat_input_t *i = vam->input;
13246 vl_api_l2_interface_efp_filter_t *mp;
13249 u8 sw_if_index_set = 0;
13252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13254 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13255 sw_if_index_set = 1;
13256 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13257 sw_if_index_set = 1;
13258 else if (unformat (i, "enable"))
13260 else if (unformat (i, "disable"))
13264 clib_warning ("parse error '%U'", format_unformat_error, i);
13269 if (sw_if_index_set == 0)
13271 errmsg ("missing sw_if_index");
13275 M (L2_INTERFACE_EFP_FILTER, mp);
13277 mp->sw_if_index = ntohl (sw_if_index);
13278 mp->enable_disable = enable;
13285 #define foreach_vtr_op \
13286 _("disable", L2_VTR_DISABLED) \
13287 _("push-1", L2_VTR_PUSH_1) \
13288 _("push-2", L2_VTR_PUSH_2) \
13289 _("pop-1", L2_VTR_POP_1) \
13290 _("pop-2", L2_VTR_POP_2) \
13291 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13292 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13293 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13294 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13297 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13299 unformat_input_t *i = vam->input;
13300 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13302 u8 sw_if_index_set = 0;
13305 u32 push_dot1q = 1;
13310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13312 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13313 sw_if_index_set = 1;
13314 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13315 sw_if_index_set = 1;
13316 else if (unformat (i, "vtr_op %d", &vtr_op))
13318 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13321 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13323 else if (unformat (i, "tag1 %d", &tag1))
13325 else if (unformat (i, "tag2 %d", &tag2))
13329 clib_warning ("parse error '%U'", format_unformat_error, i);
13334 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13336 errmsg ("missing vtr operation or sw_if_index");
13340 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13341 mp->sw_if_index = ntohl (sw_if_index);
13342 mp->vtr_op = ntohl (vtr_op);
13343 mp->push_dot1q = ntohl (push_dot1q);
13344 mp->tag1 = ntohl (tag1);
13345 mp->tag2 = ntohl (tag2);
13353 api_create_vhost_user_if (vat_main_t * vam)
13355 unformat_input_t *i = vam->input;
13356 vl_api_create_vhost_user_if_t *mp;
13359 u8 file_name_set = 0;
13360 u32 custom_dev_instance = ~0;
13362 u8 use_custom_mac = 0;
13366 /* Shut up coverity */
13367 memset (hwaddr, 0, sizeof (hwaddr));
13369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13371 if (unformat (i, "socket %s", &file_name))
13375 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13377 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13378 use_custom_mac = 1;
13379 else if (unformat (i, "server"))
13381 else if (unformat (i, "tag %s", &tag))
13387 if (file_name_set == 0)
13389 errmsg ("missing socket file name");
13393 if (vec_len (file_name) > 255)
13395 errmsg ("socket file name too long");
13398 vec_add1 (file_name, 0);
13400 M (CREATE_VHOST_USER_IF, mp);
13402 mp->is_server = is_server;
13403 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13404 vec_free (file_name);
13405 if (custom_dev_instance != ~0)
13408 mp->custom_dev_instance = ntohl (custom_dev_instance);
13410 mp->use_custom_mac = use_custom_mac;
13411 clib_memcpy (mp->mac_address, hwaddr, 6);
13413 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13422 api_modify_vhost_user_if (vat_main_t * vam)
13424 unformat_input_t *i = vam->input;
13425 vl_api_modify_vhost_user_if_t *mp;
13428 u8 file_name_set = 0;
13429 u32 custom_dev_instance = ~0;
13430 u8 sw_if_index_set = 0;
13431 u32 sw_if_index = (u32) ~ 0;
13434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13436 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13437 sw_if_index_set = 1;
13438 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13439 sw_if_index_set = 1;
13440 else if (unformat (i, "socket %s", &file_name))
13444 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13446 else if (unformat (i, "server"))
13452 if (sw_if_index_set == 0)
13454 errmsg ("missing sw_if_index or interface name");
13458 if (file_name_set == 0)
13460 errmsg ("missing socket file name");
13464 if (vec_len (file_name) > 255)
13466 errmsg ("socket file name too long");
13469 vec_add1 (file_name, 0);
13471 M (MODIFY_VHOST_USER_IF, mp);
13473 mp->sw_if_index = ntohl (sw_if_index);
13474 mp->is_server = is_server;
13475 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13476 vec_free (file_name);
13477 if (custom_dev_instance != ~0)
13480 mp->custom_dev_instance = ntohl (custom_dev_instance);
13489 api_delete_vhost_user_if (vat_main_t * vam)
13491 unformat_input_t *i = vam->input;
13492 vl_api_delete_vhost_user_if_t *mp;
13493 u32 sw_if_index = ~0;
13494 u8 sw_if_index_set = 0;
13497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13499 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13500 sw_if_index_set = 1;
13501 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13502 sw_if_index_set = 1;
13507 if (sw_if_index_set == 0)
13509 errmsg ("missing sw_if_index or interface name");
13514 M (DELETE_VHOST_USER_IF, mp);
13516 mp->sw_if_index = ntohl (sw_if_index);
13523 static void vl_api_sw_interface_vhost_user_details_t_handler
13524 (vl_api_sw_interface_vhost_user_details_t * mp)
13526 vat_main_t *vam = &vat_main;
13528 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13529 (char *) mp->interface_name,
13530 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13531 clib_net_to_host_u64 (mp->features), mp->is_server,
13532 ntohl (mp->num_regions), (char *) mp->sock_filename);
13533 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13536 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13537 (vl_api_sw_interface_vhost_user_details_t * mp)
13539 vat_main_t *vam = &vat_main;
13540 vat_json_node_t *node = NULL;
13542 if (VAT_JSON_ARRAY != vam->json_tree.type)
13544 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13545 vat_json_init_array (&vam->json_tree);
13547 node = vat_json_array_add (&vam->json_tree);
13549 vat_json_init_object (node);
13550 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13551 vat_json_object_add_string_copy (node, "interface_name",
13552 mp->interface_name);
13553 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13554 ntohl (mp->virtio_net_hdr_sz));
13555 vat_json_object_add_uint (node, "features",
13556 clib_net_to_host_u64 (mp->features));
13557 vat_json_object_add_uint (node, "is_server", mp->is_server);
13558 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13559 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13560 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13564 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13566 vl_api_sw_interface_vhost_user_dump_t *mp;
13567 vl_api_control_ping_t *mp_ping;
13570 "Interface name idx hdr_sz features server regions filename");
13572 /* Get list of vhost-user interfaces */
13573 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13576 /* Use a control ping for synchronization */
13577 MPING (CONTROL_PING, mp_ping);
13585 api_show_version (vat_main_t * vam)
13587 vl_api_show_version_t *mp;
13590 M (SHOW_VERSION, mp);
13599 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13601 unformat_input_t *line_input = vam->input;
13602 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13603 ip4_address_t local4, remote4;
13604 ip6_address_t local6, remote6;
13606 u8 ipv4_set = 0, ipv6_set = 0;
13610 u32 mcast_sw_if_index = ~0;
13611 u32 encap_vrf_id = 0;
13612 u32 decap_vrf_id = 0;
13618 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13619 memset (&local4, 0, sizeof local4);
13620 memset (&remote4, 0, sizeof remote4);
13621 memset (&local6, 0, sizeof local6);
13622 memset (&remote6, 0, sizeof remote6);
13624 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13626 if (unformat (line_input, "del"))
13628 else if (unformat (line_input, "local %U",
13629 unformat_ip4_address, &local4))
13634 else if (unformat (line_input, "remote %U",
13635 unformat_ip4_address, &remote4))
13640 else if (unformat (line_input, "local %U",
13641 unformat_ip6_address, &local6))
13646 else if (unformat (line_input, "remote %U",
13647 unformat_ip6_address, &remote6))
13652 else if (unformat (line_input, "group %U %U",
13653 unformat_ip4_address, &remote4,
13654 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13656 grp_set = remote_set = 1;
13659 else if (unformat (line_input, "group %U",
13660 unformat_ip4_address, &remote4))
13662 grp_set = remote_set = 1;
13665 else if (unformat (line_input, "group %U %U",
13666 unformat_ip6_address, &remote6,
13667 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13669 grp_set = remote_set = 1;
13672 else if (unformat (line_input, "group %U",
13673 unformat_ip6_address, &remote6))
13675 grp_set = remote_set = 1;
13679 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13681 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13683 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13685 else if (unformat (line_input, "vni %d", &vni))
13687 else if (unformat (line_input, "next-ip4"))
13689 else if (unformat (line_input, "next-ip6"))
13691 else if (unformat (line_input, "next-ethernet"))
13693 else if (unformat (line_input, "next-nsh"))
13697 errmsg ("parse error '%U'", format_unformat_error, line_input);
13702 if (local_set == 0)
13704 errmsg ("tunnel local address not specified");
13707 if (remote_set == 0)
13709 errmsg ("tunnel remote address not specified");
13712 if (grp_set && mcast_sw_if_index == ~0)
13714 errmsg ("tunnel nonexistent multicast device");
13717 if (ipv4_set && ipv6_set)
13719 errmsg ("both IPv4 and IPv6 addresses specified");
13725 errmsg ("vni not specified");
13729 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13734 clib_memcpy (&mp->local, &local6, sizeof (local6));
13735 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13739 clib_memcpy (&mp->local, &local4, sizeof (local4));
13740 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13743 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13744 mp->encap_vrf_id = ntohl (encap_vrf_id);
13745 mp->decap_vrf_id = ntohl (decap_vrf_id);
13746 mp->protocol = protocol;
13747 mp->vni = ntohl (vni);
13748 mp->is_add = is_add;
13749 mp->is_ipv6 = ipv6_set;
13756 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13757 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13759 vat_main_t *vam = &vat_main;
13760 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13761 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13763 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13764 ntohl (mp->sw_if_index),
13765 format_ip46_address, &local, IP46_TYPE_ANY,
13766 format_ip46_address, &remote, IP46_TYPE_ANY,
13767 ntohl (mp->vni), mp->protocol,
13768 ntohl (mp->mcast_sw_if_index),
13769 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13773 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13774 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13776 vat_main_t *vam = &vat_main;
13777 vat_json_node_t *node = NULL;
13778 struct in_addr ip4;
13779 struct in6_addr ip6;
13781 if (VAT_JSON_ARRAY != vam->json_tree.type)
13783 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13784 vat_json_init_array (&vam->json_tree);
13786 node = vat_json_array_add (&vam->json_tree);
13788 vat_json_init_object (node);
13789 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13792 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13793 vat_json_object_add_ip6 (node, "local", ip6);
13794 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13795 vat_json_object_add_ip6 (node, "remote", ip6);
13799 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13800 vat_json_object_add_ip4 (node, "local", ip4);
13801 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13802 vat_json_object_add_ip4 (node, "remote", ip4);
13804 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13805 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13806 vat_json_object_add_uint (node, "mcast_sw_if_index",
13807 ntohl (mp->mcast_sw_if_index));
13808 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13809 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13810 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13814 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13816 unformat_input_t *i = vam->input;
13817 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13818 vl_api_control_ping_t *mp_ping;
13820 u8 sw_if_index_set = 0;
13823 /* Parse args required to build the message */
13824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13826 if (unformat (i, "sw_if_index %d", &sw_if_index))
13827 sw_if_index_set = 1;
13832 if (sw_if_index_set == 0)
13837 if (!vam->json_output)
13839 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13840 "sw_if_index", "local", "remote", "vni",
13841 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13844 /* Get list of vxlan-tunnel interfaces */
13845 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13847 mp->sw_if_index = htonl (sw_if_index);
13851 /* Use a control ping for synchronization */
13852 MPING (CONTROL_PING, mp_ping);
13859 static void vl_api_l2_fib_table_details_t_handler
13860 (vl_api_l2_fib_table_details_t * mp)
13862 vat_main_t *vam = &vat_main;
13864 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13866 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13867 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13871 static void vl_api_l2_fib_table_details_t_handler_json
13872 (vl_api_l2_fib_table_details_t * mp)
13874 vat_main_t *vam = &vat_main;
13875 vat_json_node_t *node = NULL;
13877 if (VAT_JSON_ARRAY != vam->json_tree.type)
13879 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13880 vat_json_init_array (&vam->json_tree);
13882 node = vat_json_array_add (&vam->json_tree);
13884 vat_json_init_object (node);
13885 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13886 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13887 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13888 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13889 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13890 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13894 api_l2_fib_table_dump (vat_main_t * vam)
13896 unformat_input_t *i = vam->input;
13897 vl_api_l2_fib_table_dump_t *mp;
13898 vl_api_control_ping_t *mp_ping;
13903 /* Parse args required to build the message */
13904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13906 if (unformat (i, "bd_id %d", &bd_id))
13912 if (bd_id_set == 0)
13914 errmsg ("missing bridge domain");
13918 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13920 /* Get list of l2 fib entries */
13921 M (L2_FIB_TABLE_DUMP, mp);
13923 mp->bd_id = ntohl (bd_id);
13926 /* Use a control ping for synchronization */
13927 MPING (CONTROL_PING, mp_ping);
13936 api_interface_name_renumber (vat_main_t * vam)
13938 unformat_input_t *line_input = vam->input;
13939 vl_api_interface_name_renumber_t *mp;
13940 u32 sw_if_index = ~0;
13941 u32 new_show_dev_instance = ~0;
13944 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13946 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13949 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13951 else if (unformat (line_input, "new_show_dev_instance %d",
13952 &new_show_dev_instance))
13958 if (sw_if_index == ~0)
13960 errmsg ("missing interface name or sw_if_index");
13964 if (new_show_dev_instance == ~0)
13966 errmsg ("missing new_show_dev_instance");
13970 M (INTERFACE_NAME_RENUMBER, mp);
13972 mp->sw_if_index = ntohl (sw_if_index);
13973 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13981 api_want_ip4_arp_events (vat_main_t * vam)
13983 unformat_input_t *line_input = vam->input;
13984 vl_api_want_ip4_arp_events_t *mp;
13985 ip4_address_t address;
13986 int address_set = 0;
13987 u32 enable_disable = 1;
13990 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13992 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13994 else if (unformat (line_input, "del"))
13995 enable_disable = 0;
14000 if (address_set == 0)
14002 errmsg ("missing addresses");
14006 M (WANT_IP4_ARP_EVENTS, mp);
14007 mp->enable_disable = enable_disable;
14008 mp->pid = htonl (getpid ());
14009 mp->address = address.as_u32;
14017 api_want_ip6_nd_events (vat_main_t * vam)
14019 unformat_input_t *line_input = vam->input;
14020 vl_api_want_ip6_nd_events_t *mp;
14021 ip6_address_t address;
14022 int address_set = 0;
14023 u32 enable_disable = 1;
14026 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14028 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
14030 else if (unformat (line_input, "del"))
14031 enable_disable = 0;
14036 if (address_set == 0)
14038 errmsg ("missing addresses");
14042 M (WANT_IP6_ND_EVENTS, mp);
14043 mp->enable_disable = enable_disable;
14044 mp->pid = htonl (getpid ());
14045 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14053 api_want_l2_macs_events (vat_main_t * vam)
14055 unformat_input_t *line_input = vam->input;
14056 vl_api_want_l2_macs_events_t *mp;
14057 u8 enable_disable = 1;
14058 u32 scan_delay = 0;
14059 u32 max_macs_in_event = 0;
14060 u32 learn_limit = 0;
14063 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14065 if (unformat (line_input, "learn-limit %d", &learn_limit))
14067 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14069 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14071 else if (unformat (line_input, "disable"))
14072 enable_disable = 0;
14077 M (WANT_L2_MACS_EVENTS, mp);
14078 mp->enable_disable = enable_disable;
14079 mp->pid = htonl (getpid ());
14080 mp->learn_limit = htonl (learn_limit);
14081 mp->scan_delay = (u8) scan_delay;
14082 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14089 api_input_acl_set_interface (vat_main_t * vam)
14091 unformat_input_t *i = vam->input;
14092 vl_api_input_acl_set_interface_t *mp;
14094 int sw_if_index_set;
14095 u32 ip4_table_index = ~0;
14096 u32 ip6_table_index = ~0;
14097 u32 l2_table_index = ~0;
14101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14103 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14104 sw_if_index_set = 1;
14105 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14106 sw_if_index_set = 1;
14107 else if (unformat (i, "del"))
14109 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14111 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14113 else if (unformat (i, "l2-table %d", &l2_table_index))
14117 clib_warning ("parse error '%U'", format_unformat_error, i);
14122 if (sw_if_index_set == 0)
14124 errmsg ("missing interface name or sw_if_index");
14128 M (INPUT_ACL_SET_INTERFACE, mp);
14130 mp->sw_if_index = ntohl (sw_if_index);
14131 mp->ip4_table_index = ntohl (ip4_table_index);
14132 mp->ip6_table_index = ntohl (ip6_table_index);
14133 mp->l2_table_index = ntohl (l2_table_index);
14134 mp->is_add = is_add;
14142 api_ip_address_dump (vat_main_t * vam)
14144 unformat_input_t *i = vam->input;
14145 vl_api_ip_address_dump_t *mp;
14146 vl_api_control_ping_t *mp_ping;
14147 u32 sw_if_index = ~0;
14148 u8 sw_if_index_set = 0;
14153 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14155 if (unformat (i, "sw_if_index %d", &sw_if_index))
14156 sw_if_index_set = 1;
14158 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14159 sw_if_index_set = 1;
14160 else if (unformat (i, "ipv4"))
14162 else if (unformat (i, "ipv6"))
14168 if (ipv4_set && ipv6_set)
14170 errmsg ("ipv4 and ipv6 flags cannot be both set");
14174 if ((!ipv4_set) && (!ipv6_set))
14176 errmsg ("no ipv4 nor ipv6 flag set");
14180 if (sw_if_index_set == 0)
14182 errmsg ("missing interface name or sw_if_index");
14186 vam->current_sw_if_index = sw_if_index;
14187 vam->is_ipv6 = ipv6_set;
14189 M (IP_ADDRESS_DUMP, mp);
14190 mp->sw_if_index = ntohl (sw_if_index);
14191 mp->is_ipv6 = ipv6_set;
14194 /* Use a control ping for synchronization */
14195 MPING (CONTROL_PING, mp_ping);
14203 api_ip_dump (vat_main_t * vam)
14205 vl_api_ip_dump_t *mp;
14206 vl_api_control_ping_t *mp_ping;
14207 unformat_input_t *in = vam->input;
14214 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14216 if (unformat (in, "ipv4"))
14218 else if (unformat (in, "ipv6"))
14224 if (ipv4_set && ipv6_set)
14226 errmsg ("ipv4 and ipv6 flags cannot be both set");
14230 if ((!ipv4_set) && (!ipv6_set))
14232 errmsg ("no ipv4 nor ipv6 flag set");
14236 is_ipv6 = ipv6_set;
14237 vam->is_ipv6 = is_ipv6;
14239 /* free old data */
14240 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14242 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14244 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14247 mp->is_ipv6 = ipv6_set;
14250 /* Use a control ping for synchronization */
14251 MPING (CONTROL_PING, mp_ping);
14259 api_ipsec_spd_add_del (vat_main_t * vam)
14261 unformat_input_t *i = vam->input;
14262 vl_api_ipsec_spd_add_del_t *mp;
14267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14269 if (unformat (i, "spd_id %d", &spd_id))
14271 else if (unformat (i, "del"))
14275 clib_warning ("parse error '%U'", format_unformat_error, i);
14281 errmsg ("spd_id must be set");
14285 M (IPSEC_SPD_ADD_DEL, mp);
14287 mp->spd_id = ntohl (spd_id);
14288 mp->is_add = is_add;
14296 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14298 unformat_input_t *i = vam->input;
14299 vl_api_ipsec_interface_add_del_spd_t *mp;
14301 u8 sw_if_index_set = 0;
14302 u32 spd_id = (u32) ~ 0;
14306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14308 if (unformat (i, "del"))
14310 else if (unformat (i, "spd_id %d", &spd_id))
14313 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14314 sw_if_index_set = 1;
14315 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14316 sw_if_index_set = 1;
14319 clib_warning ("parse error '%U'", format_unformat_error, i);
14325 if (spd_id == (u32) ~ 0)
14327 errmsg ("spd_id must be set");
14331 if (sw_if_index_set == 0)
14333 errmsg ("missing interface name or sw_if_index");
14337 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14339 mp->spd_id = ntohl (spd_id);
14340 mp->sw_if_index = ntohl (sw_if_index);
14341 mp->is_add = is_add;
14349 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14351 unformat_input_t *i = vam->input;
14352 vl_api_ipsec_spd_add_del_entry_t *mp;
14353 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14354 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14356 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14357 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14358 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14359 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14362 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14363 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14364 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14365 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14366 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14367 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14371 if (unformat (i, "del"))
14373 if (unformat (i, "outbound"))
14375 if (unformat (i, "inbound"))
14377 else if (unformat (i, "spd_id %d", &spd_id))
14379 else if (unformat (i, "sa_id %d", &sa_id))
14381 else if (unformat (i, "priority %d", &priority))
14383 else if (unformat (i, "protocol %d", &protocol))
14385 else if (unformat (i, "lport_start %d", &lport_start))
14387 else if (unformat (i, "lport_stop %d", &lport_stop))
14389 else if (unformat (i, "rport_start %d", &rport_start))
14391 else if (unformat (i, "rport_stop %d", &rport_stop))
14395 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14401 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14408 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14414 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14421 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14427 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14434 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14440 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14446 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14448 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14450 clib_warning ("unsupported action: 'resolve'");
14456 clib_warning ("parse error '%U'", format_unformat_error, i);
14462 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14464 mp->spd_id = ntohl (spd_id);
14465 mp->priority = ntohl (priority);
14466 mp->is_outbound = is_outbound;
14468 mp->is_ipv6 = is_ipv6;
14469 if (is_ipv6 || is_ip_any)
14471 clib_memcpy (mp->remote_address_start, &raddr6_start,
14472 sizeof (ip6_address_t));
14473 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14474 sizeof (ip6_address_t));
14475 clib_memcpy (mp->local_address_start, &laddr6_start,
14476 sizeof (ip6_address_t));
14477 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14478 sizeof (ip6_address_t));
14482 clib_memcpy (mp->remote_address_start, &raddr4_start,
14483 sizeof (ip4_address_t));
14484 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14485 sizeof (ip4_address_t));
14486 clib_memcpy (mp->local_address_start, &laddr4_start,
14487 sizeof (ip4_address_t));
14488 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14489 sizeof (ip4_address_t));
14491 mp->protocol = (u8) protocol;
14492 mp->local_port_start = ntohs ((u16) lport_start);
14493 mp->local_port_stop = ntohs ((u16) lport_stop);
14494 mp->remote_port_start = ntohs ((u16) rport_start);
14495 mp->remote_port_stop = ntohs ((u16) rport_stop);
14496 mp->policy = (u8) policy;
14497 mp->sa_id = ntohl (sa_id);
14498 mp->is_add = is_add;
14499 mp->is_ip_any = is_ip_any;
14506 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14508 unformat_input_t *i = vam->input;
14509 vl_api_ipsec_sad_add_del_entry_t *mp;
14510 u32 sad_id = 0, spi = 0;
14511 u8 *ck = 0, *ik = 0;
14514 u8 protocol = IPSEC_PROTOCOL_AH;
14515 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14516 u32 crypto_alg = 0, integ_alg = 0;
14517 ip4_address_t tun_src4;
14518 ip4_address_t tun_dst4;
14519 ip6_address_t tun_src6;
14520 ip6_address_t tun_dst6;
14523 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14525 if (unformat (i, "del"))
14527 else if (unformat (i, "sad_id %d", &sad_id))
14529 else if (unformat (i, "spi %d", &spi))
14531 else if (unformat (i, "esp"))
14532 protocol = IPSEC_PROTOCOL_ESP;
14533 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14536 is_tunnel_ipv6 = 0;
14538 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14541 is_tunnel_ipv6 = 0;
14543 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14546 is_tunnel_ipv6 = 1;
14548 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14551 is_tunnel_ipv6 = 1;
14555 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14557 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14558 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14560 clib_warning ("unsupported crypto-alg: '%U'",
14561 format_ipsec_crypto_alg, crypto_alg);
14565 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14569 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14571 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14572 integ_alg >= IPSEC_INTEG_N_ALG)
14574 clib_warning ("unsupported integ-alg: '%U'",
14575 format_ipsec_integ_alg, integ_alg);
14579 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14583 clib_warning ("parse error '%U'", format_unformat_error, i);
14589 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14591 mp->sad_id = ntohl (sad_id);
14592 mp->is_add = is_add;
14593 mp->protocol = protocol;
14594 mp->spi = ntohl (spi);
14595 mp->is_tunnel = is_tunnel;
14596 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14597 mp->crypto_algorithm = crypto_alg;
14598 mp->integrity_algorithm = integ_alg;
14599 mp->crypto_key_length = vec_len (ck);
14600 mp->integrity_key_length = vec_len (ik);
14602 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14603 mp->crypto_key_length = sizeof (mp->crypto_key);
14605 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14606 mp->integrity_key_length = sizeof (mp->integrity_key);
14609 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14611 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14615 if (is_tunnel_ipv6)
14617 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14618 sizeof (ip6_address_t));
14619 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14620 sizeof (ip6_address_t));
14624 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14625 sizeof (ip4_address_t));
14626 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14627 sizeof (ip4_address_t));
14637 api_ipsec_sa_set_key (vat_main_t * vam)
14639 unformat_input_t *i = vam->input;
14640 vl_api_ipsec_sa_set_key_t *mp;
14642 u8 *ck = 0, *ik = 0;
14645 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14647 if (unformat (i, "sa_id %d", &sa_id))
14649 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14651 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14655 clib_warning ("parse error '%U'", format_unformat_error, i);
14660 M (IPSEC_SA_SET_KEY, mp);
14662 mp->sa_id = ntohl (sa_id);
14663 mp->crypto_key_length = vec_len (ck);
14664 mp->integrity_key_length = vec_len (ik);
14666 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14667 mp->crypto_key_length = sizeof (mp->crypto_key);
14669 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14670 mp->integrity_key_length = sizeof (mp->integrity_key);
14673 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14675 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14683 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14685 unformat_input_t *i = vam->input;
14686 vl_api_ipsec_tunnel_if_add_del_t *mp;
14687 u32 local_spi = 0, remote_spi = 0;
14688 u32 crypto_alg = 0, integ_alg = 0;
14689 u8 *lck = NULL, *rck = NULL;
14690 u8 *lik = NULL, *rik = NULL;
14691 ip4_address_t local_ip = { {0} };
14692 ip4_address_t remote_ip = { {0} };
14695 u8 anti_replay = 0;
14698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14700 if (unformat (i, "del"))
14702 else if (unformat (i, "esn"))
14704 else if (unformat (i, "anti_replay"))
14706 else if (unformat (i, "local_spi %d", &local_spi))
14708 else if (unformat (i, "remote_spi %d", &remote_spi))
14710 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14712 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14714 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14717 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14719 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14721 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14725 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14727 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14728 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14730 errmsg ("unsupported crypto-alg: '%U'\n",
14731 format_ipsec_crypto_alg, crypto_alg);
14737 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14739 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14740 integ_alg >= IPSEC_INTEG_N_ALG)
14742 errmsg ("unsupported integ-alg: '%U'\n",
14743 format_ipsec_integ_alg, integ_alg);
14749 errmsg ("parse error '%U'\n", format_unformat_error, i);
14754 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14756 mp->is_add = is_add;
14758 mp->anti_replay = anti_replay;
14760 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14761 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14763 mp->local_spi = htonl (local_spi);
14764 mp->remote_spi = htonl (remote_spi);
14765 mp->crypto_alg = (u8) crypto_alg;
14767 mp->local_crypto_key_len = 0;
14770 mp->local_crypto_key_len = vec_len (lck);
14771 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14772 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14773 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14776 mp->remote_crypto_key_len = 0;
14779 mp->remote_crypto_key_len = vec_len (rck);
14780 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14781 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14782 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14785 mp->integ_alg = (u8) integ_alg;
14787 mp->local_integ_key_len = 0;
14790 mp->local_integ_key_len = vec_len (lik);
14791 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14792 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14793 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14796 mp->remote_integ_key_len = 0;
14799 mp->remote_integ_key_len = vec_len (rik);
14800 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14801 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14802 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14811 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14813 vat_main_t *vam = &vat_main;
14815 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14816 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14817 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14818 "tunnel_src_addr %U tunnel_dst_addr %U "
14819 "salt %u seq_outbound %lu last_seq_inbound %lu "
14820 "replay_window %lu total_data_size %lu\n",
14821 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14823 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14824 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14825 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14826 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14827 mp->tunnel_src_addr,
14828 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14829 mp->tunnel_dst_addr,
14831 clib_net_to_host_u64 (mp->seq_outbound),
14832 clib_net_to_host_u64 (mp->last_seq_inbound),
14833 clib_net_to_host_u64 (mp->replay_window),
14834 clib_net_to_host_u64 (mp->total_data_size));
14837 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14838 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14840 static void vl_api_ipsec_sa_details_t_handler_json
14841 (vl_api_ipsec_sa_details_t * mp)
14843 vat_main_t *vam = &vat_main;
14844 vat_json_node_t *node = NULL;
14845 struct in_addr src_ip4, dst_ip4;
14846 struct in6_addr src_ip6, dst_ip6;
14848 if (VAT_JSON_ARRAY != vam->json_tree.type)
14850 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14851 vat_json_init_array (&vam->json_tree);
14853 node = vat_json_array_add (&vam->json_tree);
14855 vat_json_init_object (node);
14856 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14857 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14858 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14859 vat_json_object_add_uint (node, "proto", mp->protocol);
14860 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14861 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14862 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14863 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14864 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14865 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14866 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14867 mp->crypto_key_len);
14868 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14869 mp->integ_key_len);
14870 if (mp->is_tunnel_ip6)
14872 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14873 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14874 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14875 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14879 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14880 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14881 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14882 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14884 vat_json_object_add_uint (node, "replay_window",
14885 clib_net_to_host_u64 (mp->replay_window));
14886 vat_json_object_add_uint (node, "total_data_size",
14887 clib_net_to_host_u64 (mp->total_data_size));
14892 api_ipsec_sa_dump (vat_main_t * vam)
14894 unformat_input_t *i = vam->input;
14895 vl_api_ipsec_sa_dump_t *mp;
14896 vl_api_control_ping_t *mp_ping;
14900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14902 if (unformat (i, "sa_id %d", &sa_id))
14906 clib_warning ("parse error '%U'", format_unformat_error, i);
14911 M (IPSEC_SA_DUMP, mp);
14913 mp->sa_id = ntohl (sa_id);
14917 /* Use a control ping for synchronization */
14918 M (CONTROL_PING, mp_ping);
14926 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14928 unformat_input_t *i = vam->input;
14929 vl_api_ipsec_tunnel_if_set_key_t *mp;
14930 u32 sw_if_index = ~0;
14931 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14938 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14941 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14942 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14944 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14945 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14946 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14947 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14949 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14950 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14951 else if (unformat (i, "%U", unformat_hex_string, &key))
14955 clib_warning ("parse error '%U'", format_unformat_error, i);
14960 if (sw_if_index == ~0)
14962 errmsg ("interface must be specified");
14966 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14968 errmsg ("key type must be specified");
14974 errmsg ("algorithm must be specified");
14978 if (vec_len (key) == 0)
14980 errmsg ("key must be specified");
14984 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14986 mp->sw_if_index = htonl (sw_if_index);
14988 mp->key_type = key_type;
14989 mp->key_len = vec_len (key);
14990 clib_memcpy (mp->key, key, vec_len (key));
14999 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15001 unformat_input_t *i = vam->input;
15002 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15003 u32 sw_if_index = ~0;
15005 u8 is_outbound = (u8) ~ 0;
15008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15010 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15012 else if (unformat (i, "sa_id %d", &sa_id))
15014 else if (unformat (i, "outbound"))
15016 else if (unformat (i, "inbound"))
15020 clib_warning ("parse error '%U'", format_unformat_error, i);
15025 if (sw_if_index == ~0)
15027 errmsg ("interface must be specified");
15033 errmsg ("SA ID must be specified");
15037 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15039 mp->sw_if_index = htonl (sw_if_index);
15040 mp->sa_id = htonl (sa_id);
15041 mp->is_outbound = is_outbound;
15050 api_ikev2_profile_add_del (vat_main_t * vam)
15052 unformat_input_t *i = vam->input;
15053 vl_api_ikev2_profile_add_del_t *mp;
15058 const char *valid_chars = "a-zA-Z0-9_";
15060 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15062 if (unformat (i, "del"))
15064 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15065 vec_add1 (name, 0);
15068 errmsg ("parse error '%U'", format_unformat_error, i);
15073 if (!vec_len (name))
15075 errmsg ("profile name must be specified");
15079 if (vec_len (name) > 64)
15081 errmsg ("profile name too long");
15085 M (IKEV2_PROFILE_ADD_DEL, mp);
15087 clib_memcpy (mp->name, name, vec_len (name));
15088 mp->is_add = is_add;
15097 api_ikev2_profile_set_auth (vat_main_t * vam)
15099 unformat_input_t *i = vam->input;
15100 vl_api_ikev2_profile_set_auth_t *mp;
15103 u32 auth_method = 0;
15107 const char *valid_chars = "a-zA-Z0-9_";
15109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15111 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15112 vec_add1 (name, 0);
15113 else if (unformat (i, "auth_method %U",
15114 unformat_ikev2_auth_method, &auth_method))
15116 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15118 else if (unformat (i, "auth_data %v", &data))
15122 errmsg ("parse error '%U'", format_unformat_error, i);
15127 if (!vec_len (name))
15129 errmsg ("profile name must be specified");
15133 if (vec_len (name) > 64)
15135 errmsg ("profile name too long");
15139 if (!vec_len (data))
15141 errmsg ("auth_data must be specified");
15147 errmsg ("auth_method must be specified");
15151 M (IKEV2_PROFILE_SET_AUTH, mp);
15153 mp->is_hex = is_hex;
15154 mp->auth_method = (u8) auth_method;
15155 mp->data_len = vec_len (data);
15156 clib_memcpy (mp->name, name, vec_len (name));
15157 clib_memcpy (mp->data, data, vec_len (data));
15167 api_ikev2_profile_set_id (vat_main_t * vam)
15169 unformat_input_t *i = vam->input;
15170 vl_api_ikev2_profile_set_id_t *mp;
15178 const char *valid_chars = "a-zA-Z0-9_";
15180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15182 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15183 vec_add1 (name, 0);
15184 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15186 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15188 data = vec_new (u8, 4);
15189 clib_memcpy (data, ip4.as_u8, 4);
15191 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15193 else if (unformat (i, "id_data %v", &data))
15195 else if (unformat (i, "local"))
15197 else if (unformat (i, "remote"))
15201 errmsg ("parse error '%U'", format_unformat_error, i);
15206 if (!vec_len (name))
15208 errmsg ("profile name must be specified");
15212 if (vec_len (name) > 64)
15214 errmsg ("profile name too long");
15218 if (!vec_len (data))
15220 errmsg ("id_data must be specified");
15226 errmsg ("id_type must be specified");
15230 M (IKEV2_PROFILE_SET_ID, mp);
15232 mp->is_local = is_local;
15233 mp->id_type = (u8) id_type;
15234 mp->data_len = vec_len (data);
15235 clib_memcpy (mp->name, name, vec_len (name));
15236 clib_memcpy (mp->data, data, vec_len (data));
15246 api_ikev2_profile_set_ts (vat_main_t * vam)
15248 unformat_input_t *i = vam->input;
15249 vl_api_ikev2_profile_set_ts_t *mp;
15252 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15253 ip4_address_t start_addr, end_addr;
15255 const char *valid_chars = "a-zA-Z0-9_";
15258 start_addr.as_u32 = 0;
15259 end_addr.as_u32 = (u32) ~ 0;
15261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15263 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15264 vec_add1 (name, 0);
15265 else if (unformat (i, "protocol %d", &proto))
15267 else if (unformat (i, "start_port %d", &start_port))
15269 else if (unformat (i, "end_port %d", &end_port))
15272 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15274 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15276 else if (unformat (i, "local"))
15278 else if (unformat (i, "remote"))
15282 errmsg ("parse error '%U'", format_unformat_error, i);
15287 if (!vec_len (name))
15289 errmsg ("profile name must be specified");
15293 if (vec_len (name) > 64)
15295 errmsg ("profile name too long");
15299 M (IKEV2_PROFILE_SET_TS, mp);
15301 mp->is_local = is_local;
15302 mp->proto = (u8) proto;
15303 mp->start_port = (u16) start_port;
15304 mp->end_port = (u16) end_port;
15305 mp->start_addr = start_addr.as_u32;
15306 mp->end_addr = end_addr.as_u32;
15307 clib_memcpy (mp->name, name, vec_len (name));
15316 api_ikev2_set_local_key (vat_main_t * vam)
15318 unformat_input_t *i = vam->input;
15319 vl_api_ikev2_set_local_key_t *mp;
15323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15325 if (unformat (i, "file %v", &file))
15326 vec_add1 (file, 0);
15329 errmsg ("parse error '%U'", format_unformat_error, i);
15334 if (!vec_len (file))
15336 errmsg ("RSA key file must be specified");
15340 if (vec_len (file) > 256)
15342 errmsg ("file name too long");
15346 M (IKEV2_SET_LOCAL_KEY, mp);
15348 clib_memcpy (mp->key_file, file, vec_len (file));
15357 api_ikev2_set_responder (vat_main_t * vam)
15359 unformat_input_t *i = vam->input;
15360 vl_api_ikev2_set_responder_t *mp;
15363 u32 sw_if_index = ~0;
15364 ip4_address_t address;
15366 const char *valid_chars = "a-zA-Z0-9_";
15368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15371 (i, "%U interface %d address %U", unformat_token, valid_chars,
15372 &name, &sw_if_index, unformat_ip4_address, &address))
15373 vec_add1 (name, 0);
15376 errmsg ("parse error '%U'", format_unformat_error, i);
15381 if (!vec_len (name))
15383 errmsg ("profile name must be specified");
15387 if (vec_len (name) > 64)
15389 errmsg ("profile name too long");
15393 M (IKEV2_SET_RESPONDER, mp);
15395 clib_memcpy (mp->name, name, vec_len (name));
15398 mp->sw_if_index = sw_if_index;
15399 clib_memcpy (mp->address, &address, sizeof (address));
15407 api_ikev2_set_ike_transforms (vat_main_t * vam)
15409 unformat_input_t *i = vam->input;
15410 vl_api_ikev2_set_ike_transforms_t *mp;
15413 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15415 const char *valid_chars = "a-zA-Z0-9_";
15417 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15419 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15420 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15421 vec_add1 (name, 0);
15424 errmsg ("parse error '%U'", format_unformat_error, i);
15429 if (!vec_len (name))
15431 errmsg ("profile name must be specified");
15435 if (vec_len (name) > 64)
15437 errmsg ("profile name too long");
15441 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15443 clib_memcpy (mp->name, name, vec_len (name));
15445 mp->crypto_alg = crypto_alg;
15446 mp->crypto_key_size = crypto_key_size;
15447 mp->integ_alg = integ_alg;
15448 mp->dh_group = dh_group;
15457 api_ikev2_set_esp_transforms (vat_main_t * vam)
15459 unformat_input_t *i = vam->input;
15460 vl_api_ikev2_set_esp_transforms_t *mp;
15463 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15465 const char *valid_chars = "a-zA-Z0-9_";
15467 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15469 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15470 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15471 vec_add1 (name, 0);
15474 errmsg ("parse error '%U'", format_unformat_error, i);
15479 if (!vec_len (name))
15481 errmsg ("profile name must be specified");
15485 if (vec_len (name) > 64)
15487 errmsg ("profile name too long");
15491 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15493 clib_memcpy (mp->name, name, vec_len (name));
15495 mp->crypto_alg = crypto_alg;
15496 mp->crypto_key_size = crypto_key_size;
15497 mp->integ_alg = integ_alg;
15498 mp->dh_group = dh_group;
15506 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15508 unformat_input_t *i = vam->input;
15509 vl_api_ikev2_set_sa_lifetime_t *mp;
15512 u64 lifetime, lifetime_maxdata;
15513 u32 lifetime_jitter, handover;
15515 const char *valid_chars = "a-zA-Z0-9_";
15517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15519 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15520 &lifetime, &lifetime_jitter, &handover,
15521 &lifetime_maxdata))
15522 vec_add1 (name, 0);
15525 errmsg ("parse error '%U'", format_unformat_error, i);
15530 if (!vec_len (name))
15532 errmsg ("profile name must be specified");
15536 if (vec_len (name) > 64)
15538 errmsg ("profile name too long");
15542 M (IKEV2_SET_SA_LIFETIME, mp);
15544 clib_memcpy (mp->name, name, vec_len (name));
15546 mp->lifetime = lifetime;
15547 mp->lifetime_jitter = lifetime_jitter;
15548 mp->handover = handover;
15549 mp->lifetime_maxdata = lifetime_maxdata;
15557 api_ikev2_initiate_sa_init (vat_main_t * vam)
15559 unformat_input_t *i = vam->input;
15560 vl_api_ikev2_initiate_sa_init_t *mp;
15564 const char *valid_chars = "a-zA-Z0-9_";
15566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15568 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15569 vec_add1 (name, 0);
15572 errmsg ("parse error '%U'", format_unformat_error, i);
15577 if (!vec_len (name))
15579 errmsg ("profile name must be specified");
15583 if (vec_len (name) > 64)
15585 errmsg ("profile name too long");
15589 M (IKEV2_INITIATE_SA_INIT, mp);
15591 clib_memcpy (mp->name, name, vec_len (name));
15600 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15602 unformat_input_t *i = vam->input;
15603 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15610 if (unformat (i, "%lx", &ispi))
15614 errmsg ("parse error '%U'", format_unformat_error, i);
15619 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15629 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15631 unformat_input_t *i = vam->input;
15632 vl_api_ikev2_initiate_del_child_sa_t *mp;
15637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15639 if (unformat (i, "%x", &ispi))
15643 errmsg ("parse error '%U'", format_unformat_error, i);
15648 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15658 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15660 unformat_input_t *i = vam->input;
15661 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15668 if (unformat (i, "%x", &ispi))
15672 errmsg ("parse error '%U'", format_unformat_error, i);
15677 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15690 api_map_add_domain (vat_main_t * vam)
15692 unformat_input_t *i = vam->input;
15693 vl_api_map_add_domain_t *mp;
15695 ip4_address_t ip4_prefix;
15696 ip6_address_t ip6_prefix;
15697 ip6_address_t ip6_src;
15698 u32 num_m_args = 0;
15699 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15700 0, psid_length = 0;
15701 u8 is_translation = 0;
15703 u32 ip6_src_len = 128;
15706 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15708 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15709 &ip4_prefix, &ip4_prefix_len))
15711 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15712 &ip6_prefix, &ip6_prefix_len))
15716 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15719 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15721 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15723 else if (unformat (i, "psid-offset %d", &psid_offset))
15725 else if (unformat (i, "psid-len %d", &psid_length))
15727 else if (unformat (i, "mtu %d", &mtu))
15729 else if (unformat (i, "map-t"))
15730 is_translation = 1;
15733 clib_warning ("parse error '%U'", format_unformat_error, i);
15738 if (num_m_args < 3)
15740 errmsg ("mandatory argument(s) missing");
15744 /* Construct the API message */
15745 M (MAP_ADD_DOMAIN, mp);
15747 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15748 mp->ip4_prefix_len = ip4_prefix_len;
15750 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15751 mp->ip6_prefix_len = ip6_prefix_len;
15753 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15754 mp->ip6_src_prefix_len = ip6_src_len;
15756 mp->ea_bits_len = ea_bits_len;
15757 mp->psid_offset = psid_offset;
15758 mp->psid_length = psid_length;
15759 mp->is_translation = is_translation;
15760 mp->mtu = htons (mtu);
15765 /* Wait for a reply, return good/bad news */
15771 api_map_del_domain (vat_main_t * vam)
15773 unformat_input_t *i = vam->input;
15774 vl_api_map_del_domain_t *mp;
15776 u32 num_m_args = 0;
15780 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15782 if (unformat (i, "index %d", &index))
15786 clib_warning ("parse error '%U'", format_unformat_error, i);
15791 if (num_m_args != 1)
15793 errmsg ("mandatory argument(s) missing");
15797 /* Construct the API message */
15798 M (MAP_DEL_DOMAIN, mp);
15800 mp->index = ntohl (index);
15805 /* Wait for a reply, return good/bad news */
15811 api_map_add_del_rule (vat_main_t * vam)
15813 unformat_input_t *i = vam->input;
15814 vl_api_map_add_del_rule_t *mp;
15816 ip6_address_t ip6_dst;
15817 u32 num_m_args = 0, index, psid = 0;
15820 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15822 if (unformat (i, "index %d", &index))
15824 else if (unformat (i, "psid %d", &psid))
15826 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15828 else if (unformat (i, "del"))
15834 clib_warning ("parse error '%U'", format_unformat_error, i);
15839 /* Construct the API message */
15840 M (MAP_ADD_DEL_RULE, mp);
15842 mp->index = ntohl (index);
15843 mp->is_add = is_add;
15844 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15845 mp->psid = ntohs (psid);
15850 /* Wait for a reply, return good/bad news */
15856 api_map_domain_dump (vat_main_t * vam)
15858 vl_api_map_domain_dump_t *mp;
15859 vl_api_control_ping_t *mp_ping;
15862 /* Construct the API message */
15863 M (MAP_DOMAIN_DUMP, mp);
15868 /* Use a control ping for synchronization */
15869 MPING (CONTROL_PING, mp_ping);
15877 api_map_rule_dump (vat_main_t * vam)
15879 unformat_input_t *i = vam->input;
15880 vl_api_map_rule_dump_t *mp;
15881 vl_api_control_ping_t *mp_ping;
15882 u32 domain_index = ~0;
15885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15887 if (unformat (i, "index %u", &domain_index))
15893 if (domain_index == ~0)
15895 clib_warning ("parse error: domain index expected");
15899 /* Construct the API message */
15900 M (MAP_RULE_DUMP, mp);
15902 mp->domain_index = htonl (domain_index);
15907 /* Use a control ping for synchronization */
15908 MPING (CONTROL_PING, mp_ping);
15915 static void vl_api_map_add_domain_reply_t_handler
15916 (vl_api_map_add_domain_reply_t * mp)
15918 vat_main_t *vam = &vat_main;
15919 i32 retval = ntohl (mp->retval);
15921 if (vam->async_mode)
15923 vam->async_errors += (retval < 0);
15927 vam->retval = retval;
15928 vam->result_ready = 1;
15932 static void vl_api_map_add_domain_reply_t_handler_json
15933 (vl_api_map_add_domain_reply_t * mp)
15935 vat_main_t *vam = &vat_main;
15936 vat_json_node_t node;
15938 vat_json_init_object (&node);
15939 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15940 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15942 vat_json_print (vam->ofp, &node);
15943 vat_json_free (&node);
15945 vam->retval = ntohl (mp->retval);
15946 vam->result_ready = 1;
15950 api_get_first_msg_id (vat_main_t * vam)
15952 vl_api_get_first_msg_id_t *mp;
15953 unformat_input_t *i = vam->input;
15958 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15960 if (unformat (i, "client %s", &name))
15968 errmsg ("missing client name");
15971 vec_add1 (name, 0);
15973 if (vec_len (name) > 63)
15975 errmsg ("client name too long");
15979 M (GET_FIRST_MSG_ID, mp);
15980 clib_memcpy (mp->name, name, vec_len (name));
15987 api_cop_interface_enable_disable (vat_main_t * vam)
15989 unformat_input_t *line_input = vam->input;
15990 vl_api_cop_interface_enable_disable_t *mp;
15991 u32 sw_if_index = ~0;
15992 u8 enable_disable = 1;
15995 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15997 if (unformat (line_input, "disable"))
15998 enable_disable = 0;
15999 if (unformat (line_input, "enable"))
16000 enable_disable = 1;
16001 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16002 vam, &sw_if_index))
16004 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16010 if (sw_if_index == ~0)
16012 errmsg ("missing interface name or sw_if_index");
16016 /* Construct the API message */
16017 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16018 mp->sw_if_index = ntohl (sw_if_index);
16019 mp->enable_disable = enable_disable;
16023 /* Wait for the reply */
16029 api_cop_whitelist_enable_disable (vat_main_t * vam)
16031 unformat_input_t *line_input = vam->input;
16032 vl_api_cop_whitelist_enable_disable_t *mp;
16033 u32 sw_if_index = ~0;
16034 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16038 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16040 if (unformat (line_input, "ip4"))
16042 else if (unformat (line_input, "ip6"))
16044 else if (unformat (line_input, "default"))
16046 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16047 vam, &sw_if_index))
16049 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16051 else if (unformat (line_input, "fib-id %d", &fib_id))
16057 if (sw_if_index == ~0)
16059 errmsg ("missing interface name or sw_if_index");
16063 /* Construct the API message */
16064 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16065 mp->sw_if_index = ntohl (sw_if_index);
16066 mp->fib_id = ntohl (fib_id);
16069 mp->default_cop = default_cop;
16073 /* Wait for the reply */
16079 api_get_node_graph (vat_main_t * vam)
16081 vl_api_get_node_graph_t *mp;
16084 M (GET_NODE_GRAPH, mp);
16088 /* Wait for the reply */
16094 /** Used for parsing LISP eids */
16095 typedef CLIB_PACKED(struct{
16096 u8 addr[16]; /**< eid address */
16097 u32 len; /**< prefix length if IP */
16098 u8 type; /**< type of eid */
16103 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16105 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16107 memset (a, 0, sizeof (a[0]));
16109 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16111 a->type = 0; /* ipv4 type */
16113 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16115 a->type = 1; /* ipv6 type */
16117 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16119 a->type = 2; /* mac type */
16121 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16123 a->type = 3; /* NSH type */
16124 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16125 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16132 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16141 lisp_eid_size_vat (u8 type)
16158 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16160 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16164 api_one_add_del_locator_set (vat_main_t * vam)
16166 unformat_input_t *input = vam->input;
16167 vl_api_one_add_del_locator_set_t *mp;
16169 u8 *locator_set_name = NULL;
16170 u8 locator_set_name_set = 0;
16171 vl_api_local_locator_t locator, *locators = 0;
16172 u32 sw_if_index, priority, weight;
16176 /* Parse args required to build the message */
16177 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16179 if (unformat (input, "del"))
16183 else if (unformat (input, "locator-set %s", &locator_set_name))
16185 locator_set_name_set = 1;
16187 else if (unformat (input, "sw_if_index %u p %u w %u",
16188 &sw_if_index, &priority, &weight))
16190 locator.sw_if_index = htonl (sw_if_index);
16191 locator.priority = priority;
16192 locator.weight = weight;
16193 vec_add1 (locators, locator);
16197 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16198 &sw_if_index, &priority, &weight))
16200 locator.sw_if_index = htonl (sw_if_index);
16201 locator.priority = priority;
16202 locator.weight = weight;
16203 vec_add1 (locators, locator);
16209 if (locator_set_name_set == 0)
16211 errmsg ("missing locator-set name");
16212 vec_free (locators);
16216 if (vec_len (locator_set_name) > 64)
16218 errmsg ("locator-set name too long");
16219 vec_free (locator_set_name);
16220 vec_free (locators);
16223 vec_add1 (locator_set_name, 0);
16225 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16227 /* Construct the API message */
16228 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16230 mp->is_add = is_add;
16231 clib_memcpy (mp->locator_set_name, locator_set_name,
16232 vec_len (locator_set_name));
16233 vec_free (locator_set_name);
16235 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16237 clib_memcpy (mp->locators, locators, data_len);
16238 vec_free (locators);
16243 /* Wait for a reply... */
16248 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16251 api_one_add_del_locator (vat_main_t * vam)
16253 unformat_input_t *input = vam->input;
16254 vl_api_one_add_del_locator_t *mp;
16255 u32 tmp_if_index = ~0;
16256 u32 sw_if_index = ~0;
16257 u8 sw_if_index_set = 0;
16258 u8 sw_if_index_if_name_set = 0;
16260 u8 priority_set = 0;
16264 u8 *locator_set_name = NULL;
16265 u8 locator_set_name_set = 0;
16268 /* Parse args required to build the message */
16269 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16271 if (unformat (input, "del"))
16275 else if (unformat (input, "locator-set %s", &locator_set_name))
16277 locator_set_name_set = 1;
16279 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16282 sw_if_index_if_name_set = 1;
16283 sw_if_index = tmp_if_index;
16285 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16287 sw_if_index_set = 1;
16288 sw_if_index = tmp_if_index;
16290 else if (unformat (input, "p %d", &priority))
16294 else if (unformat (input, "w %d", &weight))
16302 if (locator_set_name_set == 0)
16304 errmsg ("missing locator-set name");
16308 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16310 errmsg ("missing sw_if_index");
16311 vec_free (locator_set_name);
16315 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16317 errmsg ("cannot use both params interface name and sw_if_index");
16318 vec_free (locator_set_name);
16322 if (priority_set == 0)
16324 errmsg ("missing locator-set priority");
16325 vec_free (locator_set_name);
16329 if (weight_set == 0)
16331 errmsg ("missing locator-set weight");
16332 vec_free (locator_set_name);
16336 if (vec_len (locator_set_name) > 64)
16338 errmsg ("locator-set name too long");
16339 vec_free (locator_set_name);
16342 vec_add1 (locator_set_name, 0);
16344 /* Construct the API message */
16345 M (ONE_ADD_DEL_LOCATOR, mp);
16347 mp->is_add = is_add;
16348 mp->sw_if_index = ntohl (sw_if_index);
16349 mp->priority = priority;
16350 mp->weight = weight;
16351 clib_memcpy (mp->locator_set_name, locator_set_name,
16352 vec_len (locator_set_name));
16353 vec_free (locator_set_name);
16358 /* Wait for a reply... */
16363 #define api_lisp_add_del_locator api_one_add_del_locator
16366 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16368 u32 *key_id = va_arg (*args, u32 *);
16371 if (unformat (input, "%s", &s))
16373 if (!strcmp ((char *) s, "sha1"))
16374 key_id[0] = HMAC_SHA_1_96;
16375 else if (!strcmp ((char *) s, "sha256"))
16376 key_id[0] = HMAC_SHA_256_128;
16379 clib_warning ("invalid key_id: '%s'", s);
16380 key_id[0] = HMAC_NO_KEY;
16391 api_one_add_del_local_eid (vat_main_t * vam)
16393 unformat_input_t *input = vam->input;
16394 vl_api_one_add_del_local_eid_t *mp;
16397 lisp_eid_vat_t _eid, *eid = &_eid;
16398 u8 *locator_set_name = 0;
16399 u8 locator_set_name_set = 0;
16405 /* Parse args required to build the message */
16406 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16408 if (unformat (input, "del"))
16412 else if (unformat (input, "vni %d", &vni))
16416 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16420 else if (unformat (input, "locator-set %s", &locator_set_name))
16422 locator_set_name_set = 1;
16424 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16426 else if (unformat (input, "secret-key %_%v%_", &key))
16432 if (locator_set_name_set == 0)
16434 errmsg ("missing locator-set name");
16440 errmsg ("EID address not set!");
16441 vec_free (locator_set_name);
16445 if (key && (0 == key_id))
16447 errmsg ("invalid key_id!");
16451 if (vec_len (key) > 64)
16453 errmsg ("key too long");
16458 if (vec_len (locator_set_name) > 64)
16460 errmsg ("locator-set name too long");
16461 vec_free (locator_set_name);
16464 vec_add1 (locator_set_name, 0);
16466 /* Construct the API message */
16467 M (ONE_ADD_DEL_LOCAL_EID, mp);
16469 mp->is_add = is_add;
16470 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16471 mp->eid_type = eid->type;
16472 mp->prefix_len = eid->len;
16473 mp->vni = clib_host_to_net_u32 (vni);
16474 mp->key_id = clib_host_to_net_u16 (key_id);
16475 clib_memcpy (mp->locator_set_name, locator_set_name,
16476 vec_len (locator_set_name));
16477 clib_memcpy (mp->key, key, vec_len (key));
16479 vec_free (locator_set_name);
16485 /* Wait for a reply... */
16490 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16493 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16495 u32 dp_table = 0, vni = 0;;
16496 unformat_input_t *input = vam->input;
16497 vl_api_gpe_add_del_fwd_entry_t *mp;
16499 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16500 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16501 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16502 u32 action = ~0, w;
16503 ip4_address_t rmt_rloc4, lcl_rloc4;
16504 ip6_address_t rmt_rloc6, lcl_rloc6;
16505 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16508 memset (&rloc, 0, sizeof (rloc));
16510 /* Parse args required to build the message */
16511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16513 if (unformat (input, "del"))
16515 else if (unformat (input, "add"))
16517 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16521 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16525 else if (unformat (input, "vrf %d", &dp_table))
16527 else if (unformat (input, "bd %d", &dp_table))
16529 else if (unformat (input, "vni %d", &vni))
16531 else if (unformat (input, "w %d", &w))
16535 errmsg ("No RLOC configured for setting priority/weight!");
16538 curr_rloc->weight = w;
16540 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16541 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16545 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16547 vec_add1 (lcl_locs, rloc);
16549 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16550 vec_add1 (rmt_locs, rloc);
16551 /* weight saved in rmt loc */
16552 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16554 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16555 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16558 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16560 vec_add1 (lcl_locs, rloc);
16562 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16563 vec_add1 (rmt_locs, rloc);
16564 /* weight saved in rmt loc */
16565 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16567 else if (unformat (input, "action %d", &action))
16573 clib_warning ("parse error '%U'", format_unformat_error, input);
16580 errmsg ("remote eid addresses not set");
16584 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16586 errmsg ("eid types don't match");
16590 if (0 == rmt_locs && (u32) ~ 0 == action)
16592 errmsg ("action not set for negative mapping");
16596 /* Construct the API message */
16597 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16598 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16600 mp->is_add = is_add;
16601 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16602 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16603 mp->eid_type = rmt_eid->type;
16604 mp->dp_table = clib_host_to_net_u32 (dp_table);
16605 mp->vni = clib_host_to_net_u32 (vni);
16606 mp->rmt_len = rmt_eid->len;
16607 mp->lcl_len = lcl_eid->len;
16608 mp->action = action;
16610 if (0 != rmt_locs && 0 != lcl_locs)
16612 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16613 clib_memcpy (mp->locs, lcl_locs,
16614 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16616 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16617 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16618 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16620 vec_free (lcl_locs);
16621 vec_free (rmt_locs);
16626 /* Wait for a reply... */
16632 api_one_add_del_map_server (vat_main_t * vam)
16634 unformat_input_t *input = vam->input;
16635 vl_api_one_add_del_map_server_t *mp;
16639 ip4_address_t ipv4;
16640 ip6_address_t ipv6;
16643 /* Parse args required to build the message */
16644 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16646 if (unformat (input, "del"))
16650 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16654 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16662 if (ipv4_set && ipv6_set)
16664 errmsg ("both eid v4 and v6 addresses set");
16668 if (!ipv4_set && !ipv6_set)
16670 errmsg ("eid addresses not set");
16674 /* Construct the API message */
16675 M (ONE_ADD_DEL_MAP_SERVER, mp);
16677 mp->is_add = is_add;
16681 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16686 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16692 /* Wait for a reply... */
16697 #define api_lisp_add_del_map_server api_one_add_del_map_server
16700 api_one_add_del_map_resolver (vat_main_t * vam)
16702 unformat_input_t *input = vam->input;
16703 vl_api_one_add_del_map_resolver_t *mp;
16707 ip4_address_t ipv4;
16708 ip6_address_t ipv6;
16711 /* Parse args required to build the message */
16712 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16714 if (unformat (input, "del"))
16718 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16722 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16730 if (ipv4_set && ipv6_set)
16732 errmsg ("both eid v4 and v6 addresses set");
16736 if (!ipv4_set && !ipv6_set)
16738 errmsg ("eid addresses not set");
16742 /* Construct the API message */
16743 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16745 mp->is_add = is_add;
16749 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16754 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16760 /* Wait for a reply... */
16765 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16768 api_lisp_gpe_enable_disable (vat_main_t * vam)
16770 unformat_input_t *input = vam->input;
16771 vl_api_gpe_enable_disable_t *mp;
16776 /* Parse args required to build the message */
16777 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16779 if (unformat (input, "enable"))
16784 else if (unformat (input, "disable"))
16795 errmsg ("Value not set");
16799 /* Construct the API message */
16800 M (GPE_ENABLE_DISABLE, mp);
16807 /* Wait for a reply... */
16813 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16815 unformat_input_t *input = vam->input;
16816 vl_api_one_rloc_probe_enable_disable_t *mp;
16821 /* Parse args required to build the message */
16822 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16824 if (unformat (input, "enable"))
16829 else if (unformat (input, "disable"))
16837 errmsg ("Value not set");
16841 /* Construct the API message */
16842 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16844 mp->is_enabled = is_en;
16849 /* Wait for a reply... */
16854 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16857 api_one_map_register_enable_disable (vat_main_t * vam)
16859 unformat_input_t *input = vam->input;
16860 vl_api_one_map_register_enable_disable_t *mp;
16865 /* Parse args required to build the message */
16866 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16868 if (unformat (input, "enable"))
16873 else if (unformat (input, "disable"))
16881 errmsg ("Value not set");
16885 /* Construct the API message */
16886 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16888 mp->is_enabled = is_en;
16893 /* Wait for a reply... */
16898 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16901 api_one_enable_disable (vat_main_t * vam)
16903 unformat_input_t *input = vam->input;
16904 vl_api_one_enable_disable_t *mp;
16909 /* Parse args required to build the message */
16910 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16912 if (unformat (input, "enable"))
16917 else if (unformat (input, "disable"))
16927 errmsg ("Value not set");
16931 /* Construct the API message */
16932 M (ONE_ENABLE_DISABLE, mp);
16939 /* Wait for a reply... */
16944 #define api_lisp_enable_disable api_one_enable_disable
16947 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16949 unformat_input_t *input = vam->input;
16950 vl_api_one_enable_disable_xtr_mode_t *mp;
16955 /* Parse args required to build the message */
16956 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16958 if (unformat (input, "enable"))
16963 else if (unformat (input, "disable"))
16973 errmsg ("Value not set");
16977 /* Construct the API message */
16978 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16985 /* Wait for a reply... */
16991 api_one_show_xtr_mode (vat_main_t * vam)
16993 vl_api_one_show_xtr_mode_t *mp;
16996 /* Construct the API message */
16997 M (ONE_SHOW_XTR_MODE, mp);
17002 /* Wait for a reply... */
17008 api_one_enable_disable_pitr_mode (vat_main_t * vam)
17010 unformat_input_t *input = vam->input;
17011 vl_api_one_enable_disable_pitr_mode_t *mp;
17016 /* Parse args required to build the message */
17017 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17019 if (unformat (input, "enable"))
17024 else if (unformat (input, "disable"))
17034 errmsg ("Value not set");
17038 /* Construct the API message */
17039 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17046 /* Wait for a reply... */
17052 api_one_show_pitr_mode (vat_main_t * vam)
17054 vl_api_one_show_pitr_mode_t *mp;
17057 /* Construct the API message */
17058 M (ONE_SHOW_PITR_MODE, mp);
17063 /* Wait for a reply... */
17069 api_one_enable_disable_petr_mode (vat_main_t * vam)
17071 unformat_input_t *input = vam->input;
17072 vl_api_one_enable_disable_petr_mode_t *mp;
17077 /* Parse args required to build the message */
17078 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17080 if (unformat (input, "enable"))
17085 else if (unformat (input, "disable"))
17095 errmsg ("Value not set");
17099 /* Construct the API message */
17100 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17107 /* Wait for a reply... */
17113 api_one_show_petr_mode (vat_main_t * vam)
17115 vl_api_one_show_petr_mode_t *mp;
17118 /* Construct the API message */
17119 M (ONE_SHOW_PETR_MODE, mp);
17124 /* Wait for a reply... */
17130 api_show_one_map_register_state (vat_main_t * vam)
17132 vl_api_show_one_map_register_state_t *mp;
17135 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17140 /* wait for reply */
17145 #define api_show_lisp_map_register_state api_show_one_map_register_state
17148 api_show_one_rloc_probe_state (vat_main_t * vam)
17150 vl_api_show_one_rloc_probe_state_t *mp;
17153 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17158 /* wait for reply */
17163 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17166 api_one_add_del_ndp_entry (vat_main_t * vam)
17168 vl_api_one_add_del_ndp_entry_t *mp;
17169 unformat_input_t *input = vam->input;
17174 u8 mac[6] = { 0, };
17175 u8 ip6[16] = { 0, };
17179 /* Parse args required to build the message */
17180 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17182 if (unformat (input, "del"))
17184 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17186 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17188 else if (unformat (input, "bd %d", &bd))
17192 errmsg ("parse error '%U'", format_unformat_error, input);
17197 if (!bd_set || !ip_set || (!mac_set && is_add))
17199 errmsg ("Missing BD, IP or MAC!");
17203 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17204 mp->is_add = is_add;
17205 clib_memcpy (mp->mac, mac, 6);
17206 mp->bd = clib_host_to_net_u32 (bd);
17207 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17212 /* wait for reply */
17218 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17220 vl_api_one_add_del_l2_arp_entry_t *mp;
17221 unformat_input_t *input = vam->input;
17226 u8 mac[6] = { 0, };
17227 u32 ip4 = 0, bd = ~0;
17230 /* Parse args required to build the message */
17231 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17233 if (unformat (input, "del"))
17235 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17237 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17239 else if (unformat (input, "bd %d", &bd))
17243 errmsg ("parse error '%U'", format_unformat_error, input);
17248 if (!bd_set || !ip_set || (!mac_set && is_add))
17250 errmsg ("Missing BD, IP or MAC!");
17254 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17255 mp->is_add = is_add;
17256 clib_memcpy (mp->mac, mac, 6);
17257 mp->bd = clib_host_to_net_u32 (bd);
17263 /* wait for reply */
17269 api_one_ndp_bd_get (vat_main_t * vam)
17271 vl_api_one_ndp_bd_get_t *mp;
17274 M (ONE_NDP_BD_GET, mp);
17279 /* wait for reply */
17285 api_one_ndp_entries_get (vat_main_t * vam)
17287 vl_api_one_ndp_entries_get_t *mp;
17288 unformat_input_t *input = vam->input;
17293 /* Parse args required to build the message */
17294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17296 if (unformat (input, "bd %d", &bd))
17300 errmsg ("parse error '%U'", format_unformat_error, input);
17307 errmsg ("Expected bridge domain!");
17311 M (ONE_NDP_ENTRIES_GET, mp);
17312 mp->bd = clib_host_to_net_u32 (bd);
17317 /* wait for reply */
17323 api_one_l2_arp_bd_get (vat_main_t * vam)
17325 vl_api_one_l2_arp_bd_get_t *mp;
17328 M (ONE_L2_ARP_BD_GET, mp);
17333 /* wait for reply */
17339 api_one_l2_arp_entries_get (vat_main_t * vam)
17341 vl_api_one_l2_arp_entries_get_t *mp;
17342 unformat_input_t *input = vam->input;
17347 /* Parse args required to build the message */
17348 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17350 if (unformat (input, "bd %d", &bd))
17354 errmsg ("parse error '%U'", format_unformat_error, input);
17361 errmsg ("Expected bridge domain!");
17365 M (ONE_L2_ARP_ENTRIES_GET, mp);
17366 mp->bd = clib_host_to_net_u32 (bd);
17371 /* wait for reply */
17377 api_one_stats_enable_disable (vat_main_t * vam)
17379 vl_api_one_stats_enable_disable_t *mp;
17380 unformat_input_t *input = vam->input;
17385 /* Parse args required to build the message */
17386 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17388 if (unformat (input, "enable"))
17393 else if (unformat (input, "disable"))
17403 errmsg ("Value not set");
17407 M (ONE_STATS_ENABLE_DISABLE, mp);
17413 /* wait for reply */
17419 api_show_one_stats_enable_disable (vat_main_t * vam)
17421 vl_api_show_one_stats_enable_disable_t *mp;
17424 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17429 /* wait for reply */
17435 api_show_one_map_request_mode (vat_main_t * vam)
17437 vl_api_show_one_map_request_mode_t *mp;
17440 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17445 /* wait for reply */
17450 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17453 api_one_map_request_mode (vat_main_t * vam)
17455 unformat_input_t *input = vam->input;
17456 vl_api_one_map_request_mode_t *mp;
17460 /* Parse args required to build the message */
17461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17463 if (unformat (input, "dst-only"))
17465 else if (unformat (input, "src-dst"))
17469 errmsg ("parse error '%U'", format_unformat_error, input);
17474 M (ONE_MAP_REQUEST_MODE, mp);
17481 /* wait for reply */
17486 #define api_lisp_map_request_mode api_one_map_request_mode
17489 * Enable/disable ONE proxy ITR.
17491 * @param vam vpp API test context
17492 * @return return code
17495 api_one_pitr_set_locator_set (vat_main_t * vam)
17497 u8 ls_name_set = 0;
17498 unformat_input_t *input = vam->input;
17499 vl_api_one_pitr_set_locator_set_t *mp;
17504 /* Parse args required to build the message */
17505 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17507 if (unformat (input, "del"))
17509 else if (unformat (input, "locator-set %s", &ls_name))
17513 errmsg ("parse error '%U'", format_unformat_error, input);
17520 errmsg ("locator-set name not set!");
17524 M (ONE_PITR_SET_LOCATOR_SET, mp);
17526 mp->is_add = is_add;
17527 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17528 vec_free (ls_name);
17533 /* wait for reply */
17538 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17541 api_one_nsh_set_locator_set (vat_main_t * vam)
17543 u8 ls_name_set = 0;
17544 unformat_input_t *input = vam->input;
17545 vl_api_one_nsh_set_locator_set_t *mp;
17550 /* Parse args required to build the message */
17551 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17553 if (unformat (input, "del"))
17555 else if (unformat (input, "ls %s", &ls_name))
17559 errmsg ("parse error '%U'", format_unformat_error, input);
17564 if (!ls_name_set && is_add)
17566 errmsg ("locator-set name not set!");
17570 M (ONE_NSH_SET_LOCATOR_SET, mp);
17572 mp->is_add = is_add;
17573 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17574 vec_free (ls_name);
17579 /* wait for reply */
17585 api_show_one_pitr (vat_main_t * vam)
17587 vl_api_show_one_pitr_t *mp;
17590 if (!vam->json_output)
17592 print (vam->ofp, "%=20s", "lisp status:");
17595 M (SHOW_ONE_PITR, mp);
17599 /* Wait for a reply... */
17604 #define api_show_lisp_pitr api_show_one_pitr
17607 api_one_use_petr (vat_main_t * vam)
17609 unformat_input_t *input = vam->input;
17610 vl_api_one_use_petr_t *mp;
17615 memset (&ip, 0, sizeof (ip));
17617 /* Parse args required to build the message */
17618 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17620 if (unformat (input, "disable"))
17623 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17626 ip_addr_version (&ip) = IP4;
17629 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17632 ip_addr_version (&ip) = IP6;
17636 errmsg ("parse error '%U'", format_unformat_error, input);
17641 M (ONE_USE_PETR, mp);
17643 mp->is_add = is_add;
17646 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17648 clib_memcpy (mp->address, &ip, 4);
17650 clib_memcpy (mp->address, &ip, 16);
17656 /* wait for reply */
17661 #define api_lisp_use_petr api_one_use_petr
17664 api_show_one_nsh_mapping (vat_main_t * vam)
17666 vl_api_show_one_use_petr_t *mp;
17669 if (!vam->json_output)
17671 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17674 M (SHOW_ONE_NSH_MAPPING, mp);
17678 /* Wait for a reply... */
17684 api_show_one_use_petr (vat_main_t * vam)
17686 vl_api_show_one_use_petr_t *mp;
17689 if (!vam->json_output)
17691 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17694 M (SHOW_ONE_USE_PETR, mp);
17698 /* Wait for a reply... */
17703 #define api_show_lisp_use_petr api_show_one_use_petr
17706 * Add/delete mapping between vni and vrf
17709 api_one_eid_table_add_del_map (vat_main_t * vam)
17711 unformat_input_t *input = vam->input;
17712 vl_api_one_eid_table_add_del_map_t *mp;
17713 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17714 u32 vni, vrf, bd_index;
17717 /* Parse args required to build the message */
17718 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17720 if (unformat (input, "del"))
17722 else if (unformat (input, "vrf %d", &vrf))
17724 else if (unformat (input, "bd_index %d", &bd_index))
17726 else if (unformat (input, "vni %d", &vni))
17732 if (!vni_set || (!vrf_set && !bd_index_set))
17734 errmsg ("missing arguments!");
17738 if (vrf_set && bd_index_set)
17740 errmsg ("error: both vrf and bd entered!");
17744 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17746 mp->is_add = is_add;
17747 mp->vni = htonl (vni);
17748 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17749 mp->is_l2 = bd_index_set;
17754 /* wait for reply */
17759 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17762 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17764 u32 *action = va_arg (*args, u32 *);
17767 if (unformat (input, "%s", &s))
17769 if (!strcmp ((char *) s, "no-action"))
17771 else if (!strcmp ((char *) s, "natively-forward"))
17773 else if (!strcmp ((char *) s, "send-map-request"))
17775 else if (!strcmp ((char *) s, "drop"))
17779 clib_warning ("invalid action: '%s'", s);
17791 * Add/del remote mapping to/from ONE control plane
17793 * @param vam vpp API test context
17794 * @return return code
17797 api_one_add_del_remote_mapping (vat_main_t * vam)
17799 unformat_input_t *input = vam->input;
17800 vl_api_one_add_del_remote_mapping_t *mp;
17802 lisp_eid_vat_t _eid, *eid = &_eid;
17803 lisp_eid_vat_t _seid, *seid = &_seid;
17804 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17805 u32 action = ~0, p, w, data_len;
17806 ip4_address_t rloc4;
17807 ip6_address_t rloc6;
17808 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17811 memset (&rloc, 0, sizeof (rloc));
17813 /* Parse args required to build the message */
17814 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17816 if (unformat (input, "del-all"))
17820 else if (unformat (input, "del"))
17824 else if (unformat (input, "add"))
17828 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17832 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17836 else if (unformat (input, "vni %d", &vni))
17840 else if (unformat (input, "p %d w %d", &p, &w))
17844 errmsg ("No RLOC configured for setting priority/weight!");
17847 curr_rloc->priority = p;
17848 curr_rloc->weight = w;
17850 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17853 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17854 vec_add1 (rlocs, rloc);
17855 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17857 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17860 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17861 vec_add1 (rlocs, rloc);
17862 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17864 else if (unformat (input, "action %U",
17865 unformat_negative_mapping_action, &action))
17871 clib_warning ("parse error '%U'", format_unformat_error, input);
17878 errmsg ("missing params!");
17882 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17884 errmsg ("no action set for negative map-reply!");
17888 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17890 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17891 mp->is_add = is_add;
17892 mp->vni = htonl (vni);
17893 mp->action = (u8) action;
17894 mp->is_src_dst = seid_set;
17895 mp->eid_len = eid->len;
17896 mp->seid_len = seid->len;
17897 mp->del_all = del_all;
17898 mp->eid_type = eid->type;
17899 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17900 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17902 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17903 clib_memcpy (mp->rlocs, rlocs, data_len);
17909 /* Wait for a reply... */
17914 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17917 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17918 * forwarding entries in data-plane accordingly.
17920 * @param vam vpp API test context
17921 * @return return code
17924 api_one_add_del_adjacency (vat_main_t * vam)
17926 unformat_input_t *input = vam->input;
17927 vl_api_one_add_del_adjacency_t *mp;
17929 ip4_address_t leid4, reid4;
17930 ip6_address_t leid6, reid6;
17931 u8 reid_mac[6] = { 0 };
17932 u8 leid_mac[6] = { 0 };
17933 u8 reid_type, leid_type;
17934 u32 leid_len = 0, reid_len = 0, len;
17938 leid_type = reid_type = (u8) ~ 0;
17940 /* Parse args required to build the message */
17941 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17943 if (unformat (input, "del"))
17947 else if (unformat (input, "add"))
17951 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17954 reid_type = 0; /* ipv4 */
17957 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17960 reid_type = 1; /* ipv6 */
17963 else if (unformat (input, "reid %U", unformat_ethernet_address,
17966 reid_type = 2; /* mac */
17968 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17971 leid_type = 0; /* ipv4 */
17974 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17977 leid_type = 1; /* ipv6 */
17980 else if (unformat (input, "leid %U", unformat_ethernet_address,
17983 leid_type = 2; /* mac */
17985 else if (unformat (input, "vni %d", &vni))
17991 errmsg ("parse error '%U'", format_unformat_error, input);
17996 if ((u8) ~ 0 == reid_type)
17998 errmsg ("missing params!");
18002 if (leid_type != reid_type)
18004 errmsg ("remote and local EIDs are of different types!");
18008 M (ONE_ADD_DEL_ADJACENCY, mp);
18009 mp->is_add = is_add;
18010 mp->vni = htonl (vni);
18011 mp->leid_len = leid_len;
18012 mp->reid_len = reid_len;
18013 mp->eid_type = reid_type;
18015 switch (mp->eid_type)
18018 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18019 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18022 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18023 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18026 clib_memcpy (mp->leid, leid_mac, 6);
18027 clib_memcpy (mp->reid, reid_mac, 6);
18030 errmsg ("unknown EID type %d!", mp->eid_type);
18037 /* Wait for a reply... */
18042 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18045 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18047 u32 *mode = va_arg (*args, u32 *);
18049 if (unformat (input, "lisp"))
18051 else if (unformat (input, "vxlan"))
18060 api_gpe_get_encap_mode (vat_main_t * vam)
18062 vl_api_gpe_get_encap_mode_t *mp;
18065 /* Construct the API message */
18066 M (GPE_GET_ENCAP_MODE, mp);
18071 /* Wait for a reply... */
18077 api_gpe_set_encap_mode (vat_main_t * vam)
18079 unformat_input_t *input = vam->input;
18080 vl_api_gpe_set_encap_mode_t *mp;
18084 /* Parse args required to build the message */
18085 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18087 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18093 /* Construct the API message */
18094 M (GPE_SET_ENCAP_MODE, mp);
18101 /* Wait for a reply... */
18107 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18109 unformat_input_t *input = vam->input;
18110 vl_api_gpe_add_del_iface_t *mp;
18111 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18112 u32 dp_table = 0, vni = 0;
18115 /* Parse args required to build the message */
18116 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18118 if (unformat (input, "up"))
18123 else if (unformat (input, "down"))
18128 else if (unformat (input, "table_id %d", &dp_table))
18132 else if (unformat (input, "bd_id %d", &dp_table))
18137 else if (unformat (input, "vni %d", &vni))
18145 if (action_set == 0)
18147 errmsg ("Action not set");
18150 if (dp_table_set == 0 || vni_set == 0)
18152 errmsg ("vni and dp_table must be set");
18156 /* Construct the API message */
18157 M (GPE_ADD_DEL_IFACE, mp);
18159 mp->is_add = is_add;
18160 mp->dp_table = clib_host_to_net_u32 (dp_table);
18162 mp->vni = clib_host_to_net_u32 (vni);
18167 /* Wait for a reply... */
18173 api_one_map_register_fallback_threshold (vat_main_t * vam)
18175 unformat_input_t *input = vam->input;
18176 vl_api_one_map_register_fallback_threshold_t *mp;
18181 /* Parse args required to build the message */
18182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18184 if (unformat (input, "%u", &value))
18188 clib_warning ("parse error '%U'", format_unformat_error, input);
18195 errmsg ("fallback threshold value is missing!");
18199 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18200 mp->value = clib_host_to_net_u32 (value);
18205 /* Wait for a reply... */
18211 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18213 vl_api_show_one_map_register_fallback_threshold_t *mp;
18216 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18221 /* Wait for a reply... */
18227 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18229 u32 *proto = va_arg (*args, u32 *);
18231 if (unformat (input, "udp"))
18233 else if (unformat (input, "api"))
18242 api_one_set_transport_protocol (vat_main_t * vam)
18244 unformat_input_t *input = vam->input;
18245 vl_api_one_set_transport_protocol_t *mp;
18250 /* Parse args required to build the message */
18251 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18253 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18257 clib_warning ("parse error '%U'", format_unformat_error, input);
18264 errmsg ("Transport protocol missing!");
18268 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18269 mp->protocol = (u8) protocol;
18274 /* Wait for a reply... */
18280 api_one_get_transport_protocol (vat_main_t * vam)
18282 vl_api_one_get_transport_protocol_t *mp;
18285 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18290 /* Wait for a reply... */
18296 api_one_map_register_set_ttl (vat_main_t * vam)
18298 unformat_input_t *input = vam->input;
18299 vl_api_one_map_register_set_ttl_t *mp;
18304 /* Parse args required to build the message */
18305 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18307 if (unformat (input, "%u", &ttl))
18311 clib_warning ("parse error '%U'", format_unformat_error, input);
18318 errmsg ("TTL value missing!");
18322 M (ONE_MAP_REGISTER_SET_TTL, mp);
18323 mp->ttl = clib_host_to_net_u32 (ttl);
18328 /* Wait for a reply... */
18334 api_show_one_map_register_ttl (vat_main_t * vam)
18336 vl_api_show_one_map_register_ttl_t *mp;
18339 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18344 /* Wait for a reply... */
18350 * Add/del map request itr rlocs from ONE control plane and updates
18352 * @param vam vpp API test context
18353 * @return return code
18356 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18358 unformat_input_t *input = vam->input;
18359 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18360 u8 *locator_set_name = 0;
18361 u8 locator_set_name_set = 0;
18365 /* Parse args required to build the message */
18366 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18368 if (unformat (input, "del"))
18372 else if (unformat (input, "%_%v%_", &locator_set_name))
18374 locator_set_name_set = 1;
18378 clib_warning ("parse error '%U'", format_unformat_error, input);
18383 if (is_add && !locator_set_name_set)
18385 errmsg ("itr-rloc is not set!");
18389 if (is_add && vec_len (locator_set_name) > 64)
18391 errmsg ("itr-rloc locator-set name too long");
18392 vec_free (locator_set_name);
18396 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18397 mp->is_add = is_add;
18400 clib_memcpy (mp->locator_set_name, locator_set_name,
18401 vec_len (locator_set_name));
18405 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18407 vec_free (locator_set_name);
18412 /* Wait for a reply... */
18417 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18420 api_one_locator_dump (vat_main_t * vam)
18422 unformat_input_t *input = vam->input;
18423 vl_api_one_locator_dump_t *mp;
18424 vl_api_control_ping_t *mp_ping;
18425 u8 is_index_set = 0, is_name_set = 0;
18430 /* Parse args required to build the message */
18431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18433 if (unformat (input, "ls_name %_%v%_", &ls_name))
18437 else if (unformat (input, "ls_index %d", &ls_index))
18443 errmsg ("parse error '%U'", format_unformat_error, input);
18448 if (!is_index_set && !is_name_set)
18450 errmsg ("error: expected one of index or name!");
18454 if (is_index_set && is_name_set)
18456 errmsg ("error: only one param expected!");
18460 if (vec_len (ls_name) > 62)
18462 errmsg ("error: locator set name too long!");
18466 if (!vam->json_output)
18468 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18471 M (ONE_LOCATOR_DUMP, mp);
18472 mp->is_index_set = is_index_set;
18475 mp->ls_index = clib_host_to_net_u32 (ls_index);
18478 vec_add1 (ls_name, 0);
18479 strncpy ((char *) mp->ls_name, (char *) ls_name,
18480 sizeof (mp->ls_name) - 1);
18486 /* Use a control ping for synchronization */
18487 MPING (CONTROL_PING, mp_ping);
18490 /* Wait for a reply... */
18495 #define api_lisp_locator_dump api_one_locator_dump
18498 api_one_locator_set_dump (vat_main_t * vam)
18500 vl_api_one_locator_set_dump_t *mp;
18501 vl_api_control_ping_t *mp_ping;
18502 unformat_input_t *input = vam->input;
18506 /* Parse args required to build the message */
18507 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18509 if (unformat (input, "local"))
18513 else if (unformat (input, "remote"))
18519 errmsg ("parse error '%U'", format_unformat_error, input);
18524 if (!vam->json_output)
18526 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18529 M (ONE_LOCATOR_SET_DUMP, mp);
18531 mp->filter = filter;
18536 /* Use a control ping for synchronization */
18537 MPING (CONTROL_PING, mp_ping);
18540 /* Wait for a reply... */
18545 #define api_lisp_locator_set_dump api_one_locator_set_dump
18548 api_one_eid_table_map_dump (vat_main_t * vam)
18552 unformat_input_t *input = vam->input;
18553 vl_api_one_eid_table_map_dump_t *mp;
18554 vl_api_control_ping_t *mp_ping;
18557 /* Parse args required to build the message */
18558 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18560 if (unformat (input, "l2"))
18565 else if (unformat (input, "l3"))
18572 errmsg ("parse error '%U'", format_unformat_error, input);
18579 errmsg ("expected one of 'l2' or 'l3' parameter!");
18583 if (!vam->json_output)
18585 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18588 M (ONE_EID_TABLE_MAP_DUMP, mp);
18594 /* Use a control ping for synchronization */
18595 MPING (CONTROL_PING, mp_ping);
18598 /* Wait for a reply... */
18603 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18606 api_one_eid_table_vni_dump (vat_main_t * vam)
18608 vl_api_one_eid_table_vni_dump_t *mp;
18609 vl_api_control_ping_t *mp_ping;
18612 if (!vam->json_output)
18614 print (vam->ofp, "VNI");
18617 M (ONE_EID_TABLE_VNI_DUMP, mp);
18622 /* Use a control ping for synchronization */
18623 MPING (CONTROL_PING, mp_ping);
18626 /* Wait for a reply... */
18631 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18634 api_one_eid_table_dump (vat_main_t * vam)
18636 unformat_input_t *i = vam->input;
18637 vl_api_one_eid_table_dump_t *mp;
18638 vl_api_control_ping_t *mp_ping;
18639 struct in_addr ip4;
18640 struct in6_addr ip6;
18642 u8 eid_type = ~0, eid_set = 0;
18643 u32 prefix_length = ~0, t, vni = 0;
18646 lisp_nsh_api_t nsh;
18648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18650 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18656 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18662 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18667 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18672 else if (unformat (i, "vni %d", &t))
18676 else if (unformat (i, "local"))
18680 else if (unformat (i, "remote"))
18686 errmsg ("parse error '%U'", format_unformat_error, i);
18691 if (!vam->json_output)
18693 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18694 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18697 M (ONE_EID_TABLE_DUMP, mp);
18699 mp->filter = filter;
18703 mp->vni = htonl (vni);
18704 mp->eid_type = eid_type;
18708 mp->prefix_length = prefix_length;
18709 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18712 mp->prefix_length = prefix_length;
18713 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18716 clib_memcpy (mp->eid, mac, sizeof (mac));
18719 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18722 errmsg ("unknown EID type %d!", eid_type);
18730 /* Use a control ping for synchronization */
18731 MPING (CONTROL_PING, mp_ping);
18734 /* Wait for a reply... */
18739 #define api_lisp_eid_table_dump api_one_eid_table_dump
18742 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18744 unformat_input_t *i = vam->input;
18745 vl_api_gpe_fwd_entries_get_t *mp;
18750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18752 if (unformat (i, "vni %d", &vni))
18758 errmsg ("parse error '%U'", format_unformat_error, i);
18765 errmsg ("vni not set!");
18769 if (!vam->json_output)
18771 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18775 M (GPE_FWD_ENTRIES_GET, mp);
18776 mp->vni = clib_host_to_net_u32 (vni);
18781 /* Wait for a reply... */
18786 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18787 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18788 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18789 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18790 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18791 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18792 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18793 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18796 api_one_adjacencies_get (vat_main_t * vam)
18798 unformat_input_t *i = vam->input;
18799 vl_api_one_adjacencies_get_t *mp;
18804 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18806 if (unformat (i, "vni %d", &vni))
18812 errmsg ("parse error '%U'", format_unformat_error, i);
18819 errmsg ("vni not set!");
18823 if (!vam->json_output)
18825 print (vam->ofp, "%s %40s", "leid", "reid");
18828 M (ONE_ADJACENCIES_GET, mp);
18829 mp->vni = clib_host_to_net_u32 (vni);
18834 /* Wait for a reply... */
18839 #define api_lisp_adjacencies_get api_one_adjacencies_get
18842 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18844 unformat_input_t *i = vam->input;
18845 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18847 u8 ip_family_set = 0, is_ip4 = 1;
18849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18851 if (unformat (i, "ip4"))
18856 else if (unformat (i, "ip6"))
18863 errmsg ("parse error '%U'", format_unformat_error, i);
18868 if (!ip_family_set)
18870 errmsg ("ip family not set!");
18874 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18875 mp->is_ip4 = is_ip4;
18880 /* Wait for a reply... */
18886 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18888 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18891 if (!vam->json_output)
18893 print (vam->ofp, "VNIs");
18896 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18901 /* Wait for a reply... */
18907 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18909 unformat_input_t *i = vam->input;
18910 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18912 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18913 struct in_addr ip4;
18914 struct in6_addr ip6;
18915 u32 table_id = 0, nh_sw_if_index = ~0;
18917 memset (&ip4, 0, sizeof (ip4));
18918 memset (&ip6, 0, sizeof (ip6));
18920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18922 if (unformat (i, "del"))
18924 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18925 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18930 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18931 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18936 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18940 nh_sw_if_index = ~0;
18942 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18946 nh_sw_if_index = ~0;
18948 else if (unformat (i, "table %d", &table_id))
18952 errmsg ("parse error '%U'", format_unformat_error, i);
18959 errmsg ("nh addr not set!");
18963 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18964 mp->is_add = is_add;
18965 mp->table_id = clib_host_to_net_u32 (table_id);
18966 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18967 mp->is_ip4 = is_ip4;
18969 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18971 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18976 /* Wait for a reply... */
18982 api_one_map_server_dump (vat_main_t * vam)
18984 vl_api_one_map_server_dump_t *mp;
18985 vl_api_control_ping_t *mp_ping;
18988 if (!vam->json_output)
18990 print (vam->ofp, "%=20s", "Map server");
18993 M (ONE_MAP_SERVER_DUMP, mp);
18997 /* Use a control ping for synchronization */
18998 MPING (CONTROL_PING, mp_ping);
19001 /* Wait for a reply... */
19006 #define api_lisp_map_server_dump api_one_map_server_dump
19009 api_one_map_resolver_dump (vat_main_t * vam)
19011 vl_api_one_map_resolver_dump_t *mp;
19012 vl_api_control_ping_t *mp_ping;
19015 if (!vam->json_output)
19017 print (vam->ofp, "%=20s", "Map resolver");
19020 M (ONE_MAP_RESOLVER_DUMP, mp);
19024 /* Use a control ping for synchronization */
19025 MPING (CONTROL_PING, mp_ping);
19028 /* Wait for a reply... */
19033 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19036 api_one_stats_flush (vat_main_t * vam)
19038 vl_api_one_stats_flush_t *mp;
19041 M (ONE_STATS_FLUSH, mp);
19048 api_one_stats_dump (vat_main_t * vam)
19050 vl_api_one_stats_dump_t *mp;
19051 vl_api_control_ping_t *mp_ping;
19054 M (ONE_STATS_DUMP, mp);
19058 /* Use a control ping for synchronization */
19059 MPING (CONTROL_PING, mp_ping);
19062 /* Wait for a reply... */
19068 api_show_one_status (vat_main_t * vam)
19070 vl_api_show_one_status_t *mp;
19073 if (!vam->json_output)
19075 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19078 M (SHOW_ONE_STATUS, mp);
19081 /* Wait for a reply... */
19086 #define api_show_lisp_status api_show_one_status
19089 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19091 vl_api_gpe_fwd_entry_path_dump_t *mp;
19092 vl_api_control_ping_t *mp_ping;
19093 unformat_input_t *i = vam->input;
19094 u32 fwd_entry_index = ~0;
19097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19099 if (unformat (i, "index %d", &fwd_entry_index))
19105 if (~0 == fwd_entry_index)
19107 errmsg ("no index specified!");
19111 if (!vam->json_output)
19113 print (vam->ofp, "first line");
19116 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19120 /* Use a control ping for synchronization */
19121 MPING (CONTROL_PING, mp_ping);
19124 /* Wait for a reply... */
19130 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19132 vl_api_one_get_map_request_itr_rlocs_t *mp;
19135 if (!vam->json_output)
19137 print (vam->ofp, "%=20s", "itr-rlocs:");
19140 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19143 /* Wait for a reply... */
19148 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19151 api_af_packet_create (vat_main_t * vam)
19153 unformat_input_t *i = vam->input;
19154 vl_api_af_packet_create_t *mp;
19155 u8 *host_if_name = 0;
19157 u8 random_hw_addr = 1;
19160 memset (hw_addr, 0, sizeof (hw_addr));
19162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19164 if (unformat (i, "name %s", &host_if_name))
19165 vec_add1 (host_if_name, 0);
19166 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19167 random_hw_addr = 0;
19172 if (!vec_len (host_if_name))
19174 errmsg ("host-interface name must be specified");
19178 if (vec_len (host_if_name) > 64)
19180 errmsg ("host-interface name too long");
19184 M (AF_PACKET_CREATE, mp);
19186 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19187 clib_memcpy (mp->hw_addr, hw_addr, 6);
19188 mp->use_random_hw_addr = random_hw_addr;
19189 vec_free (host_if_name);
19197 fprintf (vam->ofp ? vam->ofp : stderr,
19198 " new sw_if_index = %d\n", vam->sw_if_index);
19205 api_af_packet_delete (vat_main_t * vam)
19207 unformat_input_t *i = vam->input;
19208 vl_api_af_packet_delete_t *mp;
19209 u8 *host_if_name = 0;
19212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19214 if (unformat (i, "name %s", &host_if_name))
19215 vec_add1 (host_if_name, 0);
19220 if (!vec_len (host_if_name))
19222 errmsg ("host-interface name must be specified");
19226 if (vec_len (host_if_name) > 64)
19228 errmsg ("host-interface name too long");
19232 M (AF_PACKET_DELETE, mp);
19234 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19235 vec_free (host_if_name);
19243 api_policer_add_del (vat_main_t * vam)
19245 unformat_input_t *i = vam->input;
19246 vl_api_policer_add_del_t *mp;
19256 u8 color_aware = 0;
19257 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19260 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19261 conform_action.dscp = 0;
19262 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19263 exceed_action.dscp = 0;
19264 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19265 violate_action.dscp = 0;
19267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19269 if (unformat (i, "del"))
19271 else if (unformat (i, "name %s", &name))
19272 vec_add1 (name, 0);
19273 else if (unformat (i, "cir %u", &cir))
19275 else if (unformat (i, "eir %u", &eir))
19277 else if (unformat (i, "cb %u", &cb))
19279 else if (unformat (i, "eb %u", &eb))
19281 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19284 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19287 else if (unformat (i, "type %U", unformat_policer_type, &type))
19289 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19292 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19295 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19298 else if (unformat (i, "color-aware"))
19304 if (!vec_len (name))
19306 errmsg ("policer name must be specified");
19310 if (vec_len (name) > 64)
19312 errmsg ("policer name too long");
19316 M (POLICER_ADD_DEL, mp);
19318 clib_memcpy (mp->name, name, vec_len (name));
19320 mp->is_add = is_add;
19321 mp->cir = ntohl (cir);
19322 mp->eir = ntohl (eir);
19323 mp->cb = clib_net_to_host_u64 (cb);
19324 mp->eb = clib_net_to_host_u64 (eb);
19325 mp->rate_type = rate_type;
19326 mp->round_type = round_type;
19328 mp->conform_action_type = conform_action.action_type;
19329 mp->conform_dscp = conform_action.dscp;
19330 mp->exceed_action_type = exceed_action.action_type;
19331 mp->exceed_dscp = exceed_action.dscp;
19332 mp->violate_action_type = violate_action.action_type;
19333 mp->violate_dscp = violate_action.dscp;
19334 mp->color_aware = color_aware;
19342 api_policer_dump (vat_main_t * vam)
19344 unformat_input_t *i = vam->input;
19345 vl_api_policer_dump_t *mp;
19346 vl_api_control_ping_t *mp_ping;
19347 u8 *match_name = 0;
19348 u8 match_name_valid = 0;
19351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19353 if (unformat (i, "name %s", &match_name))
19355 vec_add1 (match_name, 0);
19356 match_name_valid = 1;
19362 M (POLICER_DUMP, mp);
19363 mp->match_name_valid = match_name_valid;
19364 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19365 vec_free (match_name);
19369 /* Use a control ping for synchronization */
19370 MPING (CONTROL_PING, mp_ping);
19373 /* Wait for a reply... */
19379 api_policer_classify_set_interface (vat_main_t * vam)
19381 unformat_input_t *i = vam->input;
19382 vl_api_policer_classify_set_interface_t *mp;
19384 int sw_if_index_set;
19385 u32 ip4_table_index = ~0;
19386 u32 ip6_table_index = ~0;
19387 u32 l2_table_index = ~0;
19391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19393 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19394 sw_if_index_set = 1;
19395 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19396 sw_if_index_set = 1;
19397 else if (unformat (i, "del"))
19399 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19401 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19403 else if (unformat (i, "l2-table %d", &l2_table_index))
19407 clib_warning ("parse error '%U'", format_unformat_error, i);
19412 if (sw_if_index_set == 0)
19414 errmsg ("missing interface name or sw_if_index");
19418 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19420 mp->sw_if_index = ntohl (sw_if_index);
19421 mp->ip4_table_index = ntohl (ip4_table_index);
19422 mp->ip6_table_index = ntohl (ip6_table_index);
19423 mp->l2_table_index = ntohl (l2_table_index);
19424 mp->is_add = is_add;
19432 api_policer_classify_dump (vat_main_t * vam)
19434 unformat_input_t *i = vam->input;
19435 vl_api_policer_classify_dump_t *mp;
19436 vl_api_control_ping_t *mp_ping;
19437 u8 type = POLICER_CLASSIFY_N_TABLES;
19440 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19444 errmsg ("classify table type must be specified");
19448 if (!vam->json_output)
19450 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19453 M (POLICER_CLASSIFY_DUMP, mp);
19458 /* Use a control ping for synchronization */
19459 MPING (CONTROL_PING, mp_ping);
19462 /* Wait for a reply... */
19468 api_netmap_create (vat_main_t * vam)
19470 unformat_input_t *i = vam->input;
19471 vl_api_netmap_create_t *mp;
19474 u8 random_hw_addr = 1;
19479 memset (hw_addr, 0, sizeof (hw_addr));
19481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19483 if (unformat (i, "name %s", &if_name))
19484 vec_add1 (if_name, 0);
19485 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19486 random_hw_addr = 0;
19487 else if (unformat (i, "pipe"))
19489 else if (unformat (i, "master"))
19491 else if (unformat (i, "slave"))
19497 if (!vec_len (if_name))
19499 errmsg ("interface name must be specified");
19503 if (vec_len (if_name) > 64)
19505 errmsg ("interface name too long");
19509 M (NETMAP_CREATE, mp);
19511 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19512 clib_memcpy (mp->hw_addr, hw_addr, 6);
19513 mp->use_random_hw_addr = random_hw_addr;
19514 mp->is_pipe = is_pipe;
19515 mp->is_master = is_master;
19516 vec_free (if_name);
19524 api_netmap_delete (vat_main_t * vam)
19526 unformat_input_t *i = vam->input;
19527 vl_api_netmap_delete_t *mp;
19531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19533 if (unformat (i, "name %s", &if_name))
19534 vec_add1 (if_name, 0);
19539 if (!vec_len (if_name))
19541 errmsg ("interface name must be specified");
19545 if (vec_len (if_name) > 64)
19547 errmsg ("interface name too long");
19551 M (NETMAP_DELETE, mp);
19553 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19554 vec_free (if_name);
19562 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19564 if (fp->afi == IP46_TYPE_IP6)
19566 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19567 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19568 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19569 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19570 format_ip6_address, fp->next_hop);
19571 else if (fp->afi == IP46_TYPE_IP4)
19573 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19574 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19575 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19576 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19577 format_ip4_address, fp->next_hop);
19581 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19582 vl_api_fib_path2_t * fp)
19584 struct in_addr ip4;
19585 struct in6_addr ip6;
19587 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19588 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19589 vat_json_object_add_uint (node, "is_local", fp->is_local);
19590 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19591 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19592 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19593 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19594 if (fp->afi == IP46_TYPE_IP4)
19596 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19597 vat_json_object_add_ip4 (node, "next_hop", ip4);
19599 else if (fp->afi == IP46_TYPE_IP6)
19601 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19602 vat_json_object_add_ip6 (node, "next_hop", ip6);
19607 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19609 vat_main_t *vam = &vat_main;
19610 int count = ntohl (mp->mt_count);
19611 vl_api_fib_path2_t *fp;
19614 print (vam->ofp, "[%d]: sw_if_index %d via:",
19615 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19617 for (i = 0; i < count; i++)
19619 vl_api_mpls_fib_path_print (vam, fp);
19623 print (vam->ofp, "");
19626 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19627 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19630 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19632 vat_main_t *vam = &vat_main;
19633 vat_json_node_t *node = NULL;
19634 int count = ntohl (mp->mt_count);
19635 vl_api_fib_path2_t *fp;
19638 if (VAT_JSON_ARRAY != vam->json_tree.type)
19640 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19641 vat_json_init_array (&vam->json_tree);
19643 node = vat_json_array_add (&vam->json_tree);
19645 vat_json_init_object (node);
19646 vat_json_object_add_uint (node, "tunnel_index",
19647 ntohl (mp->mt_tunnel_index));
19648 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19650 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19653 for (i = 0; i < count; i++)
19655 vl_api_mpls_fib_path_json_print (node, fp);
19661 api_mpls_tunnel_dump (vat_main_t * vam)
19663 vl_api_mpls_tunnel_dump_t *mp;
19664 vl_api_control_ping_t *mp_ping;
19668 /* Parse args required to build the message */
19669 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19671 if (!unformat (vam->input, "tunnel_index %d", &index))
19678 print (vam->ofp, " tunnel_index %d", index);
19680 M (MPLS_TUNNEL_DUMP, mp);
19681 mp->tunnel_index = htonl (index);
19684 /* Use a control ping for synchronization */
19685 MPING (CONTROL_PING, mp_ping);
19692 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19693 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19697 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19699 vat_main_t *vam = &vat_main;
19700 int count = ntohl (mp->count);
19701 vl_api_fib_path2_t *fp;
19705 "table-id %d, label %u, ess_bit %u",
19706 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19708 for (i = 0; i < count; i++)
19710 vl_api_mpls_fib_path_print (vam, fp);
19715 static void vl_api_mpls_fib_details_t_handler_json
19716 (vl_api_mpls_fib_details_t * mp)
19718 vat_main_t *vam = &vat_main;
19719 int count = ntohl (mp->count);
19720 vat_json_node_t *node = NULL;
19721 vl_api_fib_path2_t *fp;
19724 if (VAT_JSON_ARRAY != vam->json_tree.type)
19726 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19727 vat_json_init_array (&vam->json_tree);
19729 node = vat_json_array_add (&vam->json_tree);
19731 vat_json_init_object (node);
19732 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19733 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19734 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19735 vat_json_object_add_uint (node, "path_count", count);
19737 for (i = 0; i < count; i++)
19739 vl_api_mpls_fib_path_json_print (node, fp);
19745 api_mpls_fib_dump (vat_main_t * vam)
19747 vl_api_mpls_fib_dump_t *mp;
19748 vl_api_control_ping_t *mp_ping;
19751 M (MPLS_FIB_DUMP, mp);
19754 /* Use a control ping for synchronization */
19755 MPING (CONTROL_PING, mp_ping);
19762 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19763 #define vl_api_ip_fib_details_t_print vl_noop_handler
19766 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19768 vat_main_t *vam = &vat_main;
19769 int count = ntohl (mp->count);
19770 vl_api_fib_path_t *fp;
19774 "table-id %d, prefix %U/%d",
19775 ntohl (mp->table_id), format_ip4_address, mp->address,
19776 mp->address_length);
19778 for (i = 0; i < count; i++)
19780 if (fp->afi == IP46_TYPE_IP6)
19782 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19783 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19784 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19785 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19786 format_ip6_address, fp->next_hop);
19787 else if (fp->afi == IP46_TYPE_IP4)
19789 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19790 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19791 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19792 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19793 format_ip4_address, fp->next_hop);
19798 static void vl_api_ip_fib_details_t_handler_json
19799 (vl_api_ip_fib_details_t * mp)
19801 vat_main_t *vam = &vat_main;
19802 int count = ntohl (mp->count);
19803 vat_json_node_t *node = NULL;
19804 struct in_addr ip4;
19805 struct in6_addr ip6;
19806 vl_api_fib_path_t *fp;
19809 if (VAT_JSON_ARRAY != vam->json_tree.type)
19811 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19812 vat_json_init_array (&vam->json_tree);
19814 node = vat_json_array_add (&vam->json_tree);
19816 vat_json_init_object (node);
19817 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19818 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19819 vat_json_object_add_ip4 (node, "prefix", ip4);
19820 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19821 vat_json_object_add_uint (node, "path_count", count);
19823 for (i = 0; i < count; i++)
19825 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19826 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19827 vat_json_object_add_uint (node, "is_local", fp->is_local);
19828 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19829 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19830 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19831 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19832 if (fp->afi == IP46_TYPE_IP4)
19834 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19835 vat_json_object_add_ip4 (node, "next_hop", ip4);
19837 else if (fp->afi == IP46_TYPE_IP6)
19839 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19840 vat_json_object_add_ip6 (node, "next_hop", ip6);
19846 api_ip_fib_dump (vat_main_t * vam)
19848 vl_api_ip_fib_dump_t *mp;
19849 vl_api_control_ping_t *mp_ping;
19852 M (IP_FIB_DUMP, mp);
19855 /* Use a control ping for synchronization */
19856 MPING (CONTROL_PING, mp_ping);
19864 api_ip_mfib_dump (vat_main_t * vam)
19866 vl_api_ip_mfib_dump_t *mp;
19867 vl_api_control_ping_t *mp_ping;
19870 M (IP_MFIB_DUMP, mp);
19873 /* Use a control ping for synchronization */
19874 MPING (CONTROL_PING, mp_ping);
19881 static void vl_api_ip_neighbor_details_t_handler
19882 (vl_api_ip_neighbor_details_t * mp)
19884 vat_main_t *vam = &vat_main;
19886 print (vam->ofp, "%c %U %U",
19887 (mp->is_static) ? 'S' : 'D',
19888 format_ethernet_address, &mp->mac_address,
19889 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19893 static void vl_api_ip_neighbor_details_t_handler_json
19894 (vl_api_ip_neighbor_details_t * mp)
19897 vat_main_t *vam = &vat_main;
19898 vat_json_node_t *node;
19899 struct in_addr ip4;
19900 struct in6_addr ip6;
19902 if (VAT_JSON_ARRAY != vam->json_tree.type)
19904 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19905 vat_json_init_array (&vam->json_tree);
19907 node = vat_json_array_add (&vam->json_tree);
19909 vat_json_init_object (node);
19910 vat_json_object_add_string_copy (node, "flag",
19911 (mp->is_static) ? (u8 *) "static" : (u8 *)
19914 vat_json_object_add_string_copy (node, "link_layer",
19915 format (0, "%U", format_ethernet_address,
19916 &mp->mac_address));
19920 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19921 vat_json_object_add_ip6 (node, "ip_address", ip6);
19925 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19926 vat_json_object_add_ip4 (node, "ip_address", ip4);
19931 api_ip_neighbor_dump (vat_main_t * vam)
19933 unformat_input_t *i = vam->input;
19934 vl_api_ip_neighbor_dump_t *mp;
19935 vl_api_control_ping_t *mp_ping;
19937 u32 sw_if_index = ~0;
19940 /* Parse args required to build the message */
19941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19945 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19947 else if (unformat (i, "ip6"))
19953 if (sw_if_index == ~0)
19955 errmsg ("missing interface name or sw_if_index");
19959 M (IP_NEIGHBOR_DUMP, mp);
19960 mp->is_ipv6 = (u8) is_ipv6;
19961 mp->sw_if_index = ntohl (sw_if_index);
19964 /* Use a control ping for synchronization */
19965 MPING (CONTROL_PING, mp_ping);
19972 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19973 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19976 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19978 vat_main_t *vam = &vat_main;
19979 int count = ntohl (mp->count);
19980 vl_api_fib_path_t *fp;
19984 "table-id %d, prefix %U/%d",
19985 ntohl (mp->table_id), format_ip6_address, mp->address,
19986 mp->address_length);
19988 for (i = 0; i < count; i++)
19990 if (fp->afi == IP46_TYPE_IP6)
19992 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19993 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19994 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19995 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19996 format_ip6_address, fp->next_hop);
19997 else if (fp->afi == IP46_TYPE_IP4)
19999 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20000 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20001 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20002 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20003 format_ip4_address, fp->next_hop);
20008 static void vl_api_ip6_fib_details_t_handler_json
20009 (vl_api_ip6_fib_details_t * mp)
20011 vat_main_t *vam = &vat_main;
20012 int count = ntohl (mp->count);
20013 vat_json_node_t *node = NULL;
20014 struct in_addr ip4;
20015 struct in6_addr ip6;
20016 vl_api_fib_path_t *fp;
20019 if (VAT_JSON_ARRAY != vam->json_tree.type)
20021 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20022 vat_json_init_array (&vam->json_tree);
20024 node = vat_json_array_add (&vam->json_tree);
20026 vat_json_init_object (node);
20027 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20028 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20029 vat_json_object_add_ip6 (node, "prefix", ip6);
20030 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20031 vat_json_object_add_uint (node, "path_count", count);
20033 for (i = 0; i < count; i++)
20035 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20036 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20037 vat_json_object_add_uint (node, "is_local", fp->is_local);
20038 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20039 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20040 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20041 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20042 if (fp->afi == IP46_TYPE_IP4)
20044 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20045 vat_json_object_add_ip4 (node, "next_hop", ip4);
20047 else if (fp->afi == IP46_TYPE_IP6)
20049 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20050 vat_json_object_add_ip6 (node, "next_hop", ip6);
20056 api_ip6_fib_dump (vat_main_t * vam)
20058 vl_api_ip6_fib_dump_t *mp;
20059 vl_api_control_ping_t *mp_ping;
20062 M (IP6_FIB_DUMP, mp);
20065 /* Use a control ping for synchronization */
20066 MPING (CONTROL_PING, mp_ping);
20074 api_ip6_mfib_dump (vat_main_t * vam)
20076 vl_api_ip6_mfib_dump_t *mp;
20077 vl_api_control_ping_t *mp_ping;
20080 M (IP6_MFIB_DUMP, mp);
20083 /* Use a control ping for synchronization */
20084 MPING (CONTROL_PING, mp_ping);
20092 api_classify_table_ids (vat_main_t * vam)
20094 vl_api_classify_table_ids_t *mp;
20097 /* Construct the API message */
20098 M (CLASSIFY_TABLE_IDS, mp);
20107 api_classify_table_by_interface (vat_main_t * vam)
20109 unformat_input_t *input = vam->input;
20110 vl_api_classify_table_by_interface_t *mp;
20112 u32 sw_if_index = ~0;
20114 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20116 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20118 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20123 if (sw_if_index == ~0)
20125 errmsg ("missing interface name or sw_if_index");
20129 /* Construct the API message */
20130 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20132 mp->sw_if_index = ntohl (sw_if_index);
20140 api_classify_table_info (vat_main_t * vam)
20142 unformat_input_t *input = vam->input;
20143 vl_api_classify_table_info_t *mp;
20147 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20149 if (unformat (input, "table_id %d", &table_id))
20154 if (table_id == ~0)
20156 errmsg ("missing table id");
20160 /* Construct the API message */
20161 M (CLASSIFY_TABLE_INFO, mp);
20163 mp->table_id = ntohl (table_id);
20171 api_classify_session_dump (vat_main_t * vam)
20173 unformat_input_t *input = vam->input;
20174 vl_api_classify_session_dump_t *mp;
20175 vl_api_control_ping_t *mp_ping;
20179 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20181 if (unformat (input, "table_id %d", &table_id))
20186 if (table_id == ~0)
20188 errmsg ("missing table id");
20192 /* Construct the API message */
20193 M (CLASSIFY_SESSION_DUMP, mp);
20195 mp->table_id = ntohl (table_id);
20198 /* Use a control ping for synchronization */
20199 MPING (CONTROL_PING, mp_ping);
20207 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20209 vat_main_t *vam = &vat_main;
20211 print (vam->ofp, "collector_address %U, collector_port %d, "
20212 "src_address %U, vrf_id %d, path_mtu %u, "
20213 "template_interval %u, udp_checksum %d",
20214 format_ip4_address, mp->collector_address,
20215 ntohs (mp->collector_port),
20216 format_ip4_address, mp->src_address,
20217 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20218 ntohl (mp->template_interval), mp->udp_checksum);
20221 vam->result_ready = 1;
20225 vl_api_ipfix_exporter_details_t_handler_json
20226 (vl_api_ipfix_exporter_details_t * mp)
20228 vat_main_t *vam = &vat_main;
20229 vat_json_node_t node;
20230 struct in_addr collector_address;
20231 struct in_addr src_address;
20233 vat_json_init_object (&node);
20234 clib_memcpy (&collector_address, &mp->collector_address,
20235 sizeof (collector_address));
20236 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20237 vat_json_object_add_uint (&node, "collector_port",
20238 ntohs (mp->collector_port));
20239 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20240 vat_json_object_add_ip4 (&node, "src_address", src_address);
20241 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20242 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20243 vat_json_object_add_uint (&node, "template_interval",
20244 ntohl (mp->template_interval));
20245 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20247 vat_json_print (vam->ofp, &node);
20248 vat_json_free (&node);
20250 vam->result_ready = 1;
20254 api_ipfix_exporter_dump (vat_main_t * vam)
20256 vl_api_ipfix_exporter_dump_t *mp;
20259 /* Construct the API message */
20260 M (IPFIX_EXPORTER_DUMP, mp);
20269 api_ipfix_classify_stream_dump (vat_main_t * vam)
20271 vl_api_ipfix_classify_stream_dump_t *mp;
20274 /* Construct the API message */
20275 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20286 vl_api_ipfix_classify_stream_details_t_handler
20287 (vl_api_ipfix_classify_stream_details_t * mp)
20289 vat_main_t *vam = &vat_main;
20290 print (vam->ofp, "domain_id %d, src_port %d",
20291 ntohl (mp->domain_id), ntohs (mp->src_port));
20293 vam->result_ready = 1;
20297 vl_api_ipfix_classify_stream_details_t_handler_json
20298 (vl_api_ipfix_classify_stream_details_t * mp)
20300 vat_main_t *vam = &vat_main;
20301 vat_json_node_t node;
20303 vat_json_init_object (&node);
20304 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20305 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20307 vat_json_print (vam->ofp, &node);
20308 vat_json_free (&node);
20310 vam->result_ready = 1;
20314 api_ipfix_classify_table_dump (vat_main_t * vam)
20316 vl_api_ipfix_classify_table_dump_t *mp;
20317 vl_api_control_ping_t *mp_ping;
20320 if (!vam->json_output)
20322 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20323 "transport_protocol");
20326 /* Construct the API message */
20327 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20332 /* Use a control ping for synchronization */
20333 MPING (CONTROL_PING, mp_ping);
20341 vl_api_ipfix_classify_table_details_t_handler
20342 (vl_api_ipfix_classify_table_details_t * mp)
20344 vat_main_t *vam = &vat_main;
20345 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20346 mp->transport_protocol);
20350 vl_api_ipfix_classify_table_details_t_handler_json
20351 (vl_api_ipfix_classify_table_details_t * mp)
20353 vat_json_node_t *node = NULL;
20354 vat_main_t *vam = &vat_main;
20356 if (VAT_JSON_ARRAY != vam->json_tree.type)
20358 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20359 vat_json_init_array (&vam->json_tree);
20362 node = vat_json_array_add (&vam->json_tree);
20363 vat_json_init_object (node);
20365 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20366 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20367 vat_json_object_add_uint (node, "transport_protocol",
20368 mp->transport_protocol);
20372 api_sw_interface_span_enable_disable (vat_main_t * vam)
20374 unformat_input_t *i = vam->input;
20375 vl_api_sw_interface_span_enable_disable_t *mp;
20376 u32 src_sw_if_index = ~0;
20377 u32 dst_sw_if_index = ~0;
20382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20385 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20387 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20391 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20393 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20395 else if (unformat (i, "disable"))
20397 else if (unformat (i, "rx"))
20399 else if (unformat (i, "tx"))
20401 else if (unformat (i, "both"))
20403 else if (unformat (i, "l2"))
20409 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20411 mp->sw_if_index_from = htonl (src_sw_if_index);
20412 mp->sw_if_index_to = htonl (dst_sw_if_index);
20422 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20425 vat_main_t *vam = &vat_main;
20426 u8 *sw_if_from_name = 0;
20427 u8 *sw_if_to_name = 0;
20428 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20429 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20430 char *states[] = { "none", "rx", "tx", "both" };
20434 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20436 if ((u32) p->value[0] == sw_if_index_from)
20438 sw_if_from_name = (u8 *)(p->key);
20442 if ((u32) p->value[0] == sw_if_index_to)
20444 sw_if_to_name = (u8 *)(p->key);
20445 if (sw_if_from_name)
20450 print (vam->ofp, "%20s => %20s (%s)",
20451 sw_if_from_name, sw_if_to_name, states[mp->state]);
20455 vl_api_sw_interface_span_details_t_handler_json
20456 (vl_api_sw_interface_span_details_t * mp)
20458 vat_main_t *vam = &vat_main;
20459 vat_json_node_t *node = NULL;
20460 u8 *sw_if_from_name = 0;
20461 u8 *sw_if_to_name = 0;
20462 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20463 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20467 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20469 if ((u32) p->value[0] == sw_if_index_from)
20471 sw_if_from_name = (u8 *)(p->key);
20475 if ((u32) p->value[0] == sw_if_index_to)
20477 sw_if_to_name = (u8 *)(p->key);
20478 if (sw_if_from_name)
20484 if (VAT_JSON_ARRAY != vam->json_tree.type)
20486 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20487 vat_json_init_array (&vam->json_tree);
20489 node = vat_json_array_add (&vam->json_tree);
20491 vat_json_init_object (node);
20492 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20493 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20494 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20495 if (0 != sw_if_to_name)
20497 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20499 vat_json_object_add_uint (node, "state", mp->state);
20503 api_sw_interface_span_dump (vat_main_t * vam)
20505 unformat_input_t *input = vam->input;
20506 vl_api_sw_interface_span_dump_t *mp;
20507 vl_api_control_ping_t *mp_ping;
20511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20513 if (unformat (input, "l2"))
20519 M (SW_INTERFACE_SPAN_DUMP, mp);
20523 /* Use a control ping for synchronization */
20524 MPING (CONTROL_PING, mp_ping);
20532 api_pg_create_interface (vat_main_t * vam)
20534 unformat_input_t *input = vam->input;
20535 vl_api_pg_create_interface_t *mp;
20539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20541 if (unformat (input, "if_id %d", &if_id))
20548 errmsg ("missing pg interface index");
20552 /* Construct the API message */
20553 M (PG_CREATE_INTERFACE, mp);
20555 mp->interface_id = ntohl (if_id);
20563 api_pg_capture (vat_main_t * vam)
20565 unformat_input_t *input = vam->input;
20566 vl_api_pg_capture_t *mp;
20571 u8 pcap_file_set = 0;
20574 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20576 if (unformat (input, "if_id %d", &if_id))
20578 else if (unformat (input, "pcap %s", &pcap_file))
20580 else if (unformat (input, "count %d", &count))
20582 else if (unformat (input, "disable"))
20589 errmsg ("missing pg interface index");
20592 if (pcap_file_set > 0)
20594 if (vec_len (pcap_file) > 255)
20596 errmsg ("pcap file name is too long");
20601 u32 name_len = vec_len (pcap_file);
20602 /* Construct the API message */
20603 M (PG_CAPTURE, mp);
20605 mp->interface_id = ntohl (if_id);
20606 mp->is_enabled = enable;
20607 mp->count = ntohl (count);
20608 mp->pcap_name_length = ntohl (name_len);
20609 if (pcap_file_set != 0)
20611 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20613 vec_free (pcap_file);
20621 api_pg_enable_disable (vat_main_t * vam)
20623 unformat_input_t *input = vam->input;
20624 vl_api_pg_enable_disable_t *mp;
20627 u8 stream_name_set = 0;
20628 u8 *stream_name = 0;
20630 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20632 if (unformat (input, "stream %s", &stream_name))
20633 stream_name_set = 1;
20634 else if (unformat (input, "disable"))
20640 if (stream_name_set > 0)
20642 if (vec_len (stream_name) > 255)
20644 errmsg ("stream name too long");
20649 u32 name_len = vec_len (stream_name);
20650 /* Construct the API message */
20651 M (PG_ENABLE_DISABLE, mp);
20653 mp->is_enabled = enable;
20654 if (stream_name_set != 0)
20656 mp->stream_name_length = ntohl (name_len);
20657 clib_memcpy (mp->stream_name, stream_name, name_len);
20659 vec_free (stream_name);
20667 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20669 unformat_input_t *input = vam->input;
20670 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20672 u16 *low_ports = 0;
20673 u16 *high_ports = 0;
20676 ip4_address_t ip4_addr;
20677 ip6_address_t ip6_addr;
20686 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20688 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20694 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20699 else if (unformat (input, "vrf %d", &vrf_id))
20701 else if (unformat (input, "del"))
20703 else if (unformat (input, "port %d", &tmp))
20705 if (tmp == 0 || tmp > 65535)
20707 errmsg ("port %d out of range", tmp);
20711 this_hi = this_low + 1;
20712 vec_add1 (low_ports, this_low);
20713 vec_add1 (high_ports, this_hi);
20715 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20717 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20719 errmsg ("incorrect range parameters");
20723 /* Note: in debug CLI +1 is added to high before
20724 passing to real fn that does "the work"
20725 (ip_source_and_port_range_check_add_del).
20726 This fn is a wrapper around the binary API fn a
20727 control plane will call, which expects this increment
20728 to have occurred. Hence letting the binary API control
20729 plane fn do the increment for consistency between VAT
20730 and other control planes.
20733 vec_add1 (low_ports, this_low);
20734 vec_add1 (high_ports, this_hi);
20740 if (prefix_set == 0)
20742 errmsg ("<address>/<mask> not specified");
20748 errmsg ("VRF ID required, not specified");
20755 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20759 if (vec_len (low_ports) == 0)
20761 errmsg ("At least one port or port range required");
20765 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20767 mp->is_add = is_add;
20772 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20777 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20780 mp->mask_length = length;
20781 mp->number_of_ranges = vec_len (low_ports);
20783 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20784 vec_free (low_ports);
20786 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20787 vec_free (high_ports);
20789 mp->vrf_id = ntohl (vrf_id);
20797 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20799 unformat_input_t *input = vam->input;
20800 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20801 u32 sw_if_index = ~0;
20803 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20804 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20808 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20810 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20812 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20814 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20816 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20818 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20820 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20822 else if (unformat (input, "del"))
20828 if (sw_if_index == ~0)
20830 errmsg ("Interface required but not specified");
20836 errmsg ("VRF ID required but not specified");
20840 if (tcp_out_vrf_id == 0
20841 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20844 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20848 /* Construct the API message */
20849 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20851 mp->sw_if_index = ntohl (sw_if_index);
20852 mp->is_add = is_add;
20853 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20854 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20855 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20856 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20861 /* Wait for a reply... */
20867 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20869 unformat_input_t *i = vam->input;
20870 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20871 u32 local_sa_id = 0;
20872 u32 remote_sa_id = 0;
20873 ip4_address_t src_address;
20874 ip4_address_t dst_address;
20878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20880 if (unformat (i, "local_sa %d", &local_sa_id))
20882 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20884 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20886 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20888 else if (unformat (i, "del"))
20892 clib_warning ("parse error '%U'", format_unformat_error, i);
20897 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20899 mp->local_sa_id = ntohl (local_sa_id);
20900 mp->remote_sa_id = ntohl (remote_sa_id);
20901 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20902 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20903 mp->is_add = is_add;
20911 api_punt (vat_main_t * vam)
20913 unformat_input_t *i = vam->input;
20921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20923 if (unformat (i, "ip %d", &ipv))
20925 else if (unformat (i, "protocol %d", &protocol))
20927 else if (unformat (i, "port %d", &port))
20929 else if (unformat (i, "del"))
20933 clib_warning ("parse error '%U'", format_unformat_error, i);
20940 mp->is_add = (u8) is_add;
20941 mp->ipv = (u8) ipv;
20942 mp->l4_protocol = (u8) protocol;
20943 mp->l4_port = htons ((u16) port);
20950 static void vl_api_ipsec_gre_tunnel_details_t_handler
20951 (vl_api_ipsec_gre_tunnel_details_t * mp)
20953 vat_main_t *vam = &vat_main;
20955 print (vam->ofp, "%11d%15U%15U%14d%14d",
20956 ntohl (mp->sw_if_index),
20957 format_ip4_address, &mp->src_address,
20958 format_ip4_address, &mp->dst_address,
20959 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20962 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20963 (vl_api_ipsec_gre_tunnel_details_t * mp)
20965 vat_main_t *vam = &vat_main;
20966 vat_json_node_t *node = NULL;
20967 struct in_addr ip4;
20969 if (VAT_JSON_ARRAY != vam->json_tree.type)
20971 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20972 vat_json_init_array (&vam->json_tree);
20974 node = vat_json_array_add (&vam->json_tree);
20976 vat_json_init_object (node);
20977 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20978 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20979 vat_json_object_add_ip4 (node, "src_address", ip4);
20980 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20981 vat_json_object_add_ip4 (node, "dst_address", ip4);
20982 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20983 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20987 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20989 unformat_input_t *i = vam->input;
20990 vl_api_ipsec_gre_tunnel_dump_t *mp;
20991 vl_api_control_ping_t *mp_ping;
20993 u8 sw_if_index_set = 0;
20996 /* Parse args required to build the message */
20997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20999 if (unformat (i, "sw_if_index %d", &sw_if_index))
21000 sw_if_index_set = 1;
21005 if (sw_if_index_set == 0)
21010 if (!vam->json_output)
21012 print (vam->ofp, "%11s%15s%15s%14s%14s",
21013 "sw_if_index", "src_address", "dst_address",
21014 "local_sa_id", "remote_sa_id");
21017 /* Get list of gre-tunnel interfaces */
21018 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21020 mp->sw_if_index = htonl (sw_if_index);
21024 /* Use a control ping for synchronization */
21025 MPING (CONTROL_PING, mp_ping);
21033 api_delete_subif (vat_main_t * vam)
21035 unformat_input_t *i = vam->input;
21036 vl_api_delete_subif_t *mp;
21037 u32 sw_if_index = ~0;
21040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21044 if (unformat (i, "sw_if_index %d", &sw_if_index))
21050 if (sw_if_index == ~0)
21052 errmsg ("missing sw_if_index");
21056 /* Construct the API message */
21057 M (DELETE_SUBIF, mp);
21058 mp->sw_if_index = ntohl (sw_if_index);
21065 #define foreach_pbb_vtr_op \
21066 _("disable", L2_VTR_DISABLED) \
21067 _("pop", L2_VTR_POP_2) \
21068 _("push", L2_VTR_PUSH_2)
21071 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21073 unformat_input_t *i = vam->input;
21074 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21075 u32 sw_if_index = ~0, vtr_op = ~0;
21076 u16 outer_tag = ~0;
21077 u8 dmac[6], smac[6];
21078 u8 dmac_set = 0, smac_set = 0;
21084 /* Shut up coverity */
21085 memset (dmac, 0, sizeof (dmac));
21086 memset (smac, 0, sizeof (smac));
21088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21090 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21094 else if (unformat (i, "vtr_op %d", &vtr_op))
21096 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21099 else if (unformat (i, "translate_pbb_stag"))
21101 if (unformat (i, "%d", &tmp))
21103 vtr_op = L2_VTR_TRANSLATE_2_1;
21109 ("translate_pbb_stag operation requires outer tag definition");
21113 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21115 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21117 else if (unformat (i, "sid %d", &sid))
21119 else if (unformat (i, "vlanid %d", &tmp))
21123 clib_warning ("parse error '%U'", format_unformat_error, i);
21128 if ((sw_if_index == ~0) || (vtr_op == ~0))
21130 errmsg ("missing sw_if_index or vtr operation");
21133 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21134 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21137 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21141 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21142 mp->sw_if_index = ntohl (sw_if_index);
21143 mp->vtr_op = ntohl (vtr_op);
21144 mp->outer_tag = ntohs (outer_tag);
21145 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21146 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21147 mp->b_vlanid = ntohs (vlanid);
21148 mp->i_sid = ntohl (sid);
21156 api_flow_classify_set_interface (vat_main_t * vam)
21158 unformat_input_t *i = vam->input;
21159 vl_api_flow_classify_set_interface_t *mp;
21161 int sw_if_index_set;
21162 u32 ip4_table_index = ~0;
21163 u32 ip6_table_index = ~0;
21167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21169 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21170 sw_if_index_set = 1;
21171 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21172 sw_if_index_set = 1;
21173 else if (unformat (i, "del"))
21175 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21177 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21181 clib_warning ("parse error '%U'", format_unformat_error, i);
21186 if (sw_if_index_set == 0)
21188 errmsg ("missing interface name or sw_if_index");
21192 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21194 mp->sw_if_index = ntohl (sw_if_index);
21195 mp->ip4_table_index = ntohl (ip4_table_index);
21196 mp->ip6_table_index = ntohl (ip6_table_index);
21197 mp->is_add = is_add;
21205 api_flow_classify_dump (vat_main_t * vam)
21207 unformat_input_t *i = vam->input;
21208 vl_api_flow_classify_dump_t *mp;
21209 vl_api_control_ping_t *mp_ping;
21210 u8 type = FLOW_CLASSIFY_N_TABLES;
21213 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21217 errmsg ("classify table type must be specified");
21221 if (!vam->json_output)
21223 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21226 M (FLOW_CLASSIFY_DUMP, mp);
21231 /* Use a control ping for synchronization */
21232 MPING (CONTROL_PING, mp_ping);
21235 /* Wait for a reply... */
21241 api_feature_enable_disable (vat_main_t * vam)
21243 unformat_input_t *i = vam->input;
21244 vl_api_feature_enable_disable_t *mp;
21246 u8 *feature_name = 0;
21247 u32 sw_if_index = ~0;
21251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21253 if (unformat (i, "arc_name %s", &arc_name))
21255 else if (unformat (i, "feature_name %s", &feature_name))
21258 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21260 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21262 else if (unformat (i, "disable"))
21270 errmsg ("missing arc name");
21273 if (vec_len (arc_name) > 63)
21275 errmsg ("arc name too long");
21278 if (feature_name == 0)
21280 errmsg ("missing feature name");
21283 if (vec_len (feature_name) > 63)
21285 errmsg ("feature name too long");
21288 if (sw_if_index == ~0)
21290 errmsg ("missing interface name or sw_if_index");
21294 /* Construct the API message */
21295 M (FEATURE_ENABLE_DISABLE, mp);
21296 mp->sw_if_index = ntohl (sw_if_index);
21297 mp->enable = enable;
21298 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21299 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21300 vec_free (arc_name);
21301 vec_free (feature_name);
21309 api_sw_interface_tag_add_del (vat_main_t * vam)
21311 unformat_input_t *i = vam->input;
21312 vl_api_sw_interface_tag_add_del_t *mp;
21313 u32 sw_if_index = ~0;
21318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21320 if (unformat (i, "tag %s", &tag))
21322 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21324 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21326 else if (unformat (i, "del"))
21332 if (sw_if_index == ~0)
21334 errmsg ("missing interface name or sw_if_index");
21338 if (enable && (tag == 0))
21340 errmsg ("no tag specified");
21344 /* Construct the API message */
21345 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21346 mp->sw_if_index = ntohl (sw_if_index);
21347 mp->is_add = enable;
21349 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21357 static void vl_api_l2_xconnect_details_t_handler
21358 (vl_api_l2_xconnect_details_t * mp)
21360 vat_main_t *vam = &vat_main;
21362 print (vam->ofp, "%15d%15d",
21363 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21366 static void vl_api_l2_xconnect_details_t_handler_json
21367 (vl_api_l2_xconnect_details_t * mp)
21369 vat_main_t *vam = &vat_main;
21370 vat_json_node_t *node = NULL;
21372 if (VAT_JSON_ARRAY != vam->json_tree.type)
21374 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21375 vat_json_init_array (&vam->json_tree);
21377 node = vat_json_array_add (&vam->json_tree);
21379 vat_json_init_object (node);
21380 vat_json_object_add_uint (node, "rx_sw_if_index",
21381 ntohl (mp->rx_sw_if_index));
21382 vat_json_object_add_uint (node, "tx_sw_if_index",
21383 ntohl (mp->tx_sw_if_index));
21387 api_l2_xconnect_dump (vat_main_t * vam)
21389 vl_api_l2_xconnect_dump_t *mp;
21390 vl_api_control_ping_t *mp_ping;
21393 if (!vam->json_output)
21395 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21398 M (L2_XCONNECT_DUMP, mp);
21402 /* Use a control ping for synchronization */
21403 MPING (CONTROL_PING, mp_ping);
21411 api_sw_interface_set_mtu (vat_main_t * vam)
21413 unformat_input_t *i = vam->input;
21414 vl_api_sw_interface_set_mtu_t *mp;
21415 u32 sw_if_index = ~0;
21419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21421 if (unformat (i, "mtu %d", &mtu))
21423 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21425 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21431 if (sw_if_index == ~0)
21433 errmsg ("missing interface name or sw_if_index");
21439 errmsg ("no mtu specified");
21443 /* Construct the API message */
21444 M (SW_INTERFACE_SET_MTU, mp);
21445 mp->sw_if_index = ntohl (sw_if_index);
21446 mp->mtu = ntohs ((u16) mtu);
21454 api_p2p_ethernet_add (vat_main_t * vam)
21456 unformat_input_t *i = vam->input;
21457 vl_api_p2p_ethernet_add_t *mp;
21458 u32 parent_if_index = ~0;
21464 memset (remote_mac, 0, sizeof (remote_mac));
21465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21467 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21469 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21473 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21475 else if (unformat (i, "sub_id %d", &sub_id))
21479 clib_warning ("parse error '%U'", format_unformat_error, i);
21484 if (parent_if_index == ~0)
21486 errmsg ("missing interface name or sw_if_index");
21491 errmsg ("missing remote mac address");
21496 errmsg ("missing sub-interface id");
21500 M (P2P_ETHERNET_ADD, mp);
21501 mp->parent_if_index = ntohl (parent_if_index);
21502 mp->subif_id = ntohl (sub_id);
21503 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21511 api_p2p_ethernet_del (vat_main_t * vam)
21513 unformat_input_t *i = vam->input;
21514 vl_api_p2p_ethernet_del_t *mp;
21515 u32 parent_if_index = ~0;
21520 memset (remote_mac, 0, sizeof (remote_mac));
21521 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21523 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21525 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21529 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21533 clib_warning ("parse error '%U'", format_unformat_error, i);
21538 if (parent_if_index == ~0)
21540 errmsg ("missing interface name or sw_if_index");
21545 errmsg ("missing remote mac address");
21549 M (P2P_ETHERNET_DEL, mp);
21550 mp->parent_if_index = ntohl (parent_if_index);
21551 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21559 api_lldp_config (vat_main_t * vam)
21561 unformat_input_t *i = vam->input;
21562 vl_api_lldp_config_t *mp;
21564 int tx_interval = 0;
21565 u8 *sys_name = NULL;
21568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21570 if (unformat (i, "system-name %s", &sys_name))
21572 else if (unformat (i, "tx-hold %d", &tx_hold))
21574 else if (unformat (i, "tx-interval %d", &tx_interval))
21578 clib_warning ("parse error '%U'", format_unformat_error, i);
21583 vec_add1 (sys_name, 0);
21585 M (LLDP_CONFIG, mp);
21586 mp->tx_hold = htonl (tx_hold);
21587 mp->tx_interval = htonl (tx_interval);
21588 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21589 vec_free (sys_name);
21597 api_sw_interface_set_lldp (vat_main_t * vam)
21599 unformat_input_t *i = vam->input;
21600 vl_api_sw_interface_set_lldp_t *mp;
21601 u32 sw_if_index = ~0;
21603 u8 *port_desc = NULL, *mgmt_oid = NULL;
21604 ip4_address_t ip4_addr;
21605 ip6_address_t ip6_addr;
21608 memset (&ip4_addr, 0, sizeof (ip4_addr));
21609 memset (&ip6_addr, 0, sizeof (ip6_addr));
21611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21613 if (unformat (i, "disable"))
21616 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21618 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21620 else if (unformat (i, "port-desc %s", &port_desc))
21622 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21624 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21626 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21632 if (sw_if_index == ~0)
21634 errmsg ("missing interface name or sw_if_index");
21638 /* Construct the API message */
21639 vec_add1 (port_desc, 0);
21640 vec_add1 (mgmt_oid, 0);
21641 M (SW_INTERFACE_SET_LLDP, mp);
21642 mp->sw_if_index = ntohl (sw_if_index);
21643 mp->enable = enable;
21644 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21645 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21646 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21647 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21648 vec_free (port_desc);
21649 vec_free (mgmt_oid);
21657 api_tcp_configure_src_addresses (vat_main_t * vam)
21659 vl_api_tcp_configure_src_addresses_t *mp;
21660 unformat_input_t *i = vam->input;
21661 ip4_address_t v4first, v4last;
21662 ip6_address_t v6first, v6last;
21667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21669 if (unformat (i, "%U - %U",
21670 unformat_ip4_address, &v4first,
21671 unformat_ip4_address, &v4last))
21675 errmsg ("one range per message (range already set)");
21680 else if (unformat (i, "%U - %U",
21681 unformat_ip6_address, &v6first,
21682 unformat_ip6_address, &v6last))
21686 errmsg ("one range per message (range already set)");
21691 else if (unformat (i, "vrf %d", &vrf_id))
21697 if (range_set == 0)
21699 errmsg ("address range not set");
21703 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21704 mp->vrf_id = ntohl (vrf_id);
21706 if (range_set == 2)
21709 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21710 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21715 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21716 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21723 static void vl_api_app_namespace_add_del_reply_t_handler
21724 (vl_api_app_namespace_add_del_reply_t * mp)
21726 vat_main_t *vam = &vat_main;
21727 i32 retval = ntohl (mp->retval);
21728 if (vam->async_mode)
21730 vam->async_errors += (retval < 0);
21734 vam->retval = retval;
21736 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21737 vam->result_ready = 1;
21741 static void vl_api_app_namespace_add_del_reply_t_handler_json
21742 (vl_api_app_namespace_add_del_reply_t * mp)
21744 vat_main_t *vam = &vat_main;
21745 vat_json_node_t node;
21747 vat_json_init_object (&node);
21748 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21749 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21751 vat_json_print (vam->ofp, &node);
21752 vat_json_free (&node);
21754 vam->retval = ntohl (mp->retval);
21755 vam->result_ready = 1;
21759 api_app_namespace_add_del (vat_main_t * vam)
21761 vl_api_app_namespace_add_del_t *mp;
21762 unformat_input_t *i = vam->input;
21763 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21764 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21770 if (unformat (i, "id %_%v%_", &ns_id))
21772 else if (unformat (i, "secret %lu", &secret))
21774 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21775 sw_if_index_set = 1;
21776 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21778 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21783 if (!ns_id || !secret_set || !sw_if_index_set)
21785 errmsg ("namespace id, secret and sw_if_index must be set");
21788 if (vec_len (ns_id) > 64)
21790 errmsg ("namespace id too long");
21793 M (APP_NAMESPACE_ADD_DEL, mp);
21795 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21796 mp->namespace_id_len = vec_len (ns_id);
21797 mp->secret = clib_host_to_net_u64 (secret);
21798 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21799 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21800 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21808 api_memfd_segment_create (vat_main_t * vam)
21810 #if VPP_API_TEST_BUILTIN == 0
21811 unformat_input_t *i = vam->input;
21812 vl_api_memfd_segment_create_t *mp;
21813 u64 size = 64 << 20;
21816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21818 if (unformat (i, "size %U", unformat_memory_size, &size))
21824 M (MEMFD_SEGMENT_CREATE, mp);
21825 mp->requested_size = size;
21831 errmsg ("memfd_segment_create (builtin) not supported");
21837 api_sock_init_shm (vat_main_t * vam)
21839 #if VPP_API_TEST_BUILTIN == 0
21840 unformat_input_t *i = vam->input;
21841 vl_api_shm_elem_config_t *config = 0;
21842 u64 size = 64 << 20;
21845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21847 if (unformat (i, "size %U", unformat_memory_size, &size))
21853 /* Try customized config to see if it works */
21854 vec_validate (config, 3);
21855 config[0].type = VL_API_VLIB_RING;
21856 config[0].count = 256;
21857 config[0].size = 256;
21858 config[1].type = VL_API_CLIENT_RING;
21859 config[1].count = 256;
21860 config[1].size = 1024;
21861 config[2].type = VL_API_CLIENT_RING;
21862 config[2].count = 8;
21863 config[2].size = 4096;
21864 config[3].type = VL_API_QUEUE;
21865 config[3].count = 256;
21866 config[3].size = sizeof (uword);
21867 rv = vl_socket_client_init_shm (config);
21869 vam->client_index_invalid = 1;
21877 api_dns_enable_disable (vat_main_t * vam)
21879 unformat_input_t *line_input = vam->input;
21880 vl_api_dns_enable_disable_t *mp;
21881 u8 enable_disable = 1;
21884 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21886 if (unformat (line_input, "disable"))
21887 enable_disable = 0;
21888 if (unformat (line_input, "enable"))
21889 enable_disable = 1;
21894 /* Construct the API message */
21895 M (DNS_ENABLE_DISABLE, mp);
21896 mp->enable = enable_disable;
21900 /* Wait for the reply */
21906 api_dns_resolve_name (vat_main_t * vam)
21908 unformat_input_t *line_input = vam->input;
21909 vl_api_dns_resolve_name_t *mp;
21913 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21915 if (unformat (line_input, "%s", &name))
21921 if (vec_len (name) > 127)
21923 errmsg ("name too long");
21927 /* Construct the API message */
21928 M (DNS_RESOLVE_NAME, mp);
21929 memcpy (mp->name, name, vec_len (name));
21934 /* Wait for the reply */
21940 api_dns_resolve_ip (vat_main_t * vam)
21942 unformat_input_t *line_input = vam->input;
21943 vl_api_dns_resolve_ip_t *mp;
21945 ip4_address_t addr4;
21946 ip6_address_t addr6;
21949 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21951 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21953 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21961 errmsg ("missing address");
21965 /* Construct the API message */
21966 M (DNS_RESOLVE_IP, mp);
21967 mp->is_ip6 = is_ip6;
21969 memcpy (mp->address, &addr6, sizeof (addr6));
21971 memcpy (mp->address, &addr4, sizeof (addr4));
21975 /* Wait for the reply */
21981 api_dns_name_server_add_del (vat_main_t * vam)
21983 unformat_input_t *i = vam->input;
21984 vl_api_dns_name_server_add_del_t *mp;
21986 ip6_address_t ip6_server;
21987 ip4_address_t ip4_server;
21992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21994 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21996 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21998 else if (unformat (i, "del"))
22002 clib_warning ("parse error '%U'", format_unformat_error, i);
22007 if (ip4_set && ip6_set)
22009 errmsg ("Only one server address allowed per message");
22012 if ((ip4_set + ip6_set) == 0)
22014 errmsg ("Server address required");
22018 /* Construct the API message */
22019 M (DNS_NAME_SERVER_ADD_DEL, mp);
22023 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22028 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22032 mp->is_add = is_add;
22037 /* Wait for a reply, return good/bad news */
22043 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22045 vat_main_t *vam = &vat_main;
22050 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22051 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22052 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22053 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22054 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22055 clib_net_to_host_u32 (mp->action_index), mp->tag);
22060 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22061 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22062 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22063 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22064 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22065 clib_net_to_host_u32 (mp->action_index), mp->tag);
22070 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22073 vat_main_t *vam = &vat_main;
22074 vat_json_node_t *node = NULL;
22075 struct in6_addr ip6;
22076 struct in_addr ip4;
22078 if (VAT_JSON_ARRAY != vam->json_tree.type)
22080 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22081 vat_json_init_array (&vam->json_tree);
22083 node = vat_json_array_add (&vam->json_tree);
22084 vat_json_init_object (node);
22086 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22087 vat_json_object_add_uint (node, "appns_index",
22088 clib_net_to_host_u32 (mp->appns_index));
22089 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22090 vat_json_object_add_uint (node, "scope", mp->scope);
22091 vat_json_object_add_uint (node, "action_index",
22092 clib_net_to_host_u32 (mp->action_index));
22093 vat_json_object_add_uint (node, "lcl_port",
22094 clib_net_to_host_u16 (mp->lcl_port));
22095 vat_json_object_add_uint (node, "rmt_port",
22096 clib_net_to_host_u16 (mp->rmt_port));
22097 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22098 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22099 vat_json_object_add_string_copy (node, "tag", mp->tag);
22102 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22103 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22104 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22105 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22109 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22110 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22111 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22112 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22117 api_session_rule_add_del (vat_main_t * vam)
22119 vl_api_session_rule_add_del_t *mp;
22120 unformat_input_t *i = vam->input;
22121 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22122 u32 appns_index = 0, scope = 0;
22123 ip4_address_t lcl_ip4, rmt_ip4;
22124 ip6_address_t lcl_ip6, rmt_ip6;
22125 u8 is_ip4 = 1, conn_set = 0;
22126 u8 is_add = 1, *tag = 0;
22129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22131 if (unformat (i, "del"))
22133 else if (unformat (i, "add"))
22135 else if (unformat (i, "proto tcp"))
22137 else if (unformat (i, "proto udp"))
22139 else if (unformat (i, "appns %d", &appns_index))
22141 else if (unformat (i, "scope %d", &scope))
22143 else if (unformat (i, "tag %_%v%_", &tag))
22147 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22148 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22156 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22157 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22163 else if (unformat (i, "action %d", &action))
22168 if (proto == ~0 || !conn_set || action == ~0)
22170 errmsg ("transport proto, connection and action must be set");
22176 errmsg ("scope should be 0-3");
22180 M (SESSION_RULE_ADD_DEL, mp);
22182 mp->is_ip4 = is_ip4;
22183 mp->transport_proto = proto;
22184 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22185 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22186 mp->lcl_plen = lcl_plen;
22187 mp->rmt_plen = rmt_plen;
22188 mp->action_index = clib_host_to_net_u32 (action);
22189 mp->appns_index = clib_host_to_net_u32 (appns_index);
22191 mp->is_add = is_add;
22194 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22195 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22199 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22200 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22204 clib_memcpy (mp->tag, tag, vec_len (tag));
22214 api_session_rules_dump (vat_main_t * vam)
22216 vl_api_session_rules_dump_t *mp;
22217 vl_api_control_ping_t *mp_ping;
22220 if (!vam->json_output)
22222 print (vam->ofp, "%=20s", "Session Rules");
22225 M (SESSION_RULES_DUMP, mp);
22229 /* Use a control ping for synchronization */
22230 MPING (CONTROL_PING, mp_ping);
22233 /* Wait for a reply... */
22239 api_ip_container_proxy_add_del (vat_main_t * vam)
22241 vl_api_ip_container_proxy_add_del_t *mp;
22242 unformat_input_t *i = vam->input;
22243 u32 plen = ~0, sw_if_index = ~0;
22250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22252 if (unformat (i, "del"))
22254 else if (unformat (i, "add"))
22256 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22261 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22266 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22271 if (sw_if_index == ~0 || plen == ~0)
22273 errmsg ("address and sw_if_index must be set");
22277 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22279 mp->is_ip4 = is_ip4;
22280 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22282 mp->is_add = is_add;
22284 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22286 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22294 q_or_quit (vat_main_t * vam)
22296 #if VPP_API_TEST_BUILTIN == 0
22297 longjmp (vam->jump_buf, 1);
22299 return 0; /* not so much */
22303 q (vat_main_t * vam)
22305 return q_or_quit (vam);
22309 quit (vat_main_t * vam)
22311 return q_or_quit (vam);
22315 comment (vat_main_t * vam)
22321 cmd_cmp (void *a1, void *a2)
22326 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22330 help (vat_main_t * vam)
22335 unformat_input_t *i = vam->input;
22338 if (unformat (i, "%s", &name))
22342 vec_add1 (name, 0);
22344 hs = hash_get_mem (vam->help_by_name, name);
22346 print (vam->ofp, "usage: %s %s", name, hs[0]);
22348 print (vam->ofp, "No such msg / command '%s'", name);
22353 print (vam->ofp, "Help is available for the following:");
22356 hash_foreach_pair (p, vam->function_by_name,
22358 vec_add1 (cmds, (u8 *)(p->key));
22362 vec_sort_with_function (cmds, cmd_cmp);
22364 for (j = 0; j < vec_len (cmds); j++)
22365 print (vam->ofp, "%s", cmds[j]);
22372 set (vat_main_t * vam)
22374 u8 *name = 0, *value = 0;
22375 unformat_input_t *i = vam->input;
22377 if (unformat (i, "%s", &name))
22379 /* The input buffer is a vector, not a string. */
22380 value = vec_dup (i->buffer);
22381 vec_delete (value, i->index, 0);
22382 /* Almost certainly has a trailing newline */
22383 if (value[vec_len (value) - 1] == '\n')
22384 value[vec_len (value) - 1] = 0;
22385 /* Make sure it's a proper string, one way or the other */
22386 vec_add1 (value, 0);
22387 (void) clib_macro_set_value (&vam->macro_main,
22388 (char *) name, (char *) value);
22391 errmsg ("usage: set <name> <value>");
22399 unset (vat_main_t * vam)
22403 if (unformat (vam->input, "%s", &name))
22404 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22405 errmsg ("unset: %s wasn't set", name);
22418 macro_sort_cmp (void *a1, void *a2)
22420 macro_sort_t *s1 = a1;
22421 macro_sort_t *s2 = a2;
22423 return strcmp ((char *) (s1->name), (char *) (s2->name));
22427 dump_macro_table (vat_main_t * vam)
22429 macro_sort_t *sort_me = 0, *sm;
22434 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22436 vec_add2 (sort_me, sm, 1);
22437 sm->name = (u8 *)(p->key);
22438 sm->value = (u8 *) (p->value[0]);
22442 vec_sort_with_function (sort_me, macro_sort_cmp);
22444 if (vec_len (sort_me))
22445 print (vam->ofp, "%-15s%s", "Name", "Value");
22447 print (vam->ofp, "The macro table is empty...");
22449 for (i = 0; i < vec_len (sort_me); i++)
22450 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22455 dump_node_table (vat_main_t * vam)
22458 vlib_node_t *node, *next_node;
22460 if (vec_len (vam->graph_nodes) == 0)
22462 print (vam->ofp, "Node table empty, issue get_node_graph...");
22466 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22468 node = vam->graph_nodes[i];
22469 print (vam->ofp, "[%d] %s", i, node->name);
22470 for (j = 0; j < vec_len (node->next_nodes); j++)
22472 if (node->next_nodes[j] != ~0)
22474 next_node = vam->graph_nodes[node->next_nodes[j]];
22475 print (vam->ofp, " [%d] %s", j, next_node->name);
22483 value_sort_cmp (void *a1, void *a2)
22485 name_sort_t *n1 = a1;
22486 name_sort_t *n2 = a2;
22488 if (n1->value < n2->value)
22490 if (n1->value > n2->value)
22497 dump_msg_api_table (vat_main_t * vam)
22499 api_main_t *am = &api_main;
22500 name_sort_t *nses = 0, *ns;
22505 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22507 vec_add2 (nses, ns, 1);
22508 ns->name = (u8 *)(hp->key);
22509 ns->value = (u32) hp->value[0];
22513 vec_sort_with_function (nses, value_sort_cmp);
22515 for (i = 0; i < vec_len (nses); i++)
22516 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22522 get_msg_id (vat_main_t * vam)
22527 if (unformat (vam->input, "%s", &name_and_crc))
22529 message_index = vl_msg_api_get_msg_index (name_and_crc);
22530 if (message_index == ~0)
22532 print (vam->ofp, " '%s' not found", name_and_crc);
22535 print (vam->ofp, " '%s' has message index %d",
22536 name_and_crc, message_index);
22539 errmsg ("name_and_crc required...");
22544 search_node_table (vat_main_t * vam)
22546 unformat_input_t *line_input = vam->input;
22549 vlib_node_t *node, *next_node;
22552 if (vam->graph_node_index_by_name == 0)
22554 print (vam->ofp, "Node table empty, issue get_node_graph...");
22558 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22560 if (unformat (line_input, "%s", &node_to_find))
22562 vec_add1 (node_to_find, 0);
22563 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22566 print (vam->ofp, "%s not found...", node_to_find);
22569 node = vam->graph_nodes[p[0]];
22570 print (vam->ofp, "[%d] %s", p[0], node->name);
22571 for (j = 0; j < vec_len (node->next_nodes); j++)
22573 if (node->next_nodes[j] != ~0)
22575 next_node = vam->graph_nodes[node->next_nodes[j]];
22576 print (vam->ofp, " [%d] %s", j, next_node->name);
22583 clib_warning ("parse error '%U'", format_unformat_error,
22589 vec_free (node_to_find);
22598 script (vat_main_t * vam)
22600 #if (VPP_API_TEST_BUILTIN==0)
22602 char *save_current_file;
22603 unformat_input_t save_input;
22604 jmp_buf save_jump_buf;
22605 u32 save_line_number;
22607 FILE *new_fp, *save_ifp;
22609 if (unformat (vam->input, "%s", &s))
22611 new_fp = fopen ((char *) s, "r");
22614 errmsg ("Couldn't open script file %s", s);
22621 errmsg ("Missing script name");
22625 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22626 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22627 save_ifp = vam->ifp;
22628 save_line_number = vam->input_line_number;
22629 save_current_file = (char *) vam->current_file;
22631 vam->input_line_number = 0;
22633 vam->current_file = s;
22636 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22637 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22638 vam->ifp = save_ifp;
22639 vam->input_line_number = save_line_number;
22640 vam->current_file = (u8 *) save_current_file;
22645 clib_warning ("use the exec command...");
22651 echo (vat_main_t * vam)
22653 print (vam->ofp, "%v", vam->input->buffer);
22657 /* List of API message constructors, CLI names map to api_xxx */
22658 #define foreach_vpe_api_msg \
22659 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22660 _(sw_interface_dump,"") \
22661 _(sw_interface_set_flags, \
22662 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22663 _(sw_interface_add_del_address, \
22664 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22665 _(sw_interface_set_rx_mode, \
22666 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22667 _(sw_interface_set_table, \
22668 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22669 _(sw_interface_set_mpls_enable, \
22670 "<intfc> | sw_if_index [disable | dis]") \
22671 _(sw_interface_set_vpath, \
22672 "<intfc> | sw_if_index <id> enable | disable") \
22673 _(sw_interface_set_vxlan_bypass, \
22674 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22675 _(sw_interface_set_geneve_bypass, \
22676 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22677 _(sw_interface_set_l2_xconnect, \
22678 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22679 "enable | disable") \
22680 _(sw_interface_set_l2_bridge, \
22681 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22682 "[shg <split-horizon-group>] [bvi]\n" \
22683 "enable | disable") \
22684 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22685 _(bridge_domain_add_del, \
22686 "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") \
22687 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22689 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22690 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22691 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22693 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22695 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22697 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22699 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22701 "<vpp-if-name> | sw_if_index <id>") \
22702 _(sw_interface_tap_dump, "") \
22704 "name <name> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22706 "<vpp-if-name> | sw_if_index <id>") \
22707 _(sw_interface_tap_v2_dump, "") \
22708 _(ip_table_add_del, \
22709 "table-id <n> [ipv6]\n") \
22710 _(ip_add_del_route, \
22711 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22712 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22713 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22714 "[multipath] [count <n>]") \
22715 _(ip_mroute_add_del, \
22716 "<src> <grp>/<mask> [table-id <n>]\n" \
22717 "[<intfc> | sw_if_index <id>] [local] [del]") \
22718 _(mpls_table_add_del, \
22719 "table-id <n>\n") \
22720 _(mpls_route_add_del, \
22721 "<label> <eos> via <addr> [table-id <n>]\n" \
22722 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22723 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22724 "[multipath] [count <n>]") \
22725 _(mpls_ip_bind_unbind, \
22726 "<label> <addr/len>") \
22727 _(mpls_tunnel_add_del, \
22728 " via <addr> [table-id <n>]\n" \
22729 "sw_if_index <id>] [l2] [del]") \
22730 _(bier_table_add_del, \
22731 "<label> <sub-domain> <set> <bsl> [del]") \
22732 _(bier_route_add_del, \
22733 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22734 "[<intfc> | sw_if_index <id>]" \
22735 "[weight <n>] [del] [multipath]") \
22736 _(proxy_arp_add_del, \
22737 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22738 _(proxy_arp_intfc_enable_disable, \
22739 "<intfc> | sw_if_index <id> enable | disable") \
22740 _(sw_interface_set_unnumbered, \
22741 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22742 _(ip_neighbor_add_del, \
22743 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22744 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22745 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22746 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22747 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22748 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22749 "[outer_vlan_id_any][inner_vlan_id_any]") \
22750 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22751 _(reset_fib, "vrf <n> [ipv6]") \
22752 _(dhcp_proxy_config, \
22753 "svr <v46-address> src <v46-address>\n" \
22754 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22755 _(dhcp_proxy_set_vss, \
22756 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22757 _(dhcp_proxy_dump, "ip6") \
22758 _(dhcp_client_config, \
22759 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22760 _(set_ip_flow_hash, \
22761 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22762 _(sw_interface_ip6_enable_disable, \
22763 "<intfc> | sw_if_index <id> enable | disable") \
22764 _(sw_interface_ip6_set_link_local_address, \
22765 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22766 _(ip6nd_proxy_add_del, \
22767 "<intfc> | sw_if_index <id> <ip6-address>") \
22768 _(ip6nd_proxy_dump, "") \
22769 _(sw_interface_ip6nd_ra_prefix, \
22770 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22771 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22772 "[nolink] [isno]") \
22773 _(sw_interface_ip6nd_ra_config, \
22774 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22775 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22776 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22777 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22778 _(l2_patch_add_del, \
22779 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22780 "enable | disable") \
22781 _(sr_localsid_add_del, \
22782 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22783 "fib-table <num> (end.psp) sw_if_index <num>") \
22784 _(classify_add_del_table, \
22785 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22786 " [del] [del-chain] mask <mask-value>\n" \
22787 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22788 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22789 _(classify_add_del_session, \
22790 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22791 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22792 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22793 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22794 _(classify_set_interface_ip_table, \
22795 "<intfc> | sw_if_index <nn> table <nn>") \
22796 _(classify_set_interface_l2_tables, \
22797 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22798 " [other-table <nn>]") \
22799 _(get_node_index, "node <node-name") \
22800 _(add_node_next, "node <node-name> next <next-node-name>") \
22801 _(l2tpv3_create_tunnel, \
22802 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22803 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22804 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22805 _(l2tpv3_set_tunnel_cookies, \
22806 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22807 "[new_remote_cookie <nn>]\n") \
22808 _(l2tpv3_interface_enable_disable, \
22809 "<intfc> | sw_if_index <nn> enable | disable") \
22810 _(l2tpv3_set_lookup_key, \
22811 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22812 _(sw_if_l2tpv3_tunnel_dump, "") \
22813 _(vxlan_add_del_tunnel, \
22814 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22815 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22816 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22817 _(geneve_add_del_tunnel, \
22818 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22819 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22820 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22821 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22822 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22823 _(gre_add_del_tunnel, \
22824 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22825 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22826 _(l2_fib_clear_table, "") \
22827 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22828 _(l2_interface_vlan_tag_rewrite, \
22829 "<intfc> | sw_if_index <nn> \n" \
22830 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22831 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22832 _(create_vhost_user_if, \
22833 "socket <filename> [server] [renumber <dev_instance>] " \
22834 "[mac <mac_address>]") \
22835 _(modify_vhost_user_if, \
22836 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22837 "[server] [renumber <dev_instance>]") \
22838 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22839 _(sw_interface_vhost_user_dump, "") \
22840 _(show_version, "") \
22841 _(vxlan_gpe_add_del_tunnel, \
22842 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22843 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22844 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22845 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22846 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22847 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22848 _(interface_name_renumber, \
22849 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22850 _(input_acl_set_interface, \
22851 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22852 " [l2-table <nn>] [del]") \
22853 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22854 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22855 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22856 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22857 _(ip_dump, "ipv4 | ipv6") \
22858 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22859 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22861 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22862 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22863 " integ_alg <alg> integ_key <hex>") \
22864 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22865 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22866 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22867 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22868 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22869 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22870 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22871 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22872 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22873 _(ipsec_sa_dump, "[sa_id <n>]") \
22874 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22875 " <alg> <hex>\n") \
22876 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22877 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22878 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22879 "(auth_data 0x<data> | auth_data <data>)") \
22880 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22881 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22882 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22883 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22884 "(local|remote)") \
22885 _(ikev2_set_local_key, "file <absolute_file_path>") \
22886 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22887 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22888 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22889 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22890 _(ikev2_initiate_sa_init, "<profile_name>") \
22891 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22892 _(ikev2_initiate_del_child_sa, "<ispi>") \
22893 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22894 _(delete_loopback,"sw_if_index <nn>") \
22895 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22896 _(map_add_domain, \
22897 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22898 "ip6-src <ip6addr> " \
22899 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22900 _(map_del_domain, "index <n>") \
22901 _(map_add_del_rule, \
22902 "index <n> psid <n> dst <ip6addr> [del]") \
22903 _(map_domain_dump, "") \
22904 _(map_rule_dump, "index <map-domain>") \
22905 _(want_interface_events, "enable|disable") \
22906 _(want_stats,"enable|disable") \
22907 _(get_first_msg_id, "client <name>") \
22908 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22909 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22910 "fib-id <nn> [ip4][ip6][default]") \
22911 _(get_node_graph, " ") \
22912 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22913 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22914 _(ioam_disable, "") \
22915 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22916 " sw_if_index <sw_if_index> p <priority> " \
22917 "w <weight>] [del]") \
22918 _(one_add_del_locator, "locator-set <locator_name> " \
22919 "iface <intf> | sw_if_index <sw_if_index> " \
22920 "p <priority> w <weight> [del]") \
22921 _(one_add_del_local_eid,"vni <vni> eid " \
22922 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22923 "locator-set <locator_name> [del]" \
22924 "[key-id sha1|sha256 secret-key <secret-key>]")\
22925 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22926 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22927 _(one_enable_disable, "enable|disable") \
22928 _(one_map_register_enable_disable, "enable|disable") \
22929 _(one_map_register_fallback_threshold, "<value>") \
22930 _(one_rloc_probe_enable_disable, "enable|disable") \
22931 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22933 "rloc <locator> p <prio> " \
22934 "w <weight> [rloc <loc> ... ] " \
22935 "action <action> [del-all]") \
22936 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22938 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22939 _(one_use_petr, "ip-address> | disable") \
22940 _(one_map_request_mode, "src-dst|dst-only") \
22941 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22942 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22943 _(one_locator_set_dump, "[local | remote]") \
22944 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22945 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22946 "[local] | [remote]") \
22947 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22948 _(one_ndp_bd_get, "") \
22949 _(one_ndp_entries_get, "bd <bridge-domain>") \
22950 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22951 _(one_l2_arp_bd_get, "") \
22952 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22953 _(one_stats_enable_disable, "enable|disalbe") \
22954 _(show_one_stats_enable_disable, "") \
22955 _(one_eid_table_vni_dump, "") \
22956 _(one_eid_table_map_dump, "l2|l3") \
22957 _(one_map_resolver_dump, "") \
22958 _(one_map_server_dump, "") \
22959 _(one_adjacencies_get, "vni <vni>") \
22960 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22961 _(show_one_rloc_probe_state, "") \
22962 _(show_one_map_register_state, "") \
22963 _(show_one_status, "") \
22964 _(one_stats_dump, "") \
22965 _(one_stats_flush, "") \
22966 _(one_get_map_request_itr_rlocs, "") \
22967 _(one_map_register_set_ttl, "<ttl>") \
22968 _(one_set_transport_protocol, "udp|api") \
22969 _(one_get_transport_protocol, "") \
22970 _(one_enable_disable_xtr_mode, "enable|disable") \
22971 _(one_show_xtr_mode, "") \
22972 _(one_enable_disable_pitr_mode, "enable|disable") \
22973 _(one_show_pitr_mode, "") \
22974 _(one_enable_disable_petr_mode, "enable|disable") \
22975 _(one_show_petr_mode, "") \
22976 _(show_one_nsh_mapping, "") \
22977 _(show_one_pitr, "") \
22978 _(show_one_use_petr, "") \
22979 _(show_one_map_request_mode, "") \
22980 _(show_one_map_register_ttl, "") \
22981 _(show_one_map_register_fallback_threshold, "") \
22982 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22983 " sw_if_index <sw_if_index> p <priority> " \
22984 "w <weight>] [del]") \
22985 _(lisp_add_del_locator, "locator-set <locator_name> " \
22986 "iface <intf> | sw_if_index <sw_if_index> " \
22987 "p <priority> w <weight> [del]") \
22988 _(lisp_add_del_local_eid,"vni <vni> eid " \
22989 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22990 "locator-set <locator_name> [del]" \
22991 "[key-id sha1|sha256 secret-key <secret-key>]") \
22992 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22993 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22994 _(lisp_enable_disable, "enable|disable") \
22995 _(lisp_map_register_enable_disable, "enable|disable") \
22996 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22997 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22999 "rloc <locator> p <prio> " \
23000 "w <weight> [rloc <loc> ... ] " \
23001 "action <action> [del-all]") \
23002 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23004 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23005 _(lisp_use_petr, "<ip-address> | disable") \
23006 _(lisp_map_request_mode, "src-dst|dst-only") \
23007 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23008 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23009 _(lisp_locator_set_dump, "[local | remote]") \
23010 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
23011 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23012 "[local] | [remote]") \
23013 _(lisp_eid_table_vni_dump, "") \
23014 _(lisp_eid_table_map_dump, "l2|l3") \
23015 _(lisp_map_resolver_dump, "") \
23016 _(lisp_map_server_dump, "") \
23017 _(lisp_adjacencies_get, "vni <vni>") \
23018 _(gpe_fwd_entry_vnis_get, "") \
23019 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23020 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23021 "[table <table-id>]") \
23022 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23023 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23024 _(gpe_set_encap_mode, "lisp|vxlan") \
23025 _(gpe_get_encap_mode, "") \
23026 _(lisp_gpe_add_del_iface, "up|down") \
23027 _(lisp_gpe_enable_disable, "enable|disable") \
23028 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23029 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23030 _(show_lisp_rloc_probe_state, "") \
23031 _(show_lisp_map_register_state, "") \
23032 _(show_lisp_status, "") \
23033 _(lisp_get_map_request_itr_rlocs, "") \
23034 _(show_lisp_pitr, "") \
23035 _(show_lisp_use_petr, "") \
23036 _(show_lisp_map_request_mode, "") \
23037 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23038 _(af_packet_delete, "name <host interface name>") \
23039 _(policer_add_del, "name <policer name> <params> [del]") \
23040 _(policer_dump, "[name <policer name>]") \
23041 _(policer_classify_set_interface, \
23042 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23043 " [l2-table <nn>] [del]") \
23044 _(policer_classify_dump, "type [ip4|ip6|l2]") \
23045 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
23046 "[master|slave]") \
23047 _(netmap_delete, "name <interface name>") \
23048 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
23049 _(mpls_fib_dump, "") \
23050 _(classify_table_ids, "") \
23051 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
23052 _(classify_table_info, "table_id <nn>") \
23053 _(classify_session_dump, "table_id <nn>") \
23054 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
23055 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
23056 "[template_interval <nn>] [udp_checksum]") \
23057 _(ipfix_exporter_dump, "") \
23058 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
23059 _(ipfix_classify_stream_dump, "") \
23060 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
23061 _(ipfix_classify_table_dump, "") \
23062 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
23063 _(sw_interface_span_dump, "[l2]") \
23064 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
23065 _(pg_create_interface, "if_id <nn>") \
23066 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
23067 _(pg_enable_disable, "[stream <id>] disable") \
23068 _(ip_source_and_port_range_check_add_del, \
23069 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
23070 _(ip_source_and_port_range_check_interface_add_del, \
23071 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23072 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23073 _(ipsec_gre_add_del_tunnel, \
23074 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23075 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23076 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23077 _(l2_interface_pbb_tag_rewrite, \
23078 "<intfc> | sw_if_index <nn> \n" \
23079 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23080 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23081 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23082 _(flow_classify_set_interface, \
23083 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23084 _(flow_classify_dump, "type [ip4|ip6]") \
23085 _(ip_fib_dump, "") \
23086 _(ip_mfib_dump, "") \
23087 _(ip6_fib_dump, "") \
23088 _(ip6_mfib_dump, "") \
23089 _(feature_enable_disable, "arc_name <arc_name> " \
23090 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23091 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23093 _(l2_xconnect_dump, "") \
23094 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23095 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23096 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23097 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23098 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23099 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23100 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23101 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23102 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23103 _(memfd_segment_create,"size <nnn>") \
23104 _(sock_init_shm, "size <nnn>") \
23105 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23106 _(dns_enable_disable, "[enable][disable]") \
23107 _(dns_name_server_add_del, "<ip-address> [del]") \
23108 _(dns_resolve_name, "<hostname>") \
23109 _(dns_resolve_ip, "<ip4|ip6>") \
23110 _(dns_name_server_add_del, "<ip-address> [del]") \
23111 _(dns_resolve_name, "<hostname>") \
23112 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23113 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23114 _(session_rules_dump, "") \
23115 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23117 /* List of command functions, CLI names map directly to functions */
23118 #define foreach_cli_function \
23119 _(comment, "usage: comment <ignore-rest-of-line>") \
23120 _(dump_interface_table, "usage: dump_interface_table") \
23121 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23122 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23123 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23124 _(dump_stats_table, "usage: dump_stats_table") \
23125 _(dump_macro_table, "usage: dump_macro_table ") \
23126 _(dump_node_table, "usage: dump_node_table") \
23127 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23128 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23129 _(echo, "usage: echo <message>") \
23130 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23131 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23132 _(help, "usage: help") \
23133 _(q, "usage: quit") \
23134 _(quit, "usage: quit") \
23135 _(search_node_table, "usage: search_node_table <name>...") \
23136 _(set, "usage: set <variable-name> <value>") \
23137 _(script, "usage: script <file-name>") \
23138 _(unset, "usage: unset <variable-name>")
23140 static void vl_api_##n##_t_handler_uni \
23141 (vl_api_##n##_t * mp) \
23143 vat_main_t * vam = &vat_main; \
23144 if (vam->json_output) { \
23145 vl_api_##n##_t_handler_json(mp); \
23147 vl_api_##n##_t_handler(mp); \
23150 foreach_vpe_api_reply_msg;
23151 #if VPP_API_TEST_BUILTIN == 0
23152 foreach_standalone_reply_msg;
23157 vat_api_hookup (vat_main_t * vam)
23160 vl_msg_api_set_handlers(VL_API_##N, #n, \
23161 vl_api_##n##_t_handler_uni, \
23163 vl_api_##n##_t_endian, \
23164 vl_api_##n##_t_print, \
23165 sizeof(vl_api_##n##_t), 1);
23166 foreach_vpe_api_reply_msg;
23167 #if VPP_API_TEST_BUILTIN == 0
23168 foreach_standalone_reply_msg;
23172 #if (VPP_API_TEST_BUILTIN==0)
23173 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23175 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23177 vam->function_by_name = hash_create_string (0, sizeof (uword));
23179 vam->help_by_name = hash_create_string (0, sizeof (uword));
23182 /* API messages we can send */
23183 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23184 foreach_vpe_api_msg;
23188 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23189 foreach_vpe_api_msg;
23192 /* CLI functions */
23193 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23194 foreach_cli_function;
23198 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23199 foreach_cli_function;
23203 #if VPP_API_TEST_BUILTIN
23204 static clib_error_t *
23205 vat_api_hookup_shim (vlib_main_t * vm)
23207 vat_api_hookup (&vat_main);
23211 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23215 * fd.io coding-style-patch-verification: ON
23218 * eval: (c-set-style "gnu")