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 u32 host_ip4_prefix_len = 0;
7776 ip6_address_t host_ip6_addr;
7777 u32 host_ip6_prefix_len = 0;
7779 int rx_ring_sz = 0, tx_ring_sz = 0;
7781 memset (mac_address, 0, sizeof (mac_address));
7783 /* Parse args required to build the message */
7784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7786 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7790 else if (unformat (i, "id %s", &id))
7792 else if (unformat (i, "host-if-name %s", &host_if_name))
7794 else if (unformat (i, "host-ns %s", &host_ns))
7796 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7798 host_mac_addr_set = 1;
7799 else if (unformat (i, "host-bridge %s", &host_bridge))
7801 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7802 &host_ip4_addr, &host_ip4_prefix_len))
7804 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7805 &host_ip6_addr, &host_ip6_prefix_len))
7807 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7809 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7815 if (vec_len (host_if_name) > 63)
7817 errmsg ("tap name too long. ");
7820 if (vec_len (host_ns) > 63)
7822 errmsg ("host name space too long. ");
7825 if (vec_len (host_bridge) > 63)
7827 errmsg ("host bridge name too long. ");
7830 if (host_ip4_prefix_len > 32)
7832 errmsg ("host ip4 prefix length not valid. ");
7835 if (host_ip6_prefix_len > 128)
7837 errmsg ("host ip6 prefix length not valid. ");
7840 if (!is_pow2 (rx_ring_sz))
7842 errmsg ("rx ring size must be power of 2. ");
7845 if (rx_ring_sz > 32768)
7847 errmsg ("rx ring size must be 32768 or lower. ");
7850 if (!is_pow2 (tx_ring_sz))
7852 errmsg ("tx ring size must be power of 2. ");
7855 if (tx_ring_sz > 32768)
7857 errmsg ("tx ring size must be 32768 or lower. ");
7861 /* Construct the API message */
7862 M (TAP_CREATE_V2, mp);
7864 mp->use_random_mac = random_mac;
7867 mp->host_namespace_set = host_ns != 0;
7868 mp->host_bridge_set = host_bridge != 0;
7869 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7870 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7871 mp->rx_ring_sz = rx_ring_sz;
7872 mp->tx_ring_sz = tx_ring_sz;
7875 clib_memcpy (mp->mac_address, mac_address, 6);
7876 if (host_mac_addr_set)
7877 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7879 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7881 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7883 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7884 if (host_ip4_prefix_len)
7885 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7886 if (host_ip4_prefix_len)
7887 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7891 vec_free (host_if_name);
7892 vec_free (host_bridge);
7897 /* Wait for a reply... */
7903 api_tap_delete_v2 (vat_main_t * vam)
7905 unformat_input_t *i = vam->input;
7906 vl_api_tap_delete_v2_t *mp;
7907 u32 sw_if_index = ~0;
7908 u8 sw_if_index_set = 0;
7911 /* Parse args required to build the message */
7912 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7914 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7915 sw_if_index_set = 1;
7916 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7917 sw_if_index_set = 1;
7922 if (sw_if_index_set == 0)
7924 errmsg ("missing vpp interface name. ");
7928 /* Construct the API message */
7929 M (TAP_DELETE_V2, mp);
7931 mp->sw_if_index = ntohl (sw_if_index);
7936 /* Wait for a reply... */
7942 api_ip_table_add_del (vat_main_t * vam)
7944 unformat_input_t *i = vam->input;
7945 vl_api_ip_table_add_del_t *mp;
7951 /* Parse args required to build the message */
7952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7954 if (unformat (i, "ipv6"))
7956 else if (unformat (i, "del"))
7958 else if (unformat (i, "add"))
7960 else if (unformat (i, "table %d", &table_id))
7964 clib_warning ("parse error '%U'", format_unformat_error, i);
7971 errmsg ("missing table-ID");
7975 /* Construct the API message */
7976 M (IP_TABLE_ADD_DEL, mp);
7978 mp->table_id = ntohl (table_id);
7979 mp->is_ipv6 = is_ipv6;
7980 mp->is_add = is_add;
7985 /* Wait for a reply... */
7992 api_ip_add_del_route (vat_main_t * vam)
7994 unformat_input_t *i = vam->input;
7995 vl_api_ip_add_del_route_t *mp;
7996 u32 sw_if_index = ~0, vrf_id = 0;
7998 u8 is_local = 0, is_drop = 0;
7999 u8 is_unreach = 0, is_prohibit = 0;
8001 u32 next_hop_weight = 1;
8002 u8 is_multipath = 0;
8004 u8 address_length_set = 0;
8005 u32 next_hop_table_id = 0;
8006 u32 resolve_attempts = 0;
8007 u32 dst_address_length = 0;
8008 u8 next_hop_set = 0;
8009 ip4_address_t v4_dst_address, v4_next_hop_address;
8010 ip6_address_t v6_dst_address, v6_next_hop_address;
8014 u32 random_add_del = 0;
8015 u32 *random_vector = 0;
8017 u32 random_seed = 0xdeaddabe;
8018 u32 classify_table_index = ~0;
8020 u8 resolve_host = 0, resolve_attached = 0;
8021 mpls_label_t *next_hop_out_label_stack = NULL;
8022 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8023 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8025 /* Parse args required to build the message */
8026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8032 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8037 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8042 else if (unformat (i, "/%d", &dst_address_length))
8044 address_length_set = 1;
8047 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8048 &v4_next_hop_address))
8052 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8053 &v6_next_hop_address))
8057 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8059 else if (unformat (i, "weight %d", &next_hop_weight))
8061 else if (unformat (i, "drop"))
8065 else if (unformat (i, "null-send-unreach"))
8069 else if (unformat (i, "null-send-prohibit"))
8073 else if (unformat (i, "local"))
8077 else if (unformat (i, "classify %d", &classify_table_index))
8081 else if (unformat (i, "del"))
8083 else if (unformat (i, "add"))
8085 else if (unformat (i, "resolve-via-host"))
8087 else if (unformat (i, "resolve-via-attached"))
8088 resolve_attached = 1;
8089 else if (unformat (i, "multipath"))
8091 else if (unformat (i, "vrf %d", &vrf_id))
8093 else if (unformat (i, "count %d", &count))
8095 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8097 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8099 else if (unformat (i, "out-label %d", &next_hop_out_label))
8100 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8101 else if (unformat (i, "via-label %d", &next_hop_via_label))
8103 else if (unformat (i, "random"))
8105 else if (unformat (i, "seed %d", &random_seed))
8109 clib_warning ("parse error '%U'", format_unformat_error, i);
8114 if (!next_hop_set && !is_drop && !is_local &&
8115 !is_classify && !is_unreach && !is_prohibit &&
8116 MPLS_LABEL_INVALID == next_hop_via_label)
8119 ("next hop / local / drop / unreach / prohibit / classify not set");
8123 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8125 errmsg ("next hop and next-hop via label set");
8128 if (address_set == 0)
8130 errmsg ("missing addresses");
8134 if (address_length_set == 0)
8136 errmsg ("missing address length");
8140 /* Generate a pile of unique, random routes */
8143 u32 this_random_address;
8144 random_hash = hash_create (count, sizeof (uword));
8146 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8147 for (j = 0; j <= count; j++)
8151 this_random_address = random_u32 (&random_seed);
8152 this_random_address =
8153 clib_host_to_net_u32 (this_random_address);
8155 while (hash_get (random_hash, this_random_address));
8156 vec_add1 (random_vector, this_random_address);
8157 hash_set (random_hash, this_random_address, 1);
8159 hash_free (random_hash);
8160 v4_dst_address.as_u32 = random_vector[0];
8165 /* Turn on async mode */
8166 vam->async_mode = 1;
8167 vam->async_errors = 0;
8168 before = vat_time_now (vam);
8171 for (j = 0; j < count; j++)
8173 /* Construct the API message */
8174 M2 (IP_ADD_DEL_ROUTE, mp,
8175 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8177 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8178 mp->table_id = ntohl (vrf_id);
8180 mp->is_add = is_add;
8181 mp->is_drop = is_drop;
8182 mp->is_unreach = is_unreach;
8183 mp->is_prohibit = is_prohibit;
8184 mp->is_ipv6 = is_ipv6;
8185 mp->is_local = is_local;
8186 mp->is_classify = is_classify;
8187 mp->is_multipath = is_multipath;
8188 mp->is_resolve_host = resolve_host;
8189 mp->is_resolve_attached = resolve_attached;
8190 mp->next_hop_weight = next_hop_weight;
8191 mp->dst_address_length = dst_address_length;
8192 mp->next_hop_table_id = ntohl (next_hop_table_id);
8193 mp->classify_table_index = ntohl (classify_table_index);
8194 mp->next_hop_via_label = ntohl (next_hop_via_label);
8195 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8196 if (0 != mp->next_hop_n_out_labels)
8198 memcpy (mp->next_hop_out_label_stack,
8199 next_hop_out_label_stack,
8200 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8201 vec_free (next_hop_out_label_stack);
8206 clib_memcpy (mp->dst_address, &v6_dst_address,
8207 sizeof (v6_dst_address));
8209 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8210 sizeof (v6_next_hop_address));
8211 increment_v6_address (&v6_dst_address);
8215 clib_memcpy (mp->dst_address, &v4_dst_address,
8216 sizeof (v4_dst_address));
8218 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8219 sizeof (v4_next_hop_address));
8221 v4_dst_address.as_u32 = random_vector[j + 1];
8223 increment_v4_address (&v4_dst_address);
8227 /* If we receive SIGTERM, stop now... */
8232 /* When testing multiple add/del ops, use a control-ping to sync */
8235 vl_api_control_ping_t *mp_ping;
8239 /* Shut off async mode */
8240 vam->async_mode = 0;
8242 MPING (CONTROL_PING, mp_ping);
8245 timeout = vat_time_now (vam) + 1.0;
8246 while (vat_time_now (vam) < timeout)
8247 if (vam->result_ready == 1)
8252 if (vam->retval == -99)
8255 if (vam->async_errors > 0)
8257 errmsg ("%d asynchronous errors", vam->async_errors);
8260 vam->async_errors = 0;
8261 after = vat_time_now (vam);
8263 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8267 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8268 count, after - before, count / (after - before));
8274 /* Wait for a reply... */
8279 /* Return the good/bad news */
8280 return (vam->retval);
8284 api_ip_mroute_add_del (vat_main_t * vam)
8286 unformat_input_t *i = vam->input;
8287 vl_api_ip_mroute_add_del_t *mp;
8288 u32 sw_if_index = ~0, vrf_id = 0;
8293 u32 grp_address_length = 0;
8294 ip4_address_t v4_grp_address, v4_src_address;
8295 ip6_address_t v6_grp_address, v6_src_address;
8296 mfib_itf_flags_t iflags = 0;
8297 mfib_entry_flags_t eflags = 0;
8300 /* Parse args required to build the message */
8301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8303 if (unformat (i, "sw_if_index %d", &sw_if_index))
8305 else if (unformat (i, "%U %U",
8306 unformat_ip4_address, &v4_src_address,
8307 unformat_ip4_address, &v4_grp_address))
8309 grp_address_length = 64;
8313 else if (unformat (i, "%U %U",
8314 unformat_ip6_address, &v6_src_address,
8315 unformat_ip6_address, &v6_grp_address))
8317 grp_address_length = 256;
8321 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8323 memset (&v4_src_address, 0, sizeof (v4_src_address));
8324 grp_address_length = 32;
8328 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8330 memset (&v6_src_address, 0, sizeof (v6_src_address));
8331 grp_address_length = 128;
8335 else if (unformat (i, "/%d", &grp_address_length))
8337 else if (unformat (i, "local"))
8341 else if (unformat (i, "del"))
8343 else if (unformat (i, "add"))
8345 else if (unformat (i, "vrf %d", &vrf_id))
8347 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8349 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8353 clib_warning ("parse error '%U'", format_unformat_error, i);
8358 if (address_set == 0)
8360 errmsg ("missing addresses\n");
8364 /* Construct the API message */
8365 M (IP_MROUTE_ADD_DEL, mp);
8367 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8368 mp->table_id = ntohl (vrf_id);
8370 mp->is_add = is_add;
8371 mp->is_ipv6 = is_ipv6;
8372 mp->is_local = is_local;
8373 mp->itf_flags = ntohl (iflags);
8374 mp->entry_flags = ntohl (eflags);
8375 mp->grp_address_length = grp_address_length;
8376 mp->grp_address_length = ntohs (mp->grp_address_length);
8380 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8381 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8385 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8386 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8392 /* Wait for a reply... */
8398 api_mpls_table_add_del (vat_main_t * vam)
8400 unformat_input_t *i = vam->input;
8401 vl_api_mpls_table_add_del_t *mp;
8406 /* Parse args required to build the message */
8407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8409 if (unformat (i, "table %d", &table_id))
8411 else if (unformat (i, "del"))
8413 else if (unformat (i, "add"))
8417 clib_warning ("parse error '%U'", format_unformat_error, i);
8424 errmsg ("missing table-ID");
8428 /* Construct the API message */
8429 M (MPLS_TABLE_ADD_DEL, mp);
8431 mp->mt_table_id = ntohl (table_id);
8432 mp->mt_is_add = is_add;
8437 /* Wait for a reply... */
8444 api_mpls_route_add_del (vat_main_t * vam)
8446 unformat_input_t *i = vam->input;
8447 vl_api_mpls_route_add_del_t *mp;
8448 u32 sw_if_index = ~0, table_id = 0;
8450 u32 next_hop_weight = 1;
8451 u8 is_multipath = 0;
8452 u32 next_hop_table_id = 0;
8453 u8 next_hop_set = 0;
8454 ip4_address_t v4_next_hop_address = {
8457 ip6_address_t v6_next_hop_address = { {0} };
8461 u32 classify_table_index = ~0;
8463 u8 resolve_host = 0, resolve_attached = 0;
8464 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8465 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8466 mpls_label_t *next_hop_out_label_stack = NULL;
8467 mpls_label_t local_label = MPLS_LABEL_INVALID;
8469 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8471 /* Parse args required to build the message */
8472 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8474 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8476 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8478 else if (unformat (i, "%d", &local_label))
8480 else if (unformat (i, "eos"))
8482 else if (unformat (i, "non-eos"))
8484 else if (unformat (i, "via %U", unformat_ip4_address,
8485 &v4_next_hop_address))
8488 next_hop_proto = DPO_PROTO_IP4;
8490 else if (unformat (i, "via %U", unformat_ip6_address,
8491 &v6_next_hop_address))
8494 next_hop_proto = DPO_PROTO_IP6;
8496 else if (unformat (i, "weight %d", &next_hop_weight))
8498 else if (unformat (i, "classify %d", &classify_table_index))
8502 else if (unformat (i, "del"))
8504 else if (unformat (i, "add"))
8506 else if (unformat (i, "resolve-via-host"))
8508 else if (unformat (i, "resolve-via-attached"))
8509 resolve_attached = 1;
8510 else if (unformat (i, "multipath"))
8512 else if (unformat (i, "count %d", &count))
8514 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8517 next_hop_proto = DPO_PROTO_IP4;
8519 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8522 next_hop_proto = DPO_PROTO_IP6;
8524 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8526 else if (unformat (i, "via-label %d", &next_hop_via_label))
8528 else if (unformat (i, "out-label %d", &next_hop_out_label))
8529 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8532 clib_warning ("parse error '%U'", format_unformat_error, i);
8537 if (!next_hop_set && !is_classify)
8539 errmsg ("next hop / classify not set");
8543 if (MPLS_LABEL_INVALID == local_label)
8545 errmsg ("missing label");
8551 /* Turn on async mode */
8552 vam->async_mode = 1;
8553 vam->async_errors = 0;
8554 before = vat_time_now (vam);
8557 for (j = 0; j < count; j++)
8559 /* Construct the API message */
8560 M2 (MPLS_ROUTE_ADD_DEL, mp,
8561 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8563 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8564 mp->mr_table_id = ntohl (table_id);
8566 mp->mr_is_add = is_add;
8567 mp->mr_next_hop_proto = next_hop_proto;
8568 mp->mr_is_classify = is_classify;
8569 mp->mr_is_multipath = is_multipath;
8570 mp->mr_is_resolve_host = resolve_host;
8571 mp->mr_is_resolve_attached = resolve_attached;
8572 mp->mr_next_hop_weight = next_hop_weight;
8573 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8574 mp->mr_classify_table_index = ntohl (classify_table_index);
8575 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8576 mp->mr_label = ntohl (local_label);
8577 mp->mr_eos = is_eos;
8579 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8580 if (0 != mp->mr_next_hop_n_out_labels)
8582 memcpy (mp->mr_next_hop_out_label_stack,
8583 next_hop_out_label_stack,
8584 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8585 vec_free (next_hop_out_label_stack);
8590 if (DPO_PROTO_IP4 == next_hop_proto)
8592 clib_memcpy (mp->mr_next_hop,
8593 &v4_next_hop_address,
8594 sizeof (v4_next_hop_address));
8596 else if (DPO_PROTO_IP6 == next_hop_proto)
8599 clib_memcpy (mp->mr_next_hop,
8600 &v6_next_hop_address,
8601 sizeof (v6_next_hop_address));
8608 /* If we receive SIGTERM, stop now... */
8613 /* When testing multiple add/del ops, use a control-ping to sync */
8616 vl_api_control_ping_t *mp_ping;
8620 /* Shut off async mode */
8621 vam->async_mode = 0;
8623 MPING (CONTROL_PING, mp_ping);
8626 timeout = vat_time_now (vam) + 1.0;
8627 while (vat_time_now (vam) < timeout)
8628 if (vam->result_ready == 1)
8633 if (vam->retval == -99)
8636 if (vam->async_errors > 0)
8638 errmsg ("%d asynchronous errors", vam->async_errors);
8641 vam->async_errors = 0;
8642 after = vat_time_now (vam);
8644 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8648 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8649 count, after - before, count / (after - before));
8655 /* Wait for a reply... */
8660 /* Return the good/bad news */
8661 return (vam->retval);
8665 api_mpls_ip_bind_unbind (vat_main_t * vam)
8667 unformat_input_t *i = vam->input;
8668 vl_api_mpls_ip_bind_unbind_t *mp;
8669 u32 ip_table_id = 0;
8672 ip4_address_t v4_address;
8673 ip6_address_t v6_address;
8676 mpls_label_t local_label = MPLS_LABEL_INVALID;
8679 /* Parse args required to build the message */
8680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8682 if (unformat (i, "%U/%d", unformat_ip4_address,
8683 &v4_address, &address_length))
8688 else if (unformat (i, "%U/%d", unformat_ip6_address,
8689 &v6_address, &address_length))
8694 else if (unformat (i, "%d", &local_label))
8696 else if (unformat (i, "table-id %d", &ip_table_id))
8698 else if (unformat (i, "unbind"))
8700 else if (unformat (i, "bind"))
8704 clib_warning ("parse error '%U'", format_unformat_error, i);
8711 errmsg ("IP addres not set");
8715 if (MPLS_LABEL_INVALID == local_label)
8717 errmsg ("missing label");
8721 /* Construct the API message */
8722 M (MPLS_IP_BIND_UNBIND, mp);
8724 mp->mb_is_bind = is_bind;
8725 mp->mb_is_ip4 = is_ip4;
8726 mp->mb_ip_table_id = ntohl (ip_table_id);
8727 mp->mb_mpls_table_id = 0;
8728 mp->mb_label = ntohl (local_label);
8729 mp->mb_address_length = address_length;
8732 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8734 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8739 /* Wait for a reply... */
8745 api_bier_table_add_del (vat_main_t * vam)
8747 unformat_input_t *i = vam->input;
8748 vl_api_bier_table_add_del_t *mp;
8750 u32 set = 0, sub_domain = 0, hdr_len = 3;
8751 mpls_label_t local_label = MPLS_LABEL_INVALID;
8754 /* Parse args required to build the message */
8755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8757 if (unformat (i, "sub-domain %d", &sub_domain))
8759 else if (unformat (i, "set %d", &set))
8761 else if (unformat (i, "label %d", &local_label))
8763 else if (unformat (i, "hdr-len %d", &hdr_len))
8765 else if (unformat (i, "add"))
8767 else if (unformat (i, "del"))
8771 clib_warning ("parse error '%U'", format_unformat_error, i);
8776 if (MPLS_LABEL_INVALID == local_label)
8778 errmsg ("missing label\n");
8782 /* Construct the API message */
8783 M (BIER_TABLE_ADD_DEL, mp);
8785 mp->bt_is_add = is_add;
8786 mp->bt_label = ntohl (local_label);
8787 mp->bt_tbl_id.bt_set = set;
8788 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8789 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8794 /* Wait for a reply... */
8801 api_bier_route_add_del (vat_main_t * vam)
8803 unformat_input_t *i = vam->input;
8804 vl_api_bier_route_add_del_t *mp;
8806 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8807 ip4_address_t v4_next_hop_address;
8808 ip6_address_t v6_next_hop_address;
8809 u8 next_hop_set = 0;
8810 u8 next_hop_proto_is_ip4 = 1;
8811 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8814 /* Parse args required to build the message */
8815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8817 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8819 next_hop_proto_is_ip4 = 1;
8822 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8824 next_hop_proto_is_ip4 = 0;
8827 if (unformat (i, "sub-domain %d", &sub_domain))
8829 else if (unformat (i, "set %d", &set))
8831 else if (unformat (i, "hdr-len %d", &hdr_len))
8833 else if (unformat (i, "bp %d", &bp))
8835 else if (unformat (i, "add"))
8837 else if (unformat (i, "del"))
8839 else if (unformat (i, "out-label %d", &next_hop_out_label))
8843 clib_warning ("parse error '%U'", format_unformat_error, i);
8848 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8850 errmsg ("next hop / label set\n");
8855 errmsg ("bit=position not set\n");
8859 /* Construct the API message */
8860 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8862 mp->br_is_add = is_add;
8863 mp->br_tbl_id.bt_set = set;
8864 mp->br_tbl_id.bt_sub_domain = sub_domain;
8865 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8866 mp->br_bp = ntohs (bp);
8868 mp->br_paths[0].n_labels = 1;
8869 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8870 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8872 if (next_hop_proto_is_ip4)
8874 clib_memcpy (mp->br_paths[0].next_hop,
8875 &v4_next_hop_address, sizeof (v4_next_hop_address));
8879 clib_memcpy (mp->br_paths[0].next_hop,
8880 &v6_next_hop_address, sizeof (v6_next_hop_address));
8886 /* Wait for a reply... */
8893 api_proxy_arp_add_del (vat_main_t * vam)
8895 unformat_input_t *i = vam->input;
8896 vl_api_proxy_arp_add_del_t *mp;
8899 ip4_address_t lo, hi;
8903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8905 if (unformat (i, "vrf %d", &vrf_id))
8907 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8908 unformat_ip4_address, &hi))
8910 else if (unformat (i, "del"))
8914 clib_warning ("parse error '%U'", format_unformat_error, i);
8921 errmsg ("address range not set");
8925 M (PROXY_ARP_ADD_DEL, mp);
8927 mp->vrf_id = ntohl (vrf_id);
8928 mp->is_add = is_add;
8929 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8930 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8938 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8940 unformat_input_t *i = vam->input;
8941 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8944 u8 sw_if_index_set = 0;
8947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8949 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8950 sw_if_index_set = 1;
8951 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8952 sw_if_index_set = 1;
8953 else if (unformat (i, "enable"))
8955 else if (unformat (i, "disable"))
8959 clib_warning ("parse error '%U'", format_unformat_error, i);
8964 if (sw_if_index_set == 0)
8966 errmsg ("missing interface name or sw_if_index");
8970 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8972 mp->sw_if_index = ntohl (sw_if_index);
8973 mp->enable_disable = enable;
8981 api_mpls_tunnel_add_del (vat_main_t * vam)
8983 unformat_input_t *i = vam->input;
8984 vl_api_mpls_tunnel_add_del_t *mp;
8988 u32 sw_if_index = ~0;
8989 u32 next_hop_sw_if_index = ~0;
8990 u32 next_hop_proto_is_ip4 = 1;
8992 u32 next_hop_table_id = 0;
8993 ip4_address_t v4_next_hop_address = {
8996 ip6_address_t v6_next_hop_address = { {0} };
8997 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9002 if (unformat (i, "add"))
9004 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9006 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9008 else if (unformat (i, "via %U",
9009 unformat_ip4_address, &v4_next_hop_address))
9011 next_hop_proto_is_ip4 = 1;
9013 else if (unformat (i, "via %U",
9014 unformat_ip6_address, &v6_next_hop_address))
9016 next_hop_proto_is_ip4 = 0;
9018 else if (unformat (i, "l2-only"))
9020 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9022 else if (unformat (i, "out-label %d", &next_hop_out_label))
9023 vec_add1 (labels, ntohl (next_hop_out_label));
9026 clib_warning ("parse error '%U'", format_unformat_error, i);
9031 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9033 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9034 mp->mt_sw_if_index = ntohl (sw_if_index);
9035 mp->mt_is_add = is_add;
9036 mp->mt_l2_only = l2_only;
9037 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9038 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9040 mp->mt_next_hop_n_out_labels = vec_len (labels);
9042 if (0 != mp->mt_next_hop_n_out_labels)
9044 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9045 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9049 if (next_hop_proto_is_ip4)
9051 clib_memcpy (mp->mt_next_hop,
9052 &v4_next_hop_address, sizeof (v4_next_hop_address));
9056 clib_memcpy (mp->mt_next_hop,
9057 &v6_next_hop_address, sizeof (v6_next_hop_address));
9066 api_sw_interface_set_unnumbered (vat_main_t * vam)
9068 unformat_input_t *i = vam->input;
9069 vl_api_sw_interface_set_unnumbered_t *mp;
9071 u32 unnum_sw_index = ~0;
9073 u8 sw_if_index_set = 0;
9076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9078 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9079 sw_if_index_set = 1;
9080 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9081 sw_if_index_set = 1;
9082 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9084 else if (unformat (i, "del"))
9088 clib_warning ("parse error '%U'", format_unformat_error, i);
9093 if (sw_if_index_set == 0)
9095 errmsg ("missing interface name or sw_if_index");
9099 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9101 mp->sw_if_index = ntohl (sw_if_index);
9102 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9103 mp->is_add = is_add;
9111 api_ip_neighbor_add_del (vat_main_t * vam)
9113 unformat_input_t *i = vam->input;
9114 vl_api_ip_neighbor_add_del_t *mp;
9116 u8 sw_if_index_set = 0;
9119 u8 is_no_fib_entry = 0;
9122 u8 v4_address_set = 0;
9123 u8 v6_address_set = 0;
9124 ip4_address_t v4address;
9125 ip6_address_t v6address;
9128 memset (mac_address, 0, sizeof (mac_address));
9130 /* Parse args required to build the message */
9131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9133 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9137 else if (unformat (i, "del"))
9140 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9141 sw_if_index_set = 1;
9142 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9143 sw_if_index_set = 1;
9144 else if (unformat (i, "is_static"))
9146 else if (unformat (i, "no-fib-entry"))
9147 is_no_fib_entry = 1;
9148 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9150 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9154 clib_warning ("parse error '%U'", format_unformat_error, i);
9159 if (sw_if_index_set == 0)
9161 errmsg ("missing interface name or sw_if_index");
9164 if (v4_address_set && v6_address_set)
9166 errmsg ("both v4 and v6 addresses set");
9169 if (!v4_address_set && !v6_address_set)
9171 errmsg ("no address set");
9175 /* Construct the API message */
9176 M (IP_NEIGHBOR_ADD_DEL, mp);
9178 mp->sw_if_index = ntohl (sw_if_index);
9179 mp->is_add = is_add;
9180 mp->is_static = is_static;
9181 mp->is_no_adj_fib = is_no_fib_entry;
9183 clib_memcpy (mp->mac_address, mac_address, 6);
9187 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9191 /* mp->is_ipv6 = 0; via memset in M macro above */
9192 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9198 /* Wait for a reply, return good/bad news */
9204 api_create_vlan_subif (vat_main_t * vam)
9206 unformat_input_t *i = vam->input;
9207 vl_api_create_vlan_subif_t *mp;
9209 u8 sw_if_index_set = 0;
9214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9216 if (unformat (i, "sw_if_index %d", &sw_if_index))
9217 sw_if_index_set = 1;
9219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9220 sw_if_index_set = 1;
9221 else if (unformat (i, "vlan %d", &vlan_id))
9225 clib_warning ("parse error '%U'", format_unformat_error, i);
9230 if (sw_if_index_set == 0)
9232 errmsg ("missing interface name or sw_if_index");
9236 if (vlan_id_set == 0)
9238 errmsg ("missing vlan_id");
9241 M (CREATE_VLAN_SUBIF, mp);
9243 mp->sw_if_index = ntohl (sw_if_index);
9244 mp->vlan_id = ntohl (vlan_id);
9251 #define foreach_create_subif_bit \
9258 _(outer_vlan_id_any) \
9259 _(inner_vlan_id_any)
9262 api_create_subif (vat_main_t * vam)
9264 unformat_input_t *i = vam->input;
9265 vl_api_create_subif_t *mp;
9267 u8 sw_if_index_set = 0;
9274 u32 exact_match = 0;
9275 u32 default_sub = 0;
9276 u32 outer_vlan_id_any = 0;
9277 u32 inner_vlan_id_any = 0;
9279 u16 outer_vlan_id = 0;
9280 u16 inner_vlan_id = 0;
9283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9285 if (unformat (i, "sw_if_index %d", &sw_if_index))
9286 sw_if_index_set = 1;
9288 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9289 sw_if_index_set = 1;
9290 else if (unformat (i, "sub_id %d", &sub_id))
9292 else if (unformat (i, "outer_vlan_id %d", &tmp))
9293 outer_vlan_id = tmp;
9294 else if (unformat (i, "inner_vlan_id %d", &tmp))
9295 inner_vlan_id = tmp;
9297 #define _(a) else if (unformat (i, #a)) a = 1 ;
9298 foreach_create_subif_bit
9302 clib_warning ("parse error '%U'", format_unformat_error, i);
9307 if (sw_if_index_set == 0)
9309 errmsg ("missing interface name or sw_if_index");
9313 if (sub_id_set == 0)
9315 errmsg ("missing sub_id");
9318 M (CREATE_SUBIF, mp);
9320 mp->sw_if_index = ntohl (sw_if_index);
9321 mp->sub_id = ntohl (sub_id);
9323 #define _(a) mp->a = a;
9324 foreach_create_subif_bit;
9327 mp->outer_vlan_id = ntohs (outer_vlan_id);
9328 mp->inner_vlan_id = ntohs (inner_vlan_id);
9336 api_oam_add_del (vat_main_t * vam)
9338 unformat_input_t *i = vam->input;
9339 vl_api_oam_add_del_t *mp;
9342 ip4_address_t src, dst;
9347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9349 if (unformat (i, "vrf %d", &vrf_id))
9351 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9353 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9355 else if (unformat (i, "del"))
9359 clib_warning ("parse error '%U'", format_unformat_error, i);
9366 errmsg ("missing src addr");
9372 errmsg ("missing dst addr");
9376 M (OAM_ADD_DEL, mp);
9378 mp->vrf_id = ntohl (vrf_id);
9379 mp->is_add = is_add;
9380 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9381 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9389 api_reset_fib (vat_main_t * vam)
9391 unformat_input_t *i = vam->input;
9392 vl_api_reset_fib_t *mp;
9398 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9400 if (unformat (i, "vrf %d", &vrf_id))
9402 else if (unformat (i, "ipv6"))
9406 clib_warning ("parse error '%U'", format_unformat_error, i);
9411 if (vrf_id_set == 0)
9413 errmsg ("missing vrf id");
9419 mp->vrf_id = ntohl (vrf_id);
9420 mp->is_ipv6 = is_ipv6;
9428 api_dhcp_proxy_config (vat_main_t * vam)
9430 unformat_input_t *i = vam->input;
9431 vl_api_dhcp_proxy_config_t *mp;
9433 u32 server_vrf_id = 0;
9435 u8 v4_address_set = 0;
9436 u8 v6_address_set = 0;
9437 ip4_address_t v4address;
9438 ip6_address_t v6address;
9439 u8 v4_src_address_set = 0;
9440 u8 v6_src_address_set = 0;
9441 ip4_address_t v4srcaddress;
9442 ip6_address_t v6srcaddress;
9445 /* Parse args required to build the message */
9446 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9448 if (unformat (i, "del"))
9450 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9452 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9454 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9456 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9458 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9459 v4_src_address_set = 1;
9460 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9461 v6_src_address_set = 1;
9466 if (v4_address_set && v6_address_set)
9468 errmsg ("both v4 and v6 server addresses set");
9471 if (!v4_address_set && !v6_address_set)
9473 errmsg ("no server addresses set");
9477 if (v4_src_address_set && v6_src_address_set)
9479 errmsg ("both v4 and v6 src addresses set");
9482 if (!v4_src_address_set && !v6_src_address_set)
9484 errmsg ("no src addresses set");
9488 if (!(v4_src_address_set && v4_address_set) &&
9489 !(v6_src_address_set && v6_address_set))
9491 errmsg ("no matching server and src addresses set");
9495 /* Construct the API message */
9496 M (DHCP_PROXY_CONFIG, mp);
9498 mp->is_add = is_add;
9499 mp->rx_vrf_id = ntohl (rx_vrf_id);
9500 mp->server_vrf_id = ntohl (server_vrf_id);
9504 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9505 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9509 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9510 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9516 /* Wait for a reply, return good/bad news */
9521 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9522 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9525 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9527 vat_main_t *vam = &vat_main;
9528 u32 i, count = mp->count;
9529 vl_api_dhcp_server_t *s;
9533 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9534 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9535 ntohl (mp->rx_vrf_id),
9536 format_ip6_address, mp->dhcp_src_address,
9537 mp->vss_type, mp->vss_vpn_ascii_id,
9538 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9541 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9542 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9543 ntohl (mp->rx_vrf_id),
9544 format_ip4_address, mp->dhcp_src_address,
9545 mp->vss_type, mp->vss_vpn_ascii_id,
9546 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9548 for (i = 0; i < count; i++)
9550 s = &mp->servers[i];
9554 " Server Table-ID %d, Server Address %U",
9555 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9558 " Server Table-ID %d, Server Address %U",
9559 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9563 static void vl_api_dhcp_proxy_details_t_handler_json
9564 (vl_api_dhcp_proxy_details_t * mp)
9566 vat_main_t *vam = &vat_main;
9567 vat_json_node_t *node = NULL;
9568 u32 i, count = mp->count;
9570 struct in6_addr ip6;
9571 vl_api_dhcp_server_t *s;
9573 if (VAT_JSON_ARRAY != vam->json_tree.type)
9575 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9576 vat_json_init_array (&vam->json_tree);
9578 node = vat_json_array_add (&vam->json_tree);
9580 vat_json_init_object (node);
9581 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9582 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9583 sizeof (mp->vss_type));
9584 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9585 mp->vss_vpn_ascii_id);
9586 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9587 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9591 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9592 vat_json_object_add_ip6 (node, "src_address", ip6);
9596 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9597 vat_json_object_add_ip4 (node, "src_address", ip4);
9600 for (i = 0; i < count; i++)
9602 s = &mp->servers[i];
9604 vat_json_object_add_uint (node, "server-table-id",
9605 ntohl (s->server_vrf_id));
9609 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9610 vat_json_object_add_ip4 (node, "src_address", ip4);
9614 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9615 vat_json_object_add_ip6 (node, "server_address", ip6);
9621 api_dhcp_proxy_dump (vat_main_t * vam)
9623 unformat_input_t *i = vam->input;
9624 vl_api_control_ping_t *mp_ping;
9625 vl_api_dhcp_proxy_dump_t *mp;
9629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9631 if (unformat (i, "ipv6"))
9635 clib_warning ("parse error '%U'", format_unformat_error, i);
9640 M (DHCP_PROXY_DUMP, mp);
9642 mp->is_ip6 = is_ipv6;
9645 /* Use a control ping for synchronization */
9646 MPING (CONTROL_PING, mp_ping);
9654 api_dhcp_proxy_set_vss (vat_main_t * vam)
9656 unformat_input_t *i = vam->input;
9657 vl_api_dhcp_proxy_set_vss_t *mp;
9661 u8 vss_type = VSS_TYPE_DEFAULT;
9662 u8 *vpn_ascii_id = 0;
9667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9669 if (unformat (i, "tbl_id %d", &tbl_id))
9671 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9672 vss_type = VSS_TYPE_ASCII;
9673 else if (unformat (i, "fib_id %d", &fib_id))
9674 vss_type = VSS_TYPE_VPN_ID;
9675 else if (unformat (i, "oui %d", &oui))
9676 vss_type = VSS_TYPE_VPN_ID;
9677 else if (unformat (i, "ipv6"))
9679 else if (unformat (i, "del"))
9687 errmsg ("missing tbl_id ");
9688 vec_free (vpn_ascii_id);
9692 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9694 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9695 vec_free (vpn_ascii_id);
9699 M (DHCP_PROXY_SET_VSS, mp);
9700 mp->tbl_id = ntohl (tbl_id);
9701 mp->vss_type = vss_type;
9704 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9705 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9707 mp->vpn_index = ntohl (fib_id);
9708 mp->oui = ntohl (oui);
9709 mp->is_ipv6 = is_ipv6;
9710 mp->is_add = is_add;
9715 vec_free (vpn_ascii_id);
9720 api_dhcp_client_config (vat_main_t * vam)
9722 unformat_input_t *i = vam->input;
9723 vl_api_dhcp_client_config_t *mp;
9725 u8 sw_if_index_set = 0;
9728 u8 disable_event = 0;
9731 /* Parse args required to build the message */
9732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9734 if (unformat (i, "del"))
9737 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9738 sw_if_index_set = 1;
9739 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9740 sw_if_index_set = 1;
9741 else if (unformat (i, "hostname %s", &hostname))
9743 else if (unformat (i, "disable_event"))
9749 if (sw_if_index_set == 0)
9751 errmsg ("missing interface name or sw_if_index");
9755 if (vec_len (hostname) > 63)
9757 errmsg ("hostname too long");
9759 vec_add1 (hostname, 0);
9761 /* Construct the API message */
9762 M (DHCP_CLIENT_CONFIG, mp);
9764 mp->sw_if_index = htonl (sw_if_index);
9765 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9766 vec_free (hostname);
9767 mp->is_add = is_add;
9768 mp->want_dhcp_event = disable_event ? 0 : 1;
9769 mp->pid = htonl (getpid ());
9774 /* Wait for a reply, return good/bad news */
9780 api_set_ip_flow_hash (vat_main_t * vam)
9782 unformat_input_t *i = vam->input;
9783 vl_api_set_ip_flow_hash_t *mp;
9795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9797 if (unformat (i, "vrf %d", &vrf_id))
9799 else if (unformat (i, "ipv6"))
9801 else if (unformat (i, "src"))
9803 else if (unformat (i, "dst"))
9805 else if (unformat (i, "sport"))
9807 else if (unformat (i, "dport"))
9809 else if (unformat (i, "proto"))
9811 else if (unformat (i, "reverse"))
9816 clib_warning ("parse error '%U'", format_unformat_error, i);
9821 if (vrf_id_set == 0)
9823 errmsg ("missing vrf id");
9827 M (SET_IP_FLOW_HASH, mp);
9833 mp->reverse = reverse;
9834 mp->vrf_id = ntohl (vrf_id);
9835 mp->is_ipv6 = is_ipv6;
9843 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9845 unformat_input_t *i = vam->input;
9846 vl_api_sw_interface_ip6_enable_disable_t *mp;
9848 u8 sw_if_index_set = 0;
9852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9854 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9855 sw_if_index_set = 1;
9856 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9857 sw_if_index_set = 1;
9858 else if (unformat (i, "enable"))
9860 else if (unformat (i, "disable"))
9864 clib_warning ("parse error '%U'", format_unformat_error, i);
9869 if (sw_if_index_set == 0)
9871 errmsg ("missing interface name or sw_if_index");
9875 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9877 mp->sw_if_index = ntohl (sw_if_index);
9878 mp->enable = enable;
9886 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9888 unformat_input_t *i = vam->input;
9889 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9891 u8 sw_if_index_set = 0;
9892 u8 v6_address_set = 0;
9893 ip6_address_t v6address;
9896 /* Parse args required to build the message */
9897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9899 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9902 sw_if_index_set = 1;
9903 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9909 if (sw_if_index_set == 0)
9911 errmsg ("missing interface name or sw_if_index");
9914 if (!v6_address_set)
9916 errmsg ("no address set");
9920 /* Construct the API message */
9921 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9923 mp->sw_if_index = ntohl (sw_if_index);
9924 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9929 /* Wait for a reply, return good/bad news */
9935 api_ip6nd_proxy_add_del (vat_main_t * vam)
9937 unformat_input_t *i = vam->input;
9938 vl_api_ip6nd_proxy_add_del_t *mp;
9939 u32 sw_if_index = ~0;
9940 u8 v6_address_set = 0;
9941 ip6_address_t v6address;
9945 /* Parse args required to build the message */
9946 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9948 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9952 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9954 if (unformat (i, "del"))
9958 clib_warning ("parse error '%U'", format_unformat_error, i);
9963 if (sw_if_index == ~0)
9965 errmsg ("missing interface name or sw_if_index");
9968 if (!v6_address_set)
9970 errmsg ("no address set");
9974 /* Construct the API message */
9975 M (IP6ND_PROXY_ADD_DEL, mp);
9977 mp->is_del = is_del;
9978 mp->sw_if_index = ntohl (sw_if_index);
9979 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9984 /* Wait for a reply, return good/bad news */
9990 api_ip6nd_proxy_dump (vat_main_t * vam)
9992 vl_api_ip6nd_proxy_dump_t *mp;
9993 vl_api_control_ping_t *mp_ping;
9996 M (IP6ND_PROXY_DUMP, mp);
10000 /* Use a control ping for synchronization */
10001 MPING (CONTROL_PING, mp_ping);
10008 static void vl_api_ip6nd_proxy_details_t_handler
10009 (vl_api_ip6nd_proxy_details_t * mp)
10011 vat_main_t *vam = &vat_main;
10013 print (vam->ofp, "host %U sw_if_index %d",
10014 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10017 static void vl_api_ip6nd_proxy_details_t_handler_json
10018 (vl_api_ip6nd_proxy_details_t * mp)
10020 vat_main_t *vam = &vat_main;
10021 struct in6_addr ip6;
10022 vat_json_node_t *node = NULL;
10024 if (VAT_JSON_ARRAY != vam->json_tree.type)
10026 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10027 vat_json_init_array (&vam->json_tree);
10029 node = vat_json_array_add (&vam->json_tree);
10031 vat_json_init_object (node);
10032 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10034 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10035 vat_json_object_add_ip6 (node, "host", ip6);
10039 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10041 unformat_input_t *i = vam->input;
10042 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10044 u8 sw_if_index_set = 0;
10045 u32 address_length = 0;
10046 u8 v6_address_set = 0;
10047 ip6_address_t v6address;
10048 u8 use_default = 0;
10049 u8 no_advertise = 0;
10051 u8 no_autoconfig = 0;
10054 u32 val_lifetime = 0;
10055 u32 pref_lifetime = 0;
10058 /* Parse args required to build the message */
10059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10061 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10062 sw_if_index_set = 1;
10063 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10064 sw_if_index_set = 1;
10065 else if (unformat (i, "%U/%d",
10066 unformat_ip6_address, &v6address, &address_length))
10067 v6_address_set = 1;
10068 else if (unformat (i, "val_life %d", &val_lifetime))
10070 else if (unformat (i, "pref_life %d", &pref_lifetime))
10072 else if (unformat (i, "def"))
10074 else if (unformat (i, "noadv"))
10076 else if (unformat (i, "offl"))
10078 else if (unformat (i, "noauto"))
10080 else if (unformat (i, "nolink"))
10082 else if (unformat (i, "isno"))
10086 clib_warning ("parse error '%U'", format_unformat_error, i);
10091 if (sw_if_index_set == 0)
10093 errmsg ("missing interface name or sw_if_index");
10096 if (!v6_address_set)
10098 errmsg ("no address set");
10102 /* Construct the API message */
10103 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10105 mp->sw_if_index = ntohl (sw_if_index);
10106 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10107 mp->address_length = address_length;
10108 mp->use_default = use_default;
10109 mp->no_advertise = no_advertise;
10110 mp->off_link = off_link;
10111 mp->no_autoconfig = no_autoconfig;
10112 mp->no_onlink = no_onlink;
10114 mp->val_lifetime = ntohl (val_lifetime);
10115 mp->pref_lifetime = ntohl (pref_lifetime);
10120 /* Wait for a reply, return good/bad news */
10126 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10128 unformat_input_t *i = vam->input;
10129 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10131 u8 sw_if_index_set = 0;
10136 u8 send_unicast = 0;
10139 u8 default_router = 0;
10140 u32 max_interval = 0;
10141 u32 min_interval = 0;
10143 u32 initial_count = 0;
10144 u32 initial_interval = 0;
10148 /* Parse args required to build the message */
10149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10151 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10152 sw_if_index_set = 1;
10153 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10154 sw_if_index_set = 1;
10155 else if (unformat (i, "maxint %d", &max_interval))
10157 else if (unformat (i, "minint %d", &min_interval))
10159 else if (unformat (i, "life %d", &lifetime))
10161 else if (unformat (i, "count %d", &initial_count))
10163 else if (unformat (i, "interval %d", &initial_interval))
10165 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10167 else if (unformat (i, "managed"))
10169 else if (unformat (i, "other"))
10171 else if (unformat (i, "ll"))
10173 else if (unformat (i, "send"))
10175 else if (unformat (i, "cease"))
10177 else if (unformat (i, "isno"))
10179 else if (unformat (i, "def"))
10180 default_router = 1;
10183 clib_warning ("parse error '%U'", format_unformat_error, i);
10188 if (sw_if_index_set == 0)
10190 errmsg ("missing interface name or sw_if_index");
10194 /* Construct the API message */
10195 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10197 mp->sw_if_index = ntohl (sw_if_index);
10198 mp->max_interval = ntohl (max_interval);
10199 mp->min_interval = ntohl (min_interval);
10200 mp->lifetime = ntohl (lifetime);
10201 mp->initial_count = ntohl (initial_count);
10202 mp->initial_interval = ntohl (initial_interval);
10203 mp->suppress = suppress;
10204 mp->managed = managed;
10206 mp->ll_option = ll_option;
10207 mp->send_unicast = send_unicast;
10210 mp->default_router = default_router;
10215 /* Wait for a reply, return good/bad news */
10221 api_set_arp_neighbor_limit (vat_main_t * vam)
10223 unformat_input_t *i = vam->input;
10224 vl_api_set_arp_neighbor_limit_t *mp;
10230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10232 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10234 else if (unformat (i, "ipv6"))
10238 clib_warning ("parse error '%U'", format_unformat_error, i);
10243 if (limit_set == 0)
10245 errmsg ("missing limit value");
10249 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10251 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10252 mp->is_ipv6 = is_ipv6;
10260 api_l2_patch_add_del (vat_main_t * vam)
10262 unformat_input_t *i = vam->input;
10263 vl_api_l2_patch_add_del_t *mp;
10264 u32 rx_sw_if_index;
10265 u8 rx_sw_if_index_set = 0;
10266 u32 tx_sw_if_index;
10267 u8 tx_sw_if_index_set = 0;
10271 /* Parse args required to build the message */
10272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10274 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10275 rx_sw_if_index_set = 1;
10276 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10277 tx_sw_if_index_set = 1;
10278 else if (unformat (i, "rx"))
10280 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10282 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10284 rx_sw_if_index_set = 1;
10289 else if (unformat (i, "tx"))
10291 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10293 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10295 tx_sw_if_index_set = 1;
10300 else if (unformat (i, "del"))
10306 if (rx_sw_if_index_set == 0)
10308 errmsg ("missing rx interface name or rx_sw_if_index");
10312 if (tx_sw_if_index_set == 0)
10314 errmsg ("missing tx interface name or tx_sw_if_index");
10318 M (L2_PATCH_ADD_DEL, mp);
10320 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10321 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10322 mp->is_add = is_add;
10330 u8 localsid_addr[16];
10339 api_sr_localsid_add_del (vat_main_t * vam)
10341 unformat_input_t *i = vam->input;
10342 vl_api_sr_localsid_add_del_t *mp;
10345 ip6_address_t localsid;
10349 u32 fib_table = ~(u32) 0;
10350 ip6_address_t next_hop;
10352 bool nexthop_set = 0;
10356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10358 if (unformat (i, "del"))
10360 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10361 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10363 else if (unformat (i, "behavior %u", &behavior));
10364 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10365 else if (unformat (i, "fib-table %u", &fib_table));
10366 else if (unformat (i, "end.psp %u", &behavior));
10371 M (SR_LOCALSID_ADD_DEL, mp);
10373 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10375 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10376 mp->behavior = behavior;
10377 mp->sw_if_index = ntohl (sw_if_index);
10378 mp->fib_table = ntohl (fib_table);
10379 mp->end_psp = end_psp;
10380 mp->is_del = is_del;
10388 api_ioam_enable (vat_main_t * vam)
10390 unformat_input_t *input = vam->input;
10391 vl_api_ioam_enable_t *mp;
10393 int has_trace_option = 0;
10394 int has_pot_option = 0;
10395 int has_seqno_option = 0;
10396 int has_analyse_option = 0;
10399 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10401 if (unformat (input, "trace"))
10402 has_trace_option = 1;
10403 else if (unformat (input, "pot"))
10404 has_pot_option = 1;
10405 else if (unformat (input, "seqno"))
10406 has_seqno_option = 1;
10407 else if (unformat (input, "analyse"))
10408 has_analyse_option = 1;
10412 M (IOAM_ENABLE, mp);
10413 mp->id = htons (id);
10414 mp->seqno = has_seqno_option;
10415 mp->analyse = has_analyse_option;
10416 mp->pot_enable = has_pot_option;
10417 mp->trace_enable = has_trace_option;
10426 api_ioam_disable (vat_main_t * vam)
10428 vl_api_ioam_disable_t *mp;
10431 M (IOAM_DISABLE, mp);
10437 #define foreach_tcp_proto_field \
10441 #define foreach_udp_proto_field \
10445 #define foreach_ip4_proto_field \
10457 u16 src_port, dst_port;
10460 #if VPP_API_TEST_BUILTIN == 0
10462 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10464 u8 **maskp = va_arg (*args, u8 **);
10466 u8 found_something = 0;
10469 #define _(a) u8 a=0;
10470 foreach_tcp_proto_field;
10473 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10476 #define _(a) else if (unformat (input, #a)) a=1;
10477 foreach_tcp_proto_field
10483 #define _(a) found_something += a;
10484 foreach_tcp_proto_field;
10487 if (found_something == 0)
10490 vec_validate (mask, sizeof (*tcp) - 1);
10492 tcp = (tcp_header_t *) mask;
10494 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10495 foreach_tcp_proto_field;
10503 unformat_udp_mask (unformat_input_t * input, va_list * args)
10505 u8 **maskp = va_arg (*args, u8 **);
10507 u8 found_something = 0;
10510 #define _(a) u8 a=0;
10511 foreach_udp_proto_field;
10514 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10517 #define _(a) else if (unformat (input, #a)) a=1;
10518 foreach_udp_proto_field
10524 #define _(a) found_something += a;
10525 foreach_udp_proto_field;
10528 if (found_something == 0)
10531 vec_validate (mask, sizeof (*udp) - 1);
10533 udp = (udp_header_t *) mask;
10535 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10536 foreach_udp_proto_field;
10544 unformat_l4_mask (unformat_input_t * input, va_list * args)
10546 u8 **maskp = va_arg (*args, u8 **);
10547 u16 src_port = 0, dst_port = 0;
10548 tcpudp_header_t *tcpudp;
10550 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10552 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10554 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10556 else if (unformat (input, "src_port"))
10558 else if (unformat (input, "dst_port"))
10564 if (!src_port && !dst_port)
10568 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10570 tcpudp = (tcpudp_header_t *) mask;
10571 tcpudp->src_port = src_port;
10572 tcpudp->dst_port = dst_port;
10580 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10582 u8 **maskp = va_arg (*args, u8 **);
10584 u8 found_something = 0;
10587 #define _(a) u8 a=0;
10588 foreach_ip4_proto_field;
10594 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10596 if (unformat (input, "version"))
10598 else if (unformat (input, "hdr_length"))
10600 else if (unformat (input, "src"))
10602 else if (unformat (input, "dst"))
10604 else if (unformat (input, "proto"))
10607 #define _(a) else if (unformat (input, #a)) a=1;
10608 foreach_ip4_proto_field
10614 #define _(a) found_something += a;
10615 foreach_ip4_proto_field;
10618 if (found_something == 0)
10621 vec_validate (mask, sizeof (*ip) - 1);
10623 ip = (ip4_header_t *) mask;
10625 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10626 foreach_ip4_proto_field;
10629 ip->ip_version_and_header_length = 0;
10632 ip->ip_version_and_header_length |= 0xF0;
10635 ip->ip_version_and_header_length |= 0x0F;
10641 #define foreach_ip6_proto_field \
10644 _(payload_length) \
10649 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10651 u8 **maskp = va_arg (*args, u8 **);
10653 u8 found_something = 0;
10655 u32 ip_version_traffic_class_and_flow_label;
10657 #define _(a) u8 a=0;
10658 foreach_ip6_proto_field;
10661 u8 traffic_class = 0;
10664 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10666 if (unformat (input, "version"))
10668 else if (unformat (input, "traffic-class"))
10670 else if (unformat (input, "flow-label"))
10672 else if (unformat (input, "src"))
10674 else if (unformat (input, "dst"))
10676 else if (unformat (input, "proto"))
10679 #define _(a) else if (unformat (input, #a)) a=1;
10680 foreach_ip6_proto_field
10686 #define _(a) found_something += a;
10687 foreach_ip6_proto_field;
10690 if (found_something == 0)
10693 vec_validate (mask, sizeof (*ip) - 1);
10695 ip = (ip6_header_t *) mask;
10697 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10698 foreach_ip6_proto_field;
10701 ip_version_traffic_class_and_flow_label = 0;
10704 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10707 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10710 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10712 ip->ip_version_traffic_class_and_flow_label =
10713 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10720 unformat_l3_mask (unformat_input_t * input, va_list * args)
10722 u8 **maskp = va_arg (*args, u8 **);
10724 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10726 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10728 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10737 unformat_l2_mask (unformat_input_t * input, va_list * args)
10739 u8 **maskp = va_arg (*args, u8 **);
10746 u8 ignore_tag1 = 0;
10747 u8 ignore_tag2 = 0;
10754 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10756 if (unformat (input, "src"))
10758 else if (unformat (input, "dst"))
10760 else if (unformat (input, "proto"))
10762 else if (unformat (input, "tag1"))
10764 else if (unformat (input, "tag2"))
10766 else if (unformat (input, "ignore-tag1"))
10768 else if (unformat (input, "ignore-tag2"))
10770 else if (unformat (input, "cos1"))
10772 else if (unformat (input, "cos2"))
10774 else if (unformat (input, "dot1q"))
10776 else if (unformat (input, "dot1ad"))
10781 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10782 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10785 if (tag1 || ignore_tag1 || cos1 || dot1q)
10787 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10790 vec_validate (mask, len - 1);
10793 memset (mask, 0xff, 6);
10796 memset (mask + 6, 0xff, 6);
10798 if (tag2 || dot1ad)
10800 /* inner vlan tag */
10809 mask[21] = mask[20] = 0xff;
10830 mask[16] = mask[17] = 0xff;
10840 mask[12] = mask[13] = 0xff;
10847 unformat_classify_mask (unformat_input_t * input, va_list * args)
10849 u8 **maskp = va_arg (*args, u8 **);
10850 u32 *skipp = va_arg (*args, u32 *);
10851 u32 *matchp = va_arg (*args, u32 *);
10859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10861 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10863 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10865 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10867 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10881 if (mask || l2 || l3 || l4)
10883 if (l2 || l3 || l4)
10885 /* "With a free Ethernet header in every package" */
10887 vec_validate (l2, 13);
10891 vec_append (mask, l3);
10896 vec_append (mask, l4);
10901 /* Scan forward looking for the first significant mask octet */
10902 for (i = 0; i < vec_len (mask); i++)
10906 /* compute (skip, match) params */
10907 *skipp = i / sizeof (u32x4);
10908 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10910 /* Pad mask to an even multiple of the vector size */
10911 while (vec_len (mask) % sizeof (u32x4))
10912 vec_add1 (mask, 0);
10914 match = vec_len (mask) / sizeof (u32x4);
10916 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10918 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10919 if (*tmp || *(tmp + 1))
10924 clib_warning ("BUG: match 0");
10926 _vec_len (mask) = match * sizeof (u32x4);
10936 #endif /* VPP_API_TEST_BUILTIN */
10938 #define foreach_l2_next \
10940 _(ethernet, ETHERNET_INPUT) \
10941 _(ip4, IP4_INPUT) \
10945 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10947 u32 *miss_next_indexp = va_arg (*args, u32 *);
10948 u32 next_index = 0;
10952 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10956 if (unformat (input, "%d", &tmp))
10965 *miss_next_indexp = next_index;
10969 #define foreach_ip_next \
10972 _(rewrite, REWRITE)
10975 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10977 u32 *miss_next_indexp = va_arg (*args, u32 *);
10978 u32 next_index = 0;
10982 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10986 if (unformat (input, "%d", &tmp))
10995 *miss_next_indexp = next_index;
10999 #define foreach_acl_next \
11003 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11005 u32 *miss_next_indexp = va_arg (*args, u32 *);
11006 u32 next_index = 0;
11010 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11014 if (unformat (input, "permit"))
11019 else if (unformat (input, "%d", &tmp))
11028 *miss_next_indexp = next_index;
11033 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11035 u32 *r = va_arg (*args, u32 *);
11037 if (unformat (input, "conform-color"))
11038 *r = POLICE_CONFORM;
11039 else if (unformat (input, "exceed-color"))
11040 *r = POLICE_EXCEED;
11048 api_classify_add_del_table (vat_main_t * vam)
11050 unformat_input_t *i = vam->input;
11051 vl_api_classify_add_del_table_t *mp;
11058 u32 table_index = ~0;
11059 u32 next_table_index = ~0;
11060 u32 miss_next_index = ~0;
11061 u32 memory_size = 32 << 20;
11063 u32 current_data_flag = 0;
11064 int current_data_offset = 0;
11067 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11069 if (unformat (i, "del"))
11071 else if (unformat (i, "del-chain"))
11076 else if (unformat (i, "buckets %d", &nbuckets))
11078 else if (unformat (i, "memory_size %d", &memory_size))
11080 else if (unformat (i, "skip %d", &skip))
11082 else if (unformat (i, "match %d", &match))
11084 else if (unformat (i, "table %d", &table_index))
11086 else if (unformat (i, "mask %U", unformat_classify_mask,
11087 &mask, &skip, &match))
11089 else if (unformat (i, "next-table %d", &next_table_index))
11091 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11094 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11097 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11100 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11102 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11108 if (is_add && mask == 0)
11110 errmsg ("Mask required");
11114 if (is_add && skip == ~0)
11116 errmsg ("skip count required");
11120 if (is_add && match == ~0)
11122 errmsg ("match count required");
11126 if (!is_add && table_index == ~0)
11128 errmsg ("table index required for delete");
11132 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11134 mp->is_add = is_add;
11135 mp->del_chain = del_chain;
11136 mp->table_index = ntohl (table_index);
11137 mp->nbuckets = ntohl (nbuckets);
11138 mp->memory_size = ntohl (memory_size);
11139 mp->skip_n_vectors = ntohl (skip);
11140 mp->match_n_vectors = ntohl (match);
11141 mp->next_table_index = ntohl (next_table_index);
11142 mp->miss_next_index = ntohl (miss_next_index);
11143 mp->current_data_flag = ntohl (current_data_flag);
11144 mp->current_data_offset = ntohl (current_data_offset);
11145 clib_memcpy (mp->mask, mask, vec_len (mask));
11154 #if VPP_API_TEST_BUILTIN == 0
11156 unformat_l4_match (unformat_input_t * input, va_list * args)
11158 u8 **matchp = va_arg (*args, u8 **);
11160 u8 *proto_header = 0;
11166 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11168 if (unformat (input, "src_port %d", &src_port))
11170 else if (unformat (input, "dst_port %d", &dst_port))
11176 h.src_port = clib_host_to_net_u16 (src_port);
11177 h.dst_port = clib_host_to_net_u16 (dst_port);
11178 vec_validate (proto_header, sizeof (h) - 1);
11179 memcpy (proto_header, &h, sizeof (h));
11181 *matchp = proto_header;
11187 unformat_ip4_match (unformat_input_t * input, va_list * args)
11189 u8 **matchp = va_arg (*args, u8 **);
11194 int hdr_length = 0;
11195 u32 hdr_length_val;
11196 int src = 0, dst = 0;
11197 ip4_address_t src_val, dst_val;
11204 int fragment_id = 0;
11205 u32 fragment_id_val;
11211 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11213 if (unformat (input, "version %d", &version_val))
11215 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11217 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11219 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11221 else if (unformat (input, "proto %d", &proto_val))
11223 else if (unformat (input, "tos %d", &tos_val))
11225 else if (unformat (input, "length %d", &length_val))
11227 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11229 else if (unformat (input, "ttl %d", &ttl_val))
11231 else if (unformat (input, "checksum %d", &checksum_val))
11237 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11238 + ttl + checksum == 0)
11242 * Aligned because we use the real comparison functions
11244 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11246 ip = (ip4_header_t *) match;
11248 /* These are realistically matched in practice */
11250 ip->src_address.as_u32 = src_val.as_u32;
11253 ip->dst_address.as_u32 = dst_val.as_u32;
11256 ip->protocol = proto_val;
11259 /* These are not, but they're included for completeness */
11261 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11264 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11270 ip->length = clib_host_to_net_u16 (length_val);
11276 ip->checksum = clib_host_to_net_u16 (checksum_val);
11283 unformat_ip6_match (unformat_input_t * input, va_list * args)
11285 u8 **matchp = va_arg (*args, u8 **);
11290 u8 traffic_class = 0;
11291 u32 traffic_class_val = 0;
11294 int src = 0, dst = 0;
11295 ip6_address_t src_val, dst_val;
11298 int payload_length = 0;
11299 u32 payload_length_val;
11302 u32 ip_version_traffic_class_and_flow_label;
11304 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11306 if (unformat (input, "version %d", &version_val))
11308 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11310 else if (unformat (input, "flow_label %d", &flow_label_val))
11312 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11314 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11316 else if (unformat (input, "proto %d", &proto_val))
11318 else if (unformat (input, "payload_length %d", &payload_length_val))
11319 payload_length = 1;
11320 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11326 if (version + traffic_class + flow_label + src + dst + proto +
11327 payload_length + hop_limit == 0)
11331 * Aligned because we use the real comparison functions
11333 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11335 ip = (ip6_header_t *) match;
11338 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11341 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11344 ip->protocol = proto_val;
11346 ip_version_traffic_class_and_flow_label = 0;
11349 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11352 ip_version_traffic_class_and_flow_label |=
11353 (traffic_class_val & 0xFF) << 20;
11356 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11358 ip->ip_version_traffic_class_and_flow_label =
11359 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11361 if (payload_length)
11362 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11365 ip->hop_limit = hop_limit_val;
11372 unformat_l3_match (unformat_input_t * input, va_list * args)
11374 u8 **matchp = va_arg (*args, u8 **);
11376 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11378 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11380 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11389 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11391 u8 *tagp = va_arg (*args, u8 *);
11394 if (unformat (input, "%d", &tag))
11396 tagp[0] = (tag >> 8) & 0x0F;
11397 tagp[1] = tag & 0xFF;
11405 unformat_l2_match (unformat_input_t * input, va_list * args)
11407 u8 **matchp = va_arg (*args, u8 **);
11420 u8 ignore_tag1 = 0;
11421 u8 ignore_tag2 = 0;
11427 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11429 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11432 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11434 else if (unformat (input, "proto %U",
11435 unformat_ethernet_type_host_byte_order, &proto_val))
11437 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11439 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11441 else if (unformat (input, "ignore-tag1"))
11443 else if (unformat (input, "ignore-tag2"))
11445 else if (unformat (input, "cos1 %d", &cos1_val))
11447 else if (unformat (input, "cos2 %d", &cos2_val))
11452 if ((src + dst + proto + tag1 + tag2 +
11453 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11456 if (tag1 || ignore_tag1 || cos1)
11458 if (tag2 || ignore_tag2 || cos2)
11461 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11464 clib_memcpy (match, dst_val, 6);
11467 clib_memcpy (match + 6, src_val, 6);
11471 /* inner vlan tag */
11472 match[19] = tag2_val[1];
11473 match[18] = tag2_val[0];
11475 match[18] |= (cos2_val & 0x7) << 5;
11478 match[21] = proto_val & 0xff;
11479 match[20] = proto_val >> 8;
11483 match[15] = tag1_val[1];
11484 match[14] = tag1_val[0];
11487 match[14] |= (cos1_val & 0x7) << 5;
11493 match[15] = tag1_val[1];
11494 match[14] = tag1_val[0];
11497 match[17] = proto_val & 0xff;
11498 match[16] = proto_val >> 8;
11501 match[14] |= (cos1_val & 0x7) << 5;
11507 match[18] |= (cos2_val & 0x7) << 5;
11509 match[14] |= (cos1_val & 0x7) << 5;
11512 match[13] = proto_val & 0xff;
11513 match[12] = proto_val >> 8;
11522 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11524 u8 **matchp = va_arg (*args, u8 **);
11525 u32 skip_n_vectors = va_arg (*args, u32);
11526 u32 match_n_vectors = va_arg (*args, u32);
11533 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11535 if (unformat (input, "hex %U", unformat_hex_string, &match))
11537 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11539 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11541 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11555 if (match || l2 || l3 || l4)
11557 if (l2 || l3 || l4)
11559 /* "Win a free Ethernet header in every packet" */
11561 vec_validate_aligned (l2, 13, sizeof (u32x4));
11565 vec_append_aligned (match, l3, sizeof (u32x4));
11570 vec_append_aligned (match, l4, sizeof (u32x4));
11575 /* Make sure the vector is big enough even if key is all 0's */
11576 vec_validate_aligned
11577 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11580 /* Set size, include skipped vectors */
11581 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11592 api_classify_add_del_session (vat_main_t * vam)
11594 unformat_input_t *i = vam->input;
11595 vl_api_classify_add_del_session_t *mp;
11597 u32 table_index = ~0;
11598 u32 hit_next_index = ~0;
11599 u32 opaque_index = ~0;
11602 u32 skip_n_vectors = 0;
11603 u32 match_n_vectors = 0;
11609 * Warning: you have to supply skip_n and match_n
11610 * because the API client cant simply look at the classify
11614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11616 if (unformat (i, "del"))
11618 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11621 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11624 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11627 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11629 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11631 else if (unformat (i, "opaque-index %d", &opaque_index))
11633 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11635 else if (unformat (i, "match_n %d", &match_n_vectors))
11637 else if (unformat (i, "match %U", api_unformat_classify_match,
11638 &match, skip_n_vectors, match_n_vectors))
11640 else if (unformat (i, "advance %d", &advance))
11642 else if (unformat (i, "table-index %d", &table_index))
11644 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11646 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11648 else if (unformat (i, "action %d", &action))
11650 else if (unformat (i, "metadata %d", &metadata))
11656 if (table_index == ~0)
11658 errmsg ("Table index required");
11662 if (is_add && match == 0)
11664 errmsg ("Match value required");
11668 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11670 mp->is_add = is_add;
11671 mp->table_index = ntohl (table_index);
11672 mp->hit_next_index = ntohl (hit_next_index);
11673 mp->opaque_index = ntohl (opaque_index);
11674 mp->advance = ntohl (advance);
11675 mp->action = action;
11676 mp->metadata = ntohl (metadata);
11677 clib_memcpy (mp->match, match, vec_len (match));
11686 api_classify_set_interface_ip_table (vat_main_t * vam)
11688 unformat_input_t *i = vam->input;
11689 vl_api_classify_set_interface_ip_table_t *mp;
11691 int sw_if_index_set;
11692 u32 table_index = ~0;
11696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11698 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11699 sw_if_index_set = 1;
11700 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11701 sw_if_index_set = 1;
11702 else if (unformat (i, "table %d", &table_index))
11706 clib_warning ("parse error '%U'", format_unformat_error, i);
11711 if (sw_if_index_set == 0)
11713 errmsg ("missing interface name or sw_if_index");
11718 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11720 mp->sw_if_index = ntohl (sw_if_index);
11721 mp->table_index = ntohl (table_index);
11722 mp->is_ipv6 = is_ipv6;
11730 api_classify_set_interface_l2_tables (vat_main_t * vam)
11732 unformat_input_t *i = vam->input;
11733 vl_api_classify_set_interface_l2_tables_t *mp;
11735 int sw_if_index_set;
11736 u32 ip4_table_index = ~0;
11737 u32 ip6_table_index = ~0;
11738 u32 other_table_index = ~0;
11742 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11744 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11745 sw_if_index_set = 1;
11746 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11747 sw_if_index_set = 1;
11748 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11750 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11752 else if (unformat (i, "other-table %d", &other_table_index))
11754 else if (unformat (i, "is-input %d", &is_input))
11758 clib_warning ("parse error '%U'", format_unformat_error, i);
11763 if (sw_if_index_set == 0)
11765 errmsg ("missing interface name or sw_if_index");
11770 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11772 mp->sw_if_index = ntohl (sw_if_index);
11773 mp->ip4_table_index = ntohl (ip4_table_index);
11774 mp->ip6_table_index = ntohl (ip6_table_index);
11775 mp->other_table_index = ntohl (other_table_index);
11776 mp->is_input = (u8) is_input;
11784 api_set_ipfix_exporter (vat_main_t * vam)
11786 unformat_input_t *i = vam->input;
11787 vl_api_set_ipfix_exporter_t *mp;
11788 ip4_address_t collector_address;
11789 u8 collector_address_set = 0;
11790 u32 collector_port = ~0;
11791 ip4_address_t src_address;
11792 u8 src_address_set = 0;
11795 u32 template_interval = ~0;
11796 u8 udp_checksum = 0;
11799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11801 if (unformat (i, "collector_address %U", unformat_ip4_address,
11802 &collector_address))
11803 collector_address_set = 1;
11804 else if (unformat (i, "collector_port %d", &collector_port))
11806 else if (unformat (i, "src_address %U", unformat_ip4_address,
11808 src_address_set = 1;
11809 else if (unformat (i, "vrf_id %d", &vrf_id))
11811 else if (unformat (i, "path_mtu %d", &path_mtu))
11813 else if (unformat (i, "template_interval %d", &template_interval))
11815 else if (unformat (i, "udp_checksum"))
11821 if (collector_address_set == 0)
11823 errmsg ("collector_address required");
11827 if (src_address_set == 0)
11829 errmsg ("src_address required");
11833 M (SET_IPFIX_EXPORTER, mp);
11835 memcpy (mp->collector_address, collector_address.data,
11836 sizeof (collector_address.data));
11837 mp->collector_port = htons ((u16) collector_port);
11838 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11839 mp->vrf_id = htonl (vrf_id);
11840 mp->path_mtu = htonl (path_mtu);
11841 mp->template_interval = htonl (template_interval);
11842 mp->udp_checksum = udp_checksum;
11850 api_set_ipfix_classify_stream (vat_main_t * vam)
11852 unformat_input_t *i = vam->input;
11853 vl_api_set_ipfix_classify_stream_t *mp;
11855 u32 src_port = UDP_DST_PORT_ipfix;
11858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11860 if (unformat (i, "domain %d", &domain_id))
11862 else if (unformat (i, "src_port %d", &src_port))
11866 errmsg ("unknown input `%U'", format_unformat_error, i);
11871 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11873 mp->domain_id = htonl (domain_id);
11874 mp->src_port = htons ((u16) src_port);
11882 api_ipfix_classify_table_add_del (vat_main_t * vam)
11884 unformat_input_t *i = vam->input;
11885 vl_api_ipfix_classify_table_add_del_t *mp;
11887 u32 classify_table_index = ~0;
11889 u8 transport_protocol = 255;
11892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11894 if (unformat (i, "add"))
11896 else if (unformat (i, "del"))
11898 else if (unformat (i, "table %d", &classify_table_index))
11900 else if (unformat (i, "ip4"))
11902 else if (unformat (i, "ip6"))
11904 else if (unformat (i, "tcp"))
11905 transport_protocol = 6;
11906 else if (unformat (i, "udp"))
11907 transport_protocol = 17;
11910 errmsg ("unknown input `%U'", format_unformat_error, i);
11917 errmsg ("expecting: add|del");
11920 if (classify_table_index == ~0)
11922 errmsg ("classifier table not specified");
11925 if (ip_version == 0)
11927 errmsg ("IP version not specified");
11931 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11933 mp->is_add = is_add;
11934 mp->table_id = htonl (classify_table_index);
11935 mp->ip_version = ip_version;
11936 mp->transport_protocol = transport_protocol;
11944 api_get_node_index (vat_main_t * vam)
11946 unformat_input_t *i = vam->input;
11947 vl_api_get_node_index_t *mp;
11951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11953 if (unformat (i, "node %s", &name))
11960 errmsg ("node name required");
11963 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11965 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11969 M (GET_NODE_INDEX, mp);
11970 clib_memcpy (mp->node_name, name, vec_len (name));
11979 api_get_next_index (vat_main_t * vam)
11981 unformat_input_t *i = vam->input;
11982 vl_api_get_next_index_t *mp;
11983 u8 *node_name = 0, *next_node_name = 0;
11986 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11988 if (unformat (i, "node-name %s", &node_name))
11990 else if (unformat (i, "next-node-name %s", &next_node_name))
11994 if (node_name == 0)
11996 errmsg ("node name required");
11999 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12001 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12005 if (next_node_name == 0)
12007 errmsg ("next node name required");
12010 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12012 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12016 M (GET_NEXT_INDEX, mp);
12017 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12018 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12019 vec_free (node_name);
12020 vec_free (next_node_name);
12028 api_add_node_next (vat_main_t * vam)
12030 unformat_input_t *i = vam->input;
12031 vl_api_add_node_next_t *mp;
12036 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12038 if (unformat (i, "node %s", &name))
12040 else if (unformat (i, "next %s", &next))
12047 errmsg ("node name required");
12050 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12052 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12057 errmsg ("next node required");
12060 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12062 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12066 M (ADD_NODE_NEXT, mp);
12067 clib_memcpy (mp->node_name, name, vec_len (name));
12068 clib_memcpy (mp->next_name, next, vec_len (next));
12078 api_l2tpv3_create_tunnel (vat_main_t * vam)
12080 unformat_input_t *i = vam->input;
12081 ip6_address_t client_address, our_address;
12082 int client_address_set = 0;
12083 int our_address_set = 0;
12084 u32 local_session_id = 0;
12085 u32 remote_session_id = 0;
12086 u64 local_cookie = 0;
12087 u64 remote_cookie = 0;
12088 u8 l2_sublayer_present = 0;
12089 vl_api_l2tpv3_create_tunnel_t *mp;
12092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12094 if (unformat (i, "client_address %U", unformat_ip6_address,
12096 client_address_set = 1;
12097 else if (unformat (i, "our_address %U", unformat_ip6_address,
12099 our_address_set = 1;
12100 else if (unformat (i, "local_session_id %d", &local_session_id))
12102 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12104 else if (unformat (i, "local_cookie %lld", &local_cookie))
12106 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12108 else if (unformat (i, "l2-sublayer-present"))
12109 l2_sublayer_present = 1;
12114 if (client_address_set == 0)
12116 errmsg ("client_address required");
12120 if (our_address_set == 0)
12122 errmsg ("our_address required");
12126 M (L2TPV3_CREATE_TUNNEL, mp);
12128 clib_memcpy (mp->client_address, client_address.as_u8,
12129 sizeof (mp->client_address));
12131 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12133 mp->local_session_id = ntohl (local_session_id);
12134 mp->remote_session_id = ntohl (remote_session_id);
12135 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12136 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12137 mp->l2_sublayer_present = l2_sublayer_present;
12146 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12148 unformat_input_t *i = vam->input;
12150 u8 sw_if_index_set = 0;
12151 u64 new_local_cookie = 0;
12152 u64 new_remote_cookie = 0;
12153 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12156 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12158 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12159 sw_if_index_set = 1;
12160 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12161 sw_if_index_set = 1;
12162 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12164 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12170 if (sw_if_index_set == 0)
12172 errmsg ("missing interface name or sw_if_index");
12176 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12178 mp->sw_if_index = ntohl (sw_if_index);
12179 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12180 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12188 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12190 unformat_input_t *i = vam->input;
12191 vl_api_l2tpv3_interface_enable_disable_t *mp;
12193 u8 sw_if_index_set = 0;
12194 u8 enable_disable = 1;
12197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12199 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12200 sw_if_index_set = 1;
12201 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12202 sw_if_index_set = 1;
12203 else if (unformat (i, "enable"))
12204 enable_disable = 1;
12205 else if (unformat (i, "disable"))
12206 enable_disable = 0;
12211 if (sw_if_index_set == 0)
12213 errmsg ("missing interface name or sw_if_index");
12217 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12219 mp->sw_if_index = ntohl (sw_if_index);
12220 mp->enable_disable = enable_disable;
12228 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12230 unformat_input_t *i = vam->input;
12231 vl_api_l2tpv3_set_lookup_key_t *mp;
12235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12237 if (unformat (i, "lookup_v6_src"))
12238 key = L2T_LOOKUP_SRC_ADDRESS;
12239 else if (unformat (i, "lookup_v6_dst"))
12240 key = L2T_LOOKUP_DST_ADDRESS;
12241 else if (unformat (i, "lookup_session_id"))
12242 key = L2T_LOOKUP_SESSION_ID;
12247 if (key == (u8) ~ 0)
12249 errmsg ("l2tp session lookup key unset");
12253 M (L2TPV3_SET_LOOKUP_KEY, mp);
12262 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12263 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12265 vat_main_t *vam = &vat_main;
12267 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12268 format_ip6_address, mp->our_address,
12269 format_ip6_address, mp->client_address,
12270 clib_net_to_host_u32 (mp->sw_if_index));
12273 " local cookies %016llx %016llx remote cookie %016llx",
12274 clib_net_to_host_u64 (mp->local_cookie[0]),
12275 clib_net_to_host_u64 (mp->local_cookie[1]),
12276 clib_net_to_host_u64 (mp->remote_cookie));
12278 print (vam->ofp, " local session-id %d remote session-id %d",
12279 clib_net_to_host_u32 (mp->local_session_id),
12280 clib_net_to_host_u32 (mp->remote_session_id));
12282 print (vam->ofp, " l2 specific sublayer %s\n",
12283 mp->l2_sublayer_present ? "preset" : "absent");
12287 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12288 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12290 vat_main_t *vam = &vat_main;
12291 vat_json_node_t *node = NULL;
12292 struct in6_addr addr;
12294 if (VAT_JSON_ARRAY != vam->json_tree.type)
12296 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12297 vat_json_init_array (&vam->json_tree);
12299 node = vat_json_array_add (&vam->json_tree);
12301 vat_json_init_object (node);
12303 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12304 vat_json_object_add_ip6 (node, "our_address", addr);
12305 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12306 vat_json_object_add_ip6 (node, "client_address", addr);
12308 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12309 vat_json_init_array (lc);
12310 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12311 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12312 vat_json_object_add_uint (node, "remote_cookie",
12313 clib_net_to_host_u64 (mp->remote_cookie));
12315 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12316 vat_json_object_add_uint (node, "local_session_id",
12317 clib_net_to_host_u32 (mp->local_session_id));
12318 vat_json_object_add_uint (node, "remote_session_id",
12319 clib_net_to_host_u32 (mp->remote_session_id));
12320 vat_json_object_add_string_copy (node, "l2_sublayer",
12321 mp->l2_sublayer_present ? (u8 *) "present"
12322 : (u8 *) "absent");
12326 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12328 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12329 vl_api_control_ping_t *mp_ping;
12332 /* Get list of l2tpv3-tunnel interfaces */
12333 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12336 /* Use a control ping for synchronization */
12337 MPING (CONTROL_PING, mp_ping);
12345 static void vl_api_sw_interface_tap_details_t_handler
12346 (vl_api_sw_interface_tap_details_t * mp)
12348 vat_main_t *vam = &vat_main;
12350 print (vam->ofp, "%-16s %d",
12351 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12354 static void vl_api_sw_interface_tap_details_t_handler_json
12355 (vl_api_sw_interface_tap_details_t * mp)
12357 vat_main_t *vam = &vat_main;
12358 vat_json_node_t *node = NULL;
12360 if (VAT_JSON_ARRAY != vam->json_tree.type)
12362 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12363 vat_json_init_array (&vam->json_tree);
12365 node = vat_json_array_add (&vam->json_tree);
12367 vat_json_init_object (node);
12368 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12369 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12373 api_sw_interface_tap_dump (vat_main_t * vam)
12375 vl_api_sw_interface_tap_dump_t *mp;
12376 vl_api_control_ping_t *mp_ping;
12379 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12380 /* Get list of tap interfaces */
12381 M (SW_INTERFACE_TAP_DUMP, mp);
12384 /* Use a control ping for synchronization */
12385 MPING (CONTROL_PING, mp_ping);
12392 static void vl_api_sw_interface_tap_v2_details_t_handler
12393 (vl_api_sw_interface_tap_v2_details_t * mp)
12395 vat_main_t *vam = &vat_main;
12397 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12398 mp->host_ip4_prefix_len);
12399 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12400 mp->host_ip6_prefix_len);
12403 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s",
12404 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12405 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12406 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12407 mp->host_bridge, ip4, ip6);
12413 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12414 (vl_api_sw_interface_tap_v2_details_t * mp)
12416 vat_main_t *vam = &vat_main;
12417 vat_json_node_t *node = NULL;
12419 if (VAT_JSON_ARRAY != vam->json_tree.type)
12421 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12422 vat_json_init_array (&vam->json_tree);
12424 node = vat_json_array_add (&vam->json_tree);
12426 vat_json_init_object (node);
12427 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12428 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12429 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12430 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12431 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12432 vat_json_object_add_string_copy (node, "host_mac_addr",
12433 format (0, "%U", format_ethernet_address,
12434 &mp->host_mac_addr));
12435 vat_json_object_add_string_copy (node, "host_namespace",
12436 mp->host_namespace);
12437 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12438 vat_json_object_add_string_copy (node, "host_ip4_addr",
12439 format (0, "%U/%d", format_ip4_address,
12441 mp->host_ip4_prefix_len));
12442 vat_json_object_add_string_copy (node, "host_ip6_addr",
12443 format (0, "%U/%d", format_ip6_address,
12445 mp->host_ip6_prefix_len));
12450 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12452 vl_api_sw_interface_tap_v2_dump_t *mp;
12453 vl_api_control_ping_t *mp_ping;
12457 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12458 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12459 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12462 /* Get list of tap interfaces */
12463 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12466 /* Use a control ping for synchronization */
12467 MPING (CONTROL_PING, mp_ping);
12474 static uword unformat_vxlan_decap_next
12475 (unformat_input_t * input, va_list * args)
12477 u32 *result = va_arg (*args, u32 *);
12480 if (unformat (input, "l2"))
12481 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12482 else if (unformat (input, "%d", &tmp))
12490 api_vxlan_add_del_tunnel (vat_main_t * vam)
12492 unformat_input_t *line_input = vam->input;
12493 vl_api_vxlan_add_del_tunnel_t *mp;
12494 ip46_address_t src, dst;
12496 u8 ipv4_set = 0, ipv6_set = 0;
12500 u32 mcast_sw_if_index = ~0;
12501 u32 encap_vrf_id = 0;
12502 u32 decap_next_index = ~0;
12506 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12507 memset (&src, 0, sizeof src);
12508 memset (&dst, 0, sizeof dst);
12510 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12512 if (unformat (line_input, "del"))
12515 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12521 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12527 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12533 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12538 else if (unformat (line_input, "group %U %U",
12539 unformat_ip4_address, &dst.ip4,
12540 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12542 grp_set = dst_set = 1;
12545 else if (unformat (line_input, "group %U",
12546 unformat_ip4_address, &dst.ip4))
12548 grp_set = dst_set = 1;
12551 else if (unformat (line_input, "group %U %U",
12552 unformat_ip6_address, &dst.ip6,
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_ip6_address, &dst.ip6))
12561 grp_set = dst_set = 1;
12565 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12567 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12569 else if (unformat (line_input, "decap-next %U",
12570 unformat_vxlan_decap_next, &decap_next_index))
12572 else if (unformat (line_input, "vni %d", &vni))
12576 errmsg ("parse error '%U'", format_unformat_error, line_input);
12583 errmsg ("tunnel src address not specified");
12588 errmsg ("tunnel dst address not specified");
12592 if (grp_set && !ip46_address_is_multicast (&dst))
12594 errmsg ("tunnel group address not multicast");
12597 if (grp_set && mcast_sw_if_index == ~0)
12599 errmsg ("tunnel nonexistent multicast device");
12602 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12604 errmsg ("tunnel dst address must be unicast");
12609 if (ipv4_set && ipv6_set)
12611 errmsg ("both IPv4 and IPv6 addresses specified");
12615 if ((vni == 0) || (vni >> 24))
12617 errmsg ("vni not specified or out of range");
12621 M (VXLAN_ADD_DEL_TUNNEL, mp);
12625 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12626 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12630 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12631 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12633 mp->encap_vrf_id = ntohl (encap_vrf_id);
12634 mp->decap_next_index = ntohl (decap_next_index);
12635 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12636 mp->vni = ntohl (vni);
12637 mp->is_add = is_add;
12638 mp->is_ipv6 = ipv6_set;
12645 static void vl_api_vxlan_tunnel_details_t_handler
12646 (vl_api_vxlan_tunnel_details_t * mp)
12648 vat_main_t *vam = &vat_main;
12649 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12650 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12652 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12653 ntohl (mp->sw_if_index),
12654 format_ip46_address, &src, IP46_TYPE_ANY,
12655 format_ip46_address, &dst, IP46_TYPE_ANY,
12656 ntohl (mp->encap_vrf_id),
12657 ntohl (mp->decap_next_index), ntohl (mp->vni),
12658 ntohl (mp->mcast_sw_if_index));
12661 static void vl_api_vxlan_tunnel_details_t_handler_json
12662 (vl_api_vxlan_tunnel_details_t * mp)
12664 vat_main_t *vam = &vat_main;
12665 vat_json_node_t *node = NULL;
12667 if (VAT_JSON_ARRAY != vam->json_tree.type)
12669 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12670 vat_json_init_array (&vam->json_tree);
12672 node = vat_json_array_add (&vam->json_tree);
12674 vat_json_init_object (node);
12675 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12678 struct in6_addr ip6;
12680 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12681 vat_json_object_add_ip6 (node, "src_address", ip6);
12682 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12683 vat_json_object_add_ip6 (node, "dst_address", ip6);
12687 struct in_addr ip4;
12689 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12690 vat_json_object_add_ip4 (node, "src_address", ip4);
12691 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12692 vat_json_object_add_ip4 (node, "dst_address", ip4);
12694 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12695 vat_json_object_add_uint (node, "decap_next_index",
12696 ntohl (mp->decap_next_index));
12697 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12698 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12699 vat_json_object_add_uint (node, "mcast_sw_if_index",
12700 ntohl (mp->mcast_sw_if_index));
12704 api_vxlan_tunnel_dump (vat_main_t * vam)
12706 unformat_input_t *i = vam->input;
12707 vl_api_vxlan_tunnel_dump_t *mp;
12708 vl_api_control_ping_t *mp_ping;
12710 u8 sw_if_index_set = 0;
12713 /* Parse args required to build the message */
12714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12716 if (unformat (i, "sw_if_index %d", &sw_if_index))
12717 sw_if_index_set = 1;
12722 if (sw_if_index_set == 0)
12727 if (!vam->json_output)
12729 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12730 "sw_if_index", "src_address", "dst_address",
12731 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12734 /* Get list of vxlan-tunnel interfaces */
12735 M (VXLAN_TUNNEL_DUMP, mp);
12737 mp->sw_if_index = htonl (sw_if_index);
12741 /* Use a control ping for synchronization */
12742 MPING (CONTROL_PING, mp_ping);
12749 static uword unformat_geneve_decap_next
12750 (unformat_input_t * input, va_list * args)
12752 u32 *result = va_arg (*args, u32 *);
12755 if (unformat (input, "l2"))
12756 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12757 else if (unformat (input, "%d", &tmp))
12765 api_geneve_add_del_tunnel (vat_main_t * vam)
12767 unformat_input_t *line_input = vam->input;
12768 vl_api_geneve_add_del_tunnel_t *mp;
12769 ip46_address_t src, dst;
12771 u8 ipv4_set = 0, ipv6_set = 0;
12775 u32 mcast_sw_if_index = ~0;
12776 u32 encap_vrf_id = 0;
12777 u32 decap_next_index = ~0;
12781 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12782 memset (&src, 0, sizeof src);
12783 memset (&dst, 0, sizeof dst);
12785 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12787 if (unformat (line_input, "del"))
12790 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12796 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12802 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12808 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12813 else if (unformat (line_input, "group %U %U",
12814 unformat_ip4_address, &dst.ip4,
12815 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12817 grp_set = dst_set = 1;
12820 else if (unformat (line_input, "group %U",
12821 unformat_ip4_address, &dst.ip4))
12823 grp_set = dst_set = 1;
12826 else if (unformat (line_input, "group %U %U",
12827 unformat_ip6_address, &dst.ip6,
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_ip6_address, &dst.ip6))
12836 grp_set = dst_set = 1;
12840 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12842 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12844 else if (unformat (line_input, "decap-next %U",
12845 unformat_geneve_decap_next, &decap_next_index))
12847 else if (unformat (line_input, "vni %d", &vni))
12851 errmsg ("parse error '%U'", format_unformat_error, line_input);
12858 errmsg ("tunnel src address not specified");
12863 errmsg ("tunnel dst address not specified");
12867 if (grp_set && !ip46_address_is_multicast (&dst))
12869 errmsg ("tunnel group address not multicast");
12872 if (grp_set && mcast_sw_if_index == ~0)
12874 errmsg ("tunnel nonexistent multicast device");
12877 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12879 errmsg ("tunnel dst address must be unicast");
12884 if (ipv4_set && ipv6_set)
12886 errmsg ("both IPv4 and IPv6 addresses specified");
12890 if ((vni == 0) || (vni >> 24))
12892 errmsg ("vni not specified or out of range");
12896 M (GENEVE_ADD_DEL_TUNNEL, mp);
12900 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12901 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12905 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12906 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12908 mp->encap_vrf_id = ntohl (encap_vrf_id);
12909 mp->decap_next_index = ntohl (decap_next_index);
12910 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12911 mp->vni = ntohl (vni);
12912 mp->is_add = is_add;
12913 mp->is_ipv6 = ipv6_set;
12920 static void vl_api_geneve_tunnel_details_t_handler
12921 (vl_api_geneve_tunnel_details_t * mp)
12923 vat_main_t *vam = &vat_main;
12924 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12925 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12927 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12928 ntohl (mp->sw_if_index),
12929 format_ip46_address, &src, IP46_TYPE_ANY,
12930 format_ip46_address, &dst, IP46_TYPE_ANY,
12931 ntohl (mp->encap_vrf_id),
12932 ntohl (mp->decap_next_index), ntohl (mp->vni),
12933 ntohl (mp->mcast_sw_if_index));
12936 static void vl_api_geneve_tunnel_details_t_handler_json
12937 (vl_api_geneve_tunnel_details_t * mp)
12939 vat_main_t *vam = &vat_main;
12940 vat_json_node_t *node = NULL;
12942 if (VAT_JSON_ARRAY != vam->json_tree.type)
12944 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12945 vat_json_init_array (&vam->json_tree);
12947 node = vat_json_array_add (&vam->json_tree);
12949 vat_json_init_object (node);
12950 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12953 struct in6_addr ip6;
12955 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12956 vat_json_object_add_ip6 (node, "src_address", ip6);
12957 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12958 vat_json_object_add_ip6 (node, "dst_address", ip6);
12962 struct in_addr ip4;
12964 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12965 vat_json_object_add_ip4 (node, "src_address", ip4);
12966 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12967 vat_json_object_add_ip4 (node, "dst_address", ip4);
12969 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12970 vat_json_object_add_uint (node, "decap_next_index",
12971 ntohl (mp->decap_next_index));
12972 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12973 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12974 vat_json_object_add_uint (node, "mcast_sw_if_index",
12975 ntohl (mp->mcast_sw_if_index));
12979 api_geneve_tunnel_dump (vat_main_t * vam)
12981 unformat_input_t *i = vam->input;
12982 vl_api_geneve_tunnel_dump_t *mp;
12983 vl_api_control_ping_t *mp_ping;
12985 u8 sw_if_index_set = 0;
12988 /* Parse args required to build the message */
12989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12991 if (unformat (i, "sw_if_index %d", &sw_if_index))
12992 sw_if_index_set = 1;
12997 if (sw_if_index_set == 0)
13002 if (!vam->json_output)
13004 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13005 "sw_if_index", "local_address", "remote_address",
13006 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13009 /* Get list of geneve-tunnel interfaces */
13010 M (GENEVE_TUNNEL_DUMP, mp);
13012 mp->sw_if_index = htonl (sw_if_index);
13016 /* Use a control ping for synchronization */
13017 M (CONTROL_PING, mp_ping);
13025 api_gre_add_del_tunnel (vat_main_t * vam)
13027 unformat_input_t *line_input = vam->input;
13028 vl_api_gre_add_del_tunnel_t *mp;
13029 ip4_address_t src4, dst4;
13030 ip6_address_t src6, dst6;
13037 u32 outer_fib_id = 0;
13040 memset (&src4, 0, sizeof src4);
13041 memset (&dst4, 0, sizeof dst4);
13042 memset (&src6, 0, sizeof src6);
13043 memset (&dst6, 0, sizeof dst6);
13045 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13047 if (unformat (line_input, "del"))
13049 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13054 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13059 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13064 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13069 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13071 else if (unformat (line_input, "teb"))
13075 errmsg ("parse error '%U'", format_unformat_error, line_input);
13082 errmsg ("tunnel src address not specified");
13087 errmsg ("tunnel dst address not specified");
13090 if (ipv4_set && ipv6_set)
13092 errmsg ("both IPv4 and IPv6 addresses specified");
13097 M (GRE_ADD_DEL_TUNNEL, mp);
13101 clib_memcpy (&mp->src_address, &src4, 4);
13102 clib_memcpy (&mp->dst_address, &dst4, 4);
13106 clib_memcpy (&mp->src_address, &src6, 16);
13107 clib_memcpy (&mp->dst_address, &dst6, 16);
13109 mp->outer_fib_id = ntohl (outer_fib_id);
13110 mp->is_add = is_add;
13112 mp->is_ipv6 = ipv6_set;
13119 static void vl_api_gre_tunnel_details_t_handler
13120 (vl_api_gre_tunnel_details_t * mp)
13122 vat_main_t *vam = &vat_main;
13123 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13124 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13126 print (vam->ofp, "%11d%24U%24U%6d%14d",
13127 ntohl (mp->sw_if_index),
13128 format_ip46_address, &src, IP46_TYPE_ANY,
13129 format_ip46_address, &dst, IP46_TYPE_ANY,
13130 mp->teb, ntohl (mp->outer_fib_id));
13133 static void vl_api_gre_tunnel_details_t_handler_json
13134 (vl_api_gre_tunnel_details_t * mp)
13136 vat_main_t *vam = &vat_main;
13137 vat_json_node_t *node = NULL;
13138 struct in_addr ip4;
13139 struct in6_addr ip6;
13141 if (VAT_JSON_ARRAY != vam->json_tree.type)
13143 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13144 vat_json_init_array (&vam->json_tree);
13146 node = vat_json_array_add (&vam->json_tree);
13148 vat_json_init_object (node);
13149 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13152 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13153 vat_json_object_add_ip4 (node, "src_address", ip4);
13154 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13155 vat_json_object_add_ip4 (node, "dst_address", ip4);
13159 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13160 vat_json_object_add_ip6 (node, "src_address", ip6);
13161 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13162 vat_json_object_add_ip6 (node, "dst_address", ip6);
13164 vat_json_object_add_uint (node, "teb", mp->teb);
13165 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13166 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13170 api_gre_tunnel_dump (vat_main_t * vam)
13172 unformat_input_t *i = vam->input;
13173 vl_api_gre_tunnel_dump_t *mp;
13174 vl_api_control_ping_t *mp_ping;
13176 u8 sw_if_index_set = 0;
13179 /* Parse args required to build the message */
13180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13182 if (unformat (i, "sw_if_index %d", &sw_if_index))
13183 sw_if_index_set = 1;
13188 if (sw_if_index_set == 0)
13193 if (!vam->json_output)
13195 print (vam->ofp, "%11s%24s%24s%6s%14s",
13196 "sw_if_index", "src_address", "dst_address", "teb",
13200 /* Get list of gre-tunnel interfaces */
13201 M (GRE_TUNNEL_DUMP, mp);
13203 mp->sw_if_index = htonl (sw_if_index);
13207 /* Use a control ping for synchronization */
13208 MPING (CONTROL_PING, mp_ping);
13216 api_l2_fib_clear_table (vat_main_t * vam)
13218 // unformat_input_t * i = vam->input;
13219 vl_api_l2_fib_clear_table_t *mp;
13222 M (L2_FIB_CLEAR_TABLE, mp);
13230 api_l2_interface_efp_filter (vat_main_t * vam)
13232 unformat_input_t *i = vam->input;
13233 vl_api_l2_interface_efp_filter_t *mp;
13236 u8 sw_if_index_set = 0;
13239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13241 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13242 sw_if_index_set = 1;
13243 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13244 sw_if_index_set = 1;
13245 else if (unformat (i, "enable"))
13247 else if (unformat (i, "disable"))
13251 clib_warning ("parse error '%U'", format_unformat_error, i);
13256 if (sw_if_index_set == 0)
13258 errmsg ("missing sw_if_index");
13262 M (L2_INTERFACE_EFP_FILTER, mp);
13264 mp->sw_if_index = ntohl (sw_if_index);
13265 mp->enable_disable = enable;
13272 #define foreach_vtr_op \
13273 _("disable", L2_VTR_DISABLED) \
13274 _("push-1", L2_VTR_PUSH_1) \
13275 _("push-2", L2_VTR_PUSH_2) \
13276 _("pop-1", L2_VTR_POP_1) \
13277 _("pop-2", L2_VTR_POP_2) \
13278 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13279 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13280 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13281 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13284 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13286 unformat_input_t *i = vam->input;
13287 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13289 u8 sw_if_index_set = 0;
13292 u32 push_dot1q = 1;
13297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13299 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13300 sw_if_index_set = 1;
13301 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13302 sw_if_index_set = 1;
13303 else if (unformat (i, "vtr_op %d", &vtr_op))
13305 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13308 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13310 else if (unformat (i, "tag1 %d", &tag1))
13312 else if (unformat (i, "tag2 %d", &tag2))
13316 clib_warning ("parse error '%U'", format_unformat_error, i);
13321 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13323 errmsg ("missing vtr operation or sw_if_index");
13327 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13328 mp->sw_if_index = ntohl (sw_if_index);
13329 mp->vtr_op = ntohl (vtr_op);
13330 mp->push_dot1q = ntohl (push_dot1q);
13331 mp->tag1 = ntohl (tag1);
13332 mp->tag2 = ntohl (tag2);
13340 api_create_vhost_user_if (vat_main_t * vam)
13342 unformat_input_t *i = vam->input;
13343 vl_api_create_vhost_user_if_t *mp;
13346 u8 file_name_set = 0;
13347 u32 custom_dev_instance = ~0;
13349 u8 use_custom_mac = 0;
13353 /* Shut up coverity */
13354 memset (hwaddr, 0, sizeof (hwaddr));
13356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13358 if (unformat (i, "socket %s", &file_name))
13362 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13364 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13365 use_custom_mac = 1;
13366 else if (unformat (i, "server"))
13368 else if (unformat (i, "tag %s", &tag))
13374 if (file_name_set == 0)
13376 errmsg ("missing socket file name");
13380 if (vec_len (file_name) > 255)
13382 errmsg ("socket file name too long");
13385 vec_add1 (file_name, 0);
13387 M (CREATE_VHOST_USER_IF, mp);
13389 mp->is_server = is_server;
13390 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13391 vec_free (file_name);
13392 if (custom_dev_instance != ~0)
13395 mp->custom_dev_instance = ntohl (custom_dev_instance);
13397 mp->use_custom_mac = use_custom_mac;
13398 clib_memcpy (mp->mac_address, hwaddr, 6);
13400 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13409 api_modify_vhost_user_if (vat_main_t * vam)
13411 unformat_input_t *i = vam->input;
13412 vl_api_modify_vhost_user_if_t *mp;
13415 u8 file_name_set = 0;
13416 u32 custom_dev_instance = ~0;
13417 u8 sw_if_index_set = 0;
13418 u32 sw_if_index = (u32) ~ 0;
13421 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13423 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13424 sw_if_index_set = 1;
13425 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13426 sw_if_index_set = 1;
13427 else if (unformat (i, "socket %s", &file_name))
13431 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13433 else if (unformat (i, "server"))
13439 if (sw_if_index_set == 0)
13441 errmsg ("missing sw_if_index or interface name");
13445 if (file_name_set == 0)
13447 errmsg ("missing socket file name");
13451 if (vec_len (file_name) > 255)
13453 errmsg ("socket file name too long");
13456 vec_add1 (file_name, 0);
13458 M (MODIFY_VHOST_USER_IF, mp);
13460 mp->sw_if_index = ntohl (sw_if_index);
13461 mp->is_server = is_server;
13462 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13463 vec_free (file_name);
13464 if (custom_dev_instance != ~0)
13467 mp->custom_dev_instance = ntohl (custom_dev_instance);
13476 api_delete_vhost_user_if (vat_main_t * vam)
13478 unformat_input_t *i = vam->input;
13479 vl_api_delete_vhost_user_if_t *mp;
13480 u32 sw_if_index = ~0;
13481 u8 sw_if_index_set = 0;
13484 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13486 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13487 sw_if_index_set = 1;
13488 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13489 sw_if_index_set = 1;
13494 if (sw_if_index_set == 0)
13496 errmsg ("missing sw_if_index or interface name");
13501 M (DELETE_VHOST_USER_IF, mp);
13503 mp->sw_if_index = ntohl (sw_if_index);
13510 static void vl_api_sw_interface_vhost_user_details_t_handler
13511 (vl_api_sw_interface_vhost_user_details_t * mp)
13513 vat_main_t *vam = &vat_main;
13515 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13516 (char *) mp->interface_name,
13517 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13518 clib_net_to_host_u64 (mp->features), mp->is_server,
13519 ntohl (mp->num_regions), (char *) mp->sock_filename);
13520 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13523 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13524 (vl_api_sw_interface_vhost_user_details_t * mp)
13526 vat_main_t *vam = &vat_main;
13527 vat_json_node_t *node = NULL;
13529 if (VAT_JSON_ARRAY != vam->json_tree.type)
13531 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13532 vat_json_init_array (&vam->json_tree);
13534 node = vat_json_array_add (&vam->json_tree);
13536 vat_json_init_object (node);
13537 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13538 vat_json_object_add_string_copy (node, "interface_name",
13539 mp->interface_name);
13540 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13541 ntohl (mp->virtio_net_hdr_sz));
13542 vat_json_object_add_uint (node, "features",
13543 clib_net_to_host_u64 (mp->features));
13544 vat_json_object_add_uint (node, "is_server", mp->is_server);
13545 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13546 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13547 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13551 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13553 vl_api_sw_interface_vhost_user_dump_t *mp;
13554 vl_api_control_ping_t *mp_ping;
13557 "Interface name idx hdr_sz features server regions filename");
13559 /* Get list of vhost-user interfaces */
13560 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13563 /* Use a control ping for synchronization */
13564 MPING (CONTROL_PING, mp_ping);
13572 api_show_version (vat_main_t * vam)
13574 vl_api_show_version_t *mp;
13577 M (SHOW_VERSION, mp);
13586 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13588 unformat_input_t *line_input = vam->input;
13589 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13590 ip4_address_t local4, remote4;
13591 ip6_address_t local6, remote6;
13593 u8 ipv4_set = 0, ipv6_set = 0;
13597 u32 mcast_sw_if_index = ~0;
13598 u32 encap_vrf_id = 0;
13599 u32 decap_vrf_id = 0;
13605 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13606 memset (&local4, 0, sizeof local4);
13607 memset (&remote4, 0, sizeof remote4);
13608 memset (&local6, 0, sizeof local6);
13609 memset (&remote6, 0, sizeof remote6);
13611 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13613 if (unformat (line_input, "del"))
13615 else if (unformat (line_input, "local %U",
13616 unformat_ip4_address, &local4))
13621 else if (unformat (line_input, "remote %U",
13622 unformat_ip4_address, &remote4))
13627 else if (unformat (line_input, "local %U",
13628 unformat_ip6_address, &local6))
13633 else if (unformat (line_input, "remote %U",
13634 unformat_ip6_address, &remote6))
13639 else if (unformat (line_input, "group %U %U",
13640 unformat_ip4_address, &remote4,
13641 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13643 grp_set = remote_set = 1;
13646 else if (unformat (line_input, "group %U",
13647 unformat_ip4_address, &remote4))
13649 grp_set = remote_set = 1;
13652 else if (unformat (line_input, "group %U %U",
13653 unformat_ip6_address, &remote6,
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_ip6_address, &remote6))
13662 grp_set = remote_set = 1;
13666 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13668 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13670 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13672 else if (unformat (line_input, "vni %d", &vni))
13674 else if (unformat (line_input, "next-ip4"))
13676 else if (unformat (line_input, "next-ip6"))
13678 else if (unformat (line_input, "next-ethernet"))
13680 else if (unformat (line_input, "next-nsh"))
13684 errmsg ("parse error '%U'", format_unformat_error, line_input);
13689 if (local_set == 0)
13691 errmsg ("tunnel local address not specified");
13694 if (remote_set == 0)
13696 errmsg ("tunnel remote address not specified");
13699 if (grp_set && mcast_sw_if_index == ~0)
13701 errmsg ("tunnel nonexistent multicast device");
13704 if (ipv4_set && ipv6_set)
13706 errmsg ("both IPv4 and IPv6 addresses specified");
13712 errmsg ("vni not specified");
13716 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13721 clib_memcpy (&mp->local, &local6, sizeof (local6));
13722 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13726 clib_memcpy (&mp->local, &local4, sizeof (local4));
13727 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13730 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13731 mp->encap_vrf_id = ntohl (encap_vrf_id);
13732 mp->decap_vrf_id = ntohl (decap_vrf_id);
13733 mp->protocol = protocol;
13734 mp->vni = ntohl (vni);
13735 mp->is_add = is_add;
13736 mp->is_ipv6 = ipv6_set;
13743 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13744 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13746 vat_main_t *vam = &vat_main;
13747 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13748 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13750 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13751 ntohl (mp->sw_if_index),
13752 format_ip46_address, &local, IP46_TYPE_ANY,
13753 format_ip46_address, &remote, IP46_TYPE_ANY,
13754 ntohl (mp->vni), mp->protocol,
13755 ntohl (mp->mcast_sw_if_index),
13756 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13760 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13761 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13763 vat_main_t *vam = &vat_main;
13764 vat_json_node_t *node = NULL;
13765 struct in_addr ip4;
13766 struct in6_addr ip6;
13768 if (VAT_JSON_ARRAY != vam->json_tree.type)
13770 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13771 vat_json_init_array (&vam->json_tree);
13773 node = vat_json_array_add (&vam->json_tree);
13775 vat_json_init_object (node);
13776 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13779 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13780 vat_json_object_add_ip6 (node, "local", ip6);
13781 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13782 vat_json_object_add_ip6 (node, "remote", ip6);
13786 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13787 vat_json_object_add_ip4 (node, "local", ip4);
13788 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13789 vat_json_object_add_ip4 (node, "remote", ip4);
13791 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13792 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13793 vat_json_object_add_uint (node, "mcast_sw_if_index",
13794 ntohl (mp->mcast_sw_if_index));
13795 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13796 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13797 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13801 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13803 unformat_input_t *i = vam->input;
13804 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13805 vl_api_control_ping_t *mp_ping;
13807 u8 sw_if_index_set = 0;
13810 /* Parse args required to build the message */
13811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13813 if (unformat (i, "sw_if_index %d", &sw_if_index))
13814 sw_if_index_set = 1;
13819 if (sw_if_index_set == 0)
13824 if (!vam->json_output)
13826 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13827 "sw_if_index", "local", "remote", "vni",
13828 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13831 /* Get list of vxlan-tunnel interfaces */
13832 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13834 mp->sw_if_index = htonl (sw_if_index);
13838 /* Use a control ping for synchronization */
13839 MPING (CONTROL_PING, mp_ping);
13846 static void vl_api_l2_fib_table_details_t_handler
13847 (vl_api_l2_fib_table_details_t * mp)
13849 vat_main_t *vam = &vat_main;
13851 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13853 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13854 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13858 static void vl_api_l2_fib_table_details_t_handler_json
13859 (vl_api_l2_fib_table_details_t * mp)
13861 vat_main_t *vam = &vat_main;
13862 vat_json_node_t *node = NULL;
13864 if (VAT_JSON_ARRAY != vam->json_tree.type)
13866 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13867 vat_json_init_array (&vam->json_tree);
13869 node = vat_json_array_add (&vam->json_tree);
13871 vat_json_init_object (node);
13872 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13873 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13874 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13875 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13876 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13877 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13881 api_l2_fib_table_dump (vat_main_t * vam)
13883 unformat_input_t *i = vam->input;
13884 vl_api_l2_fib_table_dump_t *mp;
13885 vl_api_control_ping_t *mp_ping;
13890 /* Parse args required to build the message */
13891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13893 if (unformat (i, "bd_id %d", &bd_id))
13899 if (bd_id_set == 0)
13901 errmsg ("missing bridge domain");
13905 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13907 /* Get list of l2 fib entries */
13908 M (L2_FIB_TABLE_DUMP, mp);
13910 mp->bd_id = ntohl (bd_id);
13913 /* Use a control ping for synchronization */
13914 MPING (CONTROL_PING, mp_ping);
13923 api_interface_name_renumber (vat_main_t * vam)
13925 unformat_input_t *line_input = vam->input;
13926 vl_api_interface_name_renumber_t *mp;
13927 u32 sw_if_index = ~0;
13928 u32 new_show_dev_instance = ~0;
13931 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13933 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13936 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13938 else if (unformat (line_input, "new_show_dev_instance %d",
13939 &new_show_dev_instance))
13945 if (sw_if_index == ~0)
13947 errmsg ("missing interface name or sw_if_index");
13951 if (new_show_dev_instance == ~0)
13953 errmsg ("missing new_show_dev_instance");
13957 M (INTERFACE_NAME_RENUMBER, mp);
13959 mp->sw_if_index = ntohl (sw_if_index);
13960 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13968 api_want_ip4_arp_events (vat_main_t * vam)
13970 unformat_input_t *line_input = vam->input;
13971 vl_api_want_ip4_arp_events_t *mp;
13972 ip4_address_t address;
13973 int address_set = 0;
13974 u32 enable_disable = 1;
13977 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13979 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13981 else if (unformat (line_input, "del"))
13982 enable_disable = 0;
13987 if (address_set == 0)
13989 errmsg ("missing addresses");
13993 M (WANT_IP4_ARP_EVENTS, mp);
13994 mp->enable_disable = enable_disable;
13995 mp->pid = htonl (getpid ());
13996 mp->address = address.as_u32;
14004 api_want_ip6_nd_events (vat_main_t * vam)
14006 unformat_input_t *line_input = vam->input;
14007 vl_api_want_ip6_nd_events_t *mp;
14008 ip6_address_t address;
14009 int address_set = 0;
14010 u32 enable_disable = 1;
14013 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14015 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
14017 else if (unformat (line_input, "del"))
14018 enable_disable = 0;
14023 if (address_set == 0)
14025 errmsg ("missing addresses");
14029 M (WANT_IP6_ND_EVENTS, mp);
14030 mp->enable_disable = enable_disable;
14031 mp->pid = htonl (getpid ());
14032 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14040 api_want_l2_macs_events (vat_main_t * vam)
14042 unformat_input_t *line_input = vam->input;
14043 vl_api_want_l2_macs_events_t *mp;
14044 u8 enable_disable = 1;
14045 u32 scan_delay = 0;
14046 u32 max_macs_in_event = 0;
14047 u32 learn_limit = 0;
14050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14052 if (unformat (line_input, "learn-limit %d", &learn_limit))
14054 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14056 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14058 else if (unformat (line_input, "disable"))
14059 enable_disable = 0;
14064 M (WANT_L2_MACS_EVENTS, mp);
14065 mp->enable_disable = enable_disable;
14066 mp->pid = htonl (getpid ());
14067 mp->learn_limit = htonl (learn_limit);
14068 mp->scan_delay = (u8) scan_delay;
14069 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14076 api_input_acl_set_interface (vat_main_t * vam)
14078 unformat_input_t *i = vam->input;
14079 vl_api_input_acl_set_interface_t *mp;
14081 int sw_if_index_set;
14082 u32 ip4_table_index = ~0;
14083 u32 ip6_table_index = ~0;
14084 u32 l2_table_index = ~0;
14088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14090 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14091 sw_if_index_set = 1;
14092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14093 sw_if_index_set = 1;
14094 else if (unformat (i, "del"))
14096 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14098 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14100 else if (unformat (i, "l2-table %d", &l2_table_index))
14104 clib_warning ("parse error '%U'", format_unformat_error, i);
14109 if (sw_if_index_set == 0)
14111 errmsg ("missing interface name or sw_if_index");
14115 M (INPUT_ACL_SET_INTERFACE, mp);
14117 mp->sw_if_index = ntohl (sw_if_index);
14118 mp->ip4_table_index = ntohl (ip4_table_index);
14119 mp->ip6_table_index = ntohl (ip6_table_index);
14120 mp->l2_table_index = ntohl (l2_table_index);
14121 mp->is_add = is_add;
14129 api_ip_address_dump (vat_main_t * vam)
14131 unformat_input_t *i = vam->input;
14132 vl_api_ip_address_dump_t *mp;
14133 vl_api_control_ping_t *mp_ping;
14134 u32 sw_if_index = ~0;
14135 u8 sw_if_index_set = 0;
14140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14142 if (unformat (i, "sw_if_index %d", &sw_if_index))
14143 sw_if_index_set = 1;
14145 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14146 sw_if_index_set = 1;
14147 else if (unformat (i, "ipv4"))
14149 else if (unformat (i, "ipv6"))
14155 if (ipv4_set && ipv6_set)
14157 errmsg ("ipv4 and ipv6 flags cannot be both set");
14161 if ((!ipv4_set) && (!ipv6_set))
14163 errmsg ("no ipv4 nor ipv6 flag set");
14167 if (sw_if_index_set == 0)
14169 errmsg ("missing interface name or sw_if_index");
14173 vam->current_sw_if_index = sw_if_index;
14174 vam->is_ipv6 = ipv6_set;
14176 M (IP_ADDRESS_DUMP, mp);
14177 mp->sw_if_index = ntohl (sw_if_index);
14178 mp->is_ipv6 = ipv6_set;
14181 /* Use a control ping for synchronization */
14182 MPING (CONTROL_PING, mp_ping);
14190 api_ip_dump (vat_main_t * vam)
14192 vl_api_ip_dump_t *mp;
14193 vl_api_control_ping_t *mp_ping;
14194 unformat_input_t *in = vam->input;
14201 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14203 if (unformat (in, "ipv4"))
14205 else if (unformat (in, "ipv6"))
14211 if (ipv4_set && ipv6_set)
14213 errmsg ("ipv4 and ipv6 flags cannot be both set");
14217 if ((!ipv4_set) && (!ipv6_set))
14219 errmsg ("no ipv4 nor ipv6 flag set");
14223 is_ipv6 = ipv6_set;
14224 vam->is_ipv6 = is_ipv6;
14226 /* free old data */
14227 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14229 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14231 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14234 mp->is_ipv6 = ipv6_set;
14237 /* Use a control ping for synchronization */
14238 MPING (CONTROL_PING, mp_ping);
14246 api_ipsec_spd_add_del (vat_main_t * vam)
14248 unformat_input_t *i = vam->input;
14249 vl_api_ipsec_spd_add_del_t *mp;
14254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14256 if (unformat (i, "spd_id %d", &spd_id))
14258 else if (unformat (i, "del"))
14262 clib_warning ("parse error '%U'", format_unformat_error, i);
14268 errmsg ("spd_id must be set");
14272 M (IPSEC_SPD_ADD_DEL, mp);
14274 mp->spd_id = ntohl (spd_id);
14275 mp->is_add = is_add;
14283 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14285 unformat_input_t *i = vam->input;
14286 vl_api_ipsec_interface_add_del_spd_t *mp;
14288 u8 sw_if_index_set = 0;
14289 u32 spd_id = (u32) ~ 0;
14293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14295 if (unformat (i, "del"))
14297 else if (unformat (i, "spd_id %d", &spd_id))
14300 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14301 sw_if_index_set = 1;
14302 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14303 sw_if_index_set = 1;
14306 clib_warning ("parse error '%U'", format_unformat_error, i);
14312 if (spd_id == (u32) ~ 0)
14314 errmsg ("spd_id must be set");
14318 if (sw_if_index_set == 0)
14320 errmsg ("missing interface name or sw_if_index");
14324 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14326 mp->spd_id = ntohl (spd_id);
14327 mp->sw_if_index = ntohl (sw_if_index);
14328 mp->is_add = is_add;
14336 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14338 unformat_input_t *i = vam->input;
14339 vl_api_ipsec_spd_add_del_entry_t *mp;
14340 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14341 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14343 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14344 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14345 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14346 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14349 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14350 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14351 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14352 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14353 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14354 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14358 if (unformat (i, "del"))
14360 if (unformat (i, "outbound"))
14362 if (unformat (i, "inbound"))
14364 else if (unformat (i, "spd_id %d", &spd_id))
14366 else if (unformat (i, "sa_id %d", &sa_id))
14368 else if (unformat (i, "priority %d", &priority))
14370 else if (unformat (i, "protocol %d", &protocol))
14372 else if (unformat (i, "lport_start %d", &lport_start))
14374 else if (unformat (i, "lport_stop %d", &lport_stop))
14376 else if (unformat (i, "rport_start %d", &rport_start))
14378 else if (unformat (i, "rport_stop %d", &rport_stop))
14382 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14388 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14395 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14401 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14408 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14414 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14421 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14427 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14433 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14435 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14437 clib_warning ("unsupported action: 'resolve'");
14443 clib_warning ("parse error '%U'", format_unformat_error, i);
14449 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14451 mp->spd_id = ntohl (spd_id);
14452 mp->priority = ntohl (priority);
14453 mp->is_outbound = is_outbound;
14455 mp->is_ipv6 = is_ipv6;
14456 if (is_ipv6 || is_ip_any)
14458 clib_memcpy (mp->remote_address_start, &raddr6_start,
14459 sizeof (ip6_address_t));
14460 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14461 sizeof (ip6_address_t));
14462 clib_memcpy (mp->local_address_start, &laddr6_start,
14463 sizeof (ip6_address_t));
14464 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14465 sizeof (ip6_address_t));
14469 clib_memcpy (mp->remote_address_start, &raddr4_start,
14470 sizeof (ip4_address_t));
14471 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14472 sizeof (ip4_address_t));
14473 clib_memcpy (mp->local_address_start, &laddr4_start,
14474 sizeof (ip4_address_t));
14475 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14476 sizeof (ip4_address_t));
14478 mp->protocol = (u8) protocol;
14479 mp->local_port_start = ntohs ((u16) lport_start);
14480 mp->local_port_stop = ntohs ((u16) lport_stop);
14481 mp->remote_port_start = ntohs ((u16) rport_start);
14482 mp->remote_port_stop = ntohs ((u16) rport_stop);
14483 mp->policy = (u8) policy;
14484 mp->sa_id = ntohl (sa_id);
14485 mp->is_add = is_add;
14486 mp->is_ip_any = is_ip_any;
14493 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14495 unformat_input_t *i = vam->input;
14496 vl_api_ipsec_sad_add_del_entry_t *mp;
14497 u32 sad_id = 0, spi = 0;
14498 u8 *ck = 0, *ik = 0;
14501 u8 protocol = IPSEC_PROTOCOL_AH;
14502 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14503 u32 crypto_alg = 0, integ_alg = 0;
14504 ip4_address_t tun_src4;
14505 ip4_address_t tun_dst4;
14506 ip6_address_t tun_src6;
14507 ip6_address_t tun_dst6;
14510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14512 if (unformat (i, "del"))
14514 else if (unformat (i, "sad_id %d", &sad_id))
14516 else if (unformat (i, "spi %d", &spi))
14518 else if (unformat (i, "esp"))
14519 protocol = IPSEC_PROTOCOL_ESP;
14520 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14523 is_tunnel_ipv6 = 0;
14525 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14528 is_tunnel_ipv6 = 0;
14530 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14533 is_tunnel_ipv6 = 1;
14535 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14538 is_tunnel_ipv6 = 1;
14542 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14544 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14545 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14547 clib_warning ("unsupported crypto-alg: '%U'",
14548 format_ipsec_crypto_alg, crypto_alg);
14552 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14556 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14558 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14559 integ_alg >= IPSEC_INTEG_N_ALG)
14561 clib_warning ("unsupported integ-alg: '%U'",
14562 format_ipsec_integ_alg, integ_alg);
14566 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14570 clib_warning ("parse error '%U'", format_unformat_error, i);
14576 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14578 mp->sad_id = ntohl (sad_id);
14579 mp->is_add = is_add;
14580 mp->protocol = protocol;
14581 mp->spi = ntohl (spi);
14582 mp->is_tunnel = is_tunnel;
14583 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14584 mp->crypto_algorithm = crypto_alg;
14585 mp->integrity_algorithm = integ_alg;
14586 mp->crypto_key_length = vec_len (ck);
14587 mp->integrity_key_length = vec_len (ik);
14589 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14590 mp->crypto_key_length = sizeof (mp->crypto_key);
14592 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14593 mp->integrity_key_length = sizeof (mp->integrity_key);
14596 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14598 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14602 if (is_tunnel_ipv6)
14604 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14605 sizeof (ip6_address_t));
14606 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14607 sizeof (ip6_address_t));
14611 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14612 sizeof (ip4_address_t));
14613 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14614 sizeof (ip4_address_t));
14624 api_ipsec_sa_set_key (vat_main_t * vam)
14626 unformat_input_t *i = vam->input;
14627 vl_api_ipsec_sa_set_key_t *mp;
14629 u8 *ck = 0, *ik = 0;
14632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14634 if (unformat (i, "sa_id %d", &sa_id))
14636 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14638 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14642 clib_warning ("parse error '%U'", format_unformat_error, i);
14647 M (IPSEC_SA_SET_KEY, mp);
14649 mp->sa_id = ntohl (sa_id);
14650 mp->crypto_key_length = vec_len (ck);
14651 mp->integrity_key_length = vec_len (ik);
14653 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14654 mp->crypto_key_length = sizeof (mp->crypto_key);
14656 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14657 mp->integrity_key_length = sizeof (mp->integrity_key);
14660 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14662 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14670 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14672 unformat_input_t *i = vam->input;
14673 vl_api_ipsec_tunnel_if_add_del_t *mp;
14674 u32 local_spi = 0, remote_spi = 0;
14675 u32 crypto_alg = 0, integ_alg = 0;
14676 u8 *lck = NULL, *rck = NULL;
14677 u8 *lik = NULL, *rik = NULL;
14678 ip4_address_t local_ip = { {0} };
14679 ip4_address_t remote_ip = { {0} };
14682 u8 anti_replay = 0;
14685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14687 if (unformat (i, "del"))
14689 else if (unformat (i, "esn"))
14691 else if (unformat (i, "anti_replay"))
14693 else if (unformat (i, "local_spi %d", &local_spi))
14695 else if (unformat (i, "remote_spi %d", &remote_spi))
14697 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14699 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14701 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14704 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14706 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14708 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14712 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14714 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14715 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14717 errmsg ("unsupported crypto-alg: '%U'\n",
14718 format_ipsec_crypto_alg, crypto_alg);
14724 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14726 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14727 integ_alg >= IPSEC_INTEG_N_ALG)
14729 errmsg ("unsupported integ-alg: '%U'\n",
14730 format_ipsec_integ_alg, integ_alg);
14736 errmsg ("parse error '%U'\n", format_unformat_error, i);
14741 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14743 mp->is_add = is_add;
14745 mp->anti_replay = anti_replay;
14747 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14748 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14750 mp->local_spi = htonl (local_spi);
14751 mp->remote_spi = htonl (remote_spi);
14752 mp->crypto_alg = (u8) crypto_alg;
14754 mp->local_crypto_key_len = 0;
14757 mp->local_crypto_key_len = vec_len (lck);
14758 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14759 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14760 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14763 mp->remote_crypto_key_len = 0;
14766 mp->remote_crypto_key_len = vec_len (rck);
14767 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14768 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14769 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14772 mp->integ_alg = (u8) integ_alg;
14774 mp->local_integ_key_len = 0;
14777 mp->local_integ_key_len = vec_len (lik);
14778 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14779 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14780 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14783 mp->remote_integ_key_len = 0;
14786 mp->remote_integ_key_len = vec_len (rik);
14787 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14788 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14789 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14798 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14800 vat_main_t *vam = &vat_main;
14802 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14803 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14804 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14805 "tunnel_src_addr %U tunnel_dst_addr %U "
14806 "salt %u seq_outbound %lu last_seq_inbound %lu "
14807 "replay_window %lu total_data_size %lu\n",
14808 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14810 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14811 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14812 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14813 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14814 mp->tunnel_src_addr,
14815 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14816 mp->tunnel_dst_addr,
14818 clib_net_to_host_u64 (mp->seq_outbound),
14819 clib_net_to_host_u64 (mp->last_seq_inbound),
14820 clib_net_to_host_u64 (mp->replay_window),
14821 clib_net_to_host_u64 (mp->total_data_size));
14824 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14825 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14827 static void vl_api_ipsec_sa_details_t_handler_json
14828 (vl_api_ipsec_sa_details_t * mp)
14830 vat_main_t *vam = &vat_main;
14831 vat_json_node_t *node = NULL;
14832 struct in_addr src_ip4, dst_ip4;
14833 struct in6_addr src_ip6, dst_ip6;
14835 if (VAT_JSON_ARRAY != vam->json_tree.type)
14837 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14838 vat_json_init_array (&vam->json_tree);
14840 node = vat_json_array_add (&vam->json_tree);
14842 vat_json_init_object (node);
14843 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14844 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14845 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14846 vat_json_object_add_uint (node, "proto", mp->protocol);
14847 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14848 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14849 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14850 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14851 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14852 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14853 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14854 mp->crypto_key_len);
14855 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14856 mp->integ_key_len);
14857 if (mp->is_tunnel_ip6)
14859 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14860 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14861 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14862 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14866 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14867 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14868 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14869 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14871 vat_json_object_add_uint (node, "replay_window",
14872 clib_net_to_host_u64 (mp->replay_window));
14873 vat_json_object_add_uint (node, "total_data_size",
14874 clib_net_to_host_u64 (mp->total_data_size));
14879 api_ipsec_sa_dump (vat_main_t * vam)
14881 unformat_input_t *i = vam->input;
14882 vl_api_ipsec_sa_dump_t *mp;
14883 vl_api_control_ping_t *mp_ping;
14887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14889 if (unformat (i, "sa_id %d", &sa_id))
14893 clib_warning ("parse error '%U'", format_unformat_error, i);
14898 M (IPSEC_SA_DUMP, mp);
14900 mp->sa_id = ntohl (sa_id);
14904 /* Use a control ping for synchronization */
14905 M (CONTROL_PING, mp_ping);
14913 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14915 unformat_input_t *i = vam->input;
14916 vl_api_ipsec_tunnel_if_set_key_t *mp;
14917 u32 sw_if_index = ~0;
14918 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14925 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14928 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14929 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14931 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14932 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14933 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14934 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14936 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14937 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14938 else if (unformat (i, "%U", unformat_hex_string, &key))
14942 clib_warning ("parse error '%U'", format_unformat_error, i);
14947 if (sw_if_index == ~0)
14949 errmsg ("interface must be specified");
14953 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14955 errmsg ("key type must be specified");
14961 errmsg ("algorithm must be specified");
14965 if (vec_len (key) == 0)
14967 errmsg ("key must be specified");
14971 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14973 mp->sw_if_index = htonl (sw_if_index);
14975 mp->key_type = key_type;
14976 mp->key_len = vec_len (key);
14977 clib_memcpy (mp->key, key, vec_len (key));
14986 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14988 unformat_input_t *i = vam->input;
14989 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14990 u32 sw_if_index = ~0;
14992 u8 is_outbound = (u8) ~ 0;
14995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14997 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14999 else if (unformat (i, "sa_id %d", &sa_id))
15001 else if (unformat (i, "outbound"))
15003 else if (unformat (i, "inbound"))
15007 clib_warning ("parse error '%U'", format_unformat_error, i);
15012 if (sw_if_index == ~0)
15014 errmsg ("interface must be specified");
15020 errmsg ("SA ID must be specified");
15024 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15026 mp->sw_if_index = htonl (sw_if_index);
15027 mp->sa_id = htonl (sa_id);
15028 mp->is_outbound = is_outbound;
15037 api_ikev2_profile_add_del (vat_main_t * vam)
15039 unformat_input_t *i = vam->input;
15040 vl_api_ikev2_profile_add_del_t *mp;
15045 const char *valid_chars = "a-zA-Z0-9_";
15047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15049 if (unformat (i, "del"))
15051 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15052 vec_add1 (name, 0);
15055 errmsg ("parse error '%U'", format_unformat_error, i);
15060 if (!vec_len (name))
15062 errmsg ("profile name must be specified");
15066 if (vec_len (name) > 64)
15068 errmsg ("profile name too long");
15072 M (IKEV2_PROFILE_ADD_DEL, mp);
15074 clib_memcpy (mp->name, name, vec_len (name));
15075 mp->is_add = is_add;
15084 api_ikev2_profile_set_auth (vat_main_t * vam)
15086 unformat_input_t *i = vam->input;
15087 vl_api_ikev2_profile_set_auth_t *mp;
15090 u32 auth_method = 0;
15094 const char *valid_chars = "a-zA-Z0-9_";
15096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15098 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15099 vec_add1 (name, 0);
15100 else if (unformat (i, "auth_method %U",
15101 unformat_ikev2_auth_method, &auth_method))
15103 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15105 else if (unformat (i, "auth_data %v", &data))
15109 errmsg ("parse error '%U'", format_unformat_error, i);
15114 if (!vec_len (name))
15116 errmsg ("profile name must be specified");
15120 if (vec_len (name) > 64)
15122 errmsg ("profile name too long");
15126 if (!vec_len (data))
15128 errmsg ("auth_data must be specified");
15134 errmsg ("auth_method must be specified");
15138 M (IKEV2_PROFILE_SET_AUTH, mp);
15140 mp->is_hex = is_hex;
15141 mp->auth_method = (u8) auth_method;
15142 mp->data_len = vec_len (data);
15143 clib_memcpy (mp->name, name, vec_len (name));
15144 clib_memcpy (mp->data, data, vec_len (data));
15154 api_ikev2_profile_set_id (vat_main_t * vam)
15156 unformat_input_t *i = vam->input;
15157 vl_api_ikev2_profile_set_id_t *mp;
15165 const char *valid_chars = "a-zA-Z0-9_";
15167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15169 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15170 vec_add1 (name, 0);
15171 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15173 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15175 data = vec_new (u8, 4);
15176 clib_memcpy (data, ip4.as_u8, 4);
15178 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15180 else if (unformat (i, "id_data %v", &data))
15182 else if (unformat (i, "local"))
15184 else if (unformat (i, "remote"))
15188 errmsg ("parse error '%U'", format_unformat_error, i);
15193 if (!vec_len (name))
15195 errmsg ("profile name must be specified");
15199 if (vec_len (name) > 64)
15201 errmsg ("profile name too long");
15205 if (!vec_len (data))
15207 errmsg ("id_data must be specified");
15213 errmsg ("id_type must be specified");
15217 M (IKEV2_PROFILE_SET_ID, mp);
15219 mp->is_local = is_local;
15220 mp->id_type = (u8) id_type;
15221 mp->data_len = vec_len (data);
15222 clib_memcpy (mp->name, name, vec_len (name));
15223 clib_memcpy (mp->data, data, vec_len (data));
15233 api_ikev2_profile_set_ts (vat_main_t * vam)
15235 unformat_input_t *i = vam->input;
15236 vl_api_ikev2_profile_set_ts_t *mp;
15239 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15240 ip4_address_t start_addr, end_addr;
15242 const char *valid_chars = "a-zA-Z0-9_";
15245 start_addr.as_u32 = 0;
15246 end_addr.as_u32 = (u32) ~ 0;
15248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15250 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15251 vec_add1 (name, 0);
15252 else if (unformat (i, "protocol %d", &proto))
15254 else if (unformat (i, "start_port %d", &start_port))
15256 else if (unformat (i, "end_port %d", &end_port))
15259 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15261 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15263 else if (unformat (i, "local"))
15265 else if (unformat (i, "remote"))
15269 errmsg ("parse error '%U'", format_unformat_error, i);
15274 if (!vec_len (name))
15276 errmsg ("profile name must be specified");
15280 if (vec_len (name) > 64)
15282 errmsg ("profile name too long");
15286 M (IKEV2_PROFILE_SET_TS, mp);
15288 mp->is_local = is_local;
15289 mp->proto = (u8) proto;
15290 mp->start_port = (u16) start_port;
15291 mp->end_port = (u16) end_port;
15292 mp->start_addr = start_addr.as_u32;
15293 mp->end_addr = end_addr.as_u32;
15294 clib_memcpy (mp->name, name, vec_len (name));
15303 api_ikev2_set_local_key (vat_main_t * vam)
15305 unformat_input_t *i = vam->input;
15306 vl_api_ikev2_set_local_key_t *mp;
15310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15312 if (unformat (i, "file %v", &file))
15313 vec_add1 (file, 0);
15316 errmsg ("parse error '%U'", format_unformat_error, i);
15321 if (!vec_len (file))
15323 errmsg ("RSA key file must be specified");
15327 if (vec_len (file) > 256)
15329 errmsg ("file name too long");
15333 M (IKEV2_SET_LOCAL_KEY, mp);
15335 clib_memcpy (mp->key_file, file, vec_len (file));
15344 api_ikev2_set_responder (vat_main_t * vam)
15346 unformat_input_t *i = vam->input;
15347 vl_api_ikev2_set_responder_t *mp;
15350 u32 sw_if_index = ~0;
15351 ip4_address_t address;
15353 const char *valid_chars = "a-zA-Z0-9_";
15355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15358 (i, "%U interface %d address %U", unformat_token, valid_chars,
15359 &name, &sw_if_index, unformat_ip4_address, &address))
15360 vec_add1 (name, 0);
15363 errmsg ("parse error '%U'", format_unformat_error, i);
15368 if (!vec_len (name))
15370 errmsg ("profile name must be specified");
15374 if (vec_len (name) > 64)
15376 errmsg ("profile name too long");
15380 M (IKEV2_SET_RESPONDER, mp);
15382 clib_memcpy (mp->name, name, vec_len (name));
15385 mp->sw_if_index = sw_if_index;
15386 clib_memcpy (mp->address, &address, sizeof (address));
15394 api_ikev2_set_ike_transforms (vat_main_t * vam)
15396 unformat_input_t *i = vam->input;
15397 vl_api_ikev2_set_ike_transforms_t *mp;
15400 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15402 const char *valid_chars = "a-zA-Z0-9_";
15404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15406 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15407 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15408 vec_add1 (name, 0);
15411 errmsg ("parse error '%U'", format_unformat_error, i);
15416 if (!vec_len (name))
15418 errmsg ("profile name must be specified");
15422 if (vec_len (name) > 64)
15424 errmsg ("profile name too long");
15428 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15430 clib_memcpy (mp->name, name, vec_len (name));
15432 mp->crypto_alg = crypto_alg;
15433 mp->crypto_key_size = crypto_key_size;
15434 mp->integ_alg = integ_alg;
15435 mp->dh_group = dh_group;
15444 api_ikev2_set_esp_transforms (vat_main_t * vam)
15446 unformat_input_t *i = vam->input;
15447 vl_api_ikev2_set_esp_transforms_t *mp;
15450 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15452 const char *valid_chars = "a-zA-Z0-9_";
15454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15456 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15457 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15458 vec_add1 (name, 0);
15461 errmsg ("parse error '%U'", format_unformat_error, i);
15466 if (!vec_len (name))
15468 errmsg ("profile name must be specified");
15472 if (vec_len (name) > 64)
15474 errmsg ("profile name too long");
15478 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15480 clib_memcpy (mp->name, name, vec_len (name));
15482 mp->crypto_alg = crypto_alg;
15483 mp->crypto_key_size = crypto_key_size;
15484 mp->integ_alg = integ_alg;
15485 mp->dh_group = dh_group;
15493 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15495 unformat_input_t *i = vam->input;
15496 vl_api_ikev2_set_sa_lifetime_t *mp;
15499 u64 lifetime, lifetime_maxdata;
15500 u32 lifetime_jitter, handover;
15502 const char *valid_chars = "a-zA-Z0-9_";
15504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15506 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15507 &lifetime, &lifetime_jitter, &handover,
15508 &lifetime_maxdata))
15509 vec_add1 (name, 0);
15512 errmsg ("parse error '%U'", format_unformat_error, i);
15517 if (!vec_len (name))
15519 errmsg ("profile name must be specified");
15523 if (vec_len (name) > 64)
15525 errmsg ("profile name too long");
15529 M (IKEV2_SET_SA_LIFETIME, mp);
15531 clib_memcpy (mp->name, name, vec_len (name));
15533 mp->lifetime = lifetime;
15534 mp->lifetime_jitter = lifetime_jitter;
15535 mp->handover = handover;
15536 mp->lifetime_maxdata = lifetime_maxdata;
15544 api_ikev2_initiate_sa_init (vat_main_t * vam)
15546 unformat_input_t *i = vam->input;
15547 vl_api_ikev2_initiate_sa_init_t *mp;
15551 const char *valid_chars = "a-zA-Z0-9_";
15553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15555 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15556 vec_add1 (name, 0);
15559 errmsg ("parse error '%U'", format_unformat_error, i);
15564 if (!vec_len (name))
15566 errmsg ("profile name must be specified");
15570 if (vec_len (name) > 64)
15572 errmsg ("profile name too long");
15576 M (IKEV2_INITIATE_SA_INIT, mp);
15578 clib_memcpy (mp->name, name, vec_len (name));
15587 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15589 unformat_input_t *i = vam->input;
15590 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15597 if (unformat (i, "%lx", &ispi))
15601 errmsg ("parse error '%U'", format_unformat_error, i);
15606 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15616 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15618 unformat_input_t *i = vam->input;
15619 vl_api_ikev2_initiate_del_child_sa_t *mp;
15624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15626 if (unformat (i, "%x", &ispi))
15630 errmsg ("parse error '%U'", format_unformat_error, i);
15635 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15645 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15647 unformat_input_t *i = vam->input;
15648 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15655 if (unformat (i, "%x", &ispi))
15659 errmsg ("parse error '%U'", format_unformat_error, i);
15664 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15677 api_map_add_domain (vat_main_t * vam)
15679 unformat_input_t *i = vam->input;
15680 vl_api_map_add_domain_t *mp;
15682 ip4_address_t ip4_prefix;
15683 ip6_address_t ip6_prefix;
15684 ip6_address_t ip6_src;
15685 u32 num_m_args = 0;
15686 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15687 0, psid_length = 0;
15688 u8 is_translation = 0;
15690 u32 ip6_src_len = 128;
15693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15695 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15696 &ip4_prefix, &ip4_prefix_len))
15698 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15699 &ip6_prefix, &ip6_prefix_len))
15703 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15706 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15708 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15710 else if (unformat (i, "psid-offset %d", &psid_offset))
15712 else if (unformat (i, "psid-len %d", &psid_length))
15714 else if (unformat (i, "mtu %d", &mtu))
15716 else if (unformat (i, "map-t"))
15717 is_translation = 1;
15720 clib_warning ("parse error '%U'", format_unformat_error, i);
15725 if (num_m_args < 3)
15727 errmsg ("mandatory argument(s) missing");
15731 /* Construct the API message */
15732 M (MAP_ADD_DOMAIN, mp);
15734 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15735 mp->ip4_prefix_len = ip4_prefix_len;
15737 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15738 mp->ip6_prefix_len = ip6_prefix_len;
15740 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15741 mp->ip6_src_prefix_len = ip6_src_len;
15743 mp->ea_bits_len = ea_bits_len;
15744 mp->psid_offset = psid_offset;
15745 mp->psid_length = psid_length;
15746 mp->is_translation = is_translation;
15747 mp->mtu = htons (mtu);
15752 /* Wait for a reply, return good/bad news */
15758 api_map_del_domain (vat_main_t * vam)
15760 unformat_input_t *i = vam->input;
15761 vl_api_map_del_domain_t *mp;
15763 u32 num_m_args = 0;
15767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15769 if (unformat (i, "index %d", &index))
15773 clib_warning ("parse error '%U'", format_unformat_error, i);
15778 if (num_m_args != 1)
15780 errmsg ("mandatory argument(s) missing");
15784 /* Construct the API message */
15785 M (MAP_DEL_DOMAIN, mp);
15787 mp->index = ntohl (index);
15792 /* Wait for a reply, return good/bad news */
15798 api_map_add_del_rule (vat_main_t * vam)
15800 unformat_input_t *i = vam->input;
15801 vl_api_map_add_del_rule_t *mp;
15803 ip6_address_t ip6_dst;
15804 u32 num_m_args = 0, index, psid = 0;
15807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15809 if (unformat (i, "index %d", &index))
15811 else if (unformat (i, "psid %d", &psid))
15813 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15815 else if (unformat (i, "del"))
15821 clib_warning ("parse error '%U'", format_unformat_error, i);
15826 /* Construct the API message */
15827 M (MAP_ADD_DEL_RULE, mp);
15829 mp->index = ntohl (index);
15830 mp->is_add = is_add;
15831 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15832 mp->psid = ntohs (psid);
15837 /* Wait for a reply, return good/bad news */
15843 api_map_domain_dump (vat_main_t * vam)
15845 vl_api_map_domain_dump_t *mp;
15846 vl_api_control_ping_t *mp_ping;
15849 /* Construct the API message */
15850 M (MAP_DOMAIN_DUMP, mp);
15855 /* Use a control ping for synchronization */
15856 MPING (CONTROL_PING, mp_ping);
15864 api_map_rule_dump (vat_main_t * vam)
15866 unformat_input_t *i = vam->input;
15867 vl_api_map_rule_dump_t *mp;
15868 vl_api_control_ping_t *mp_ping;
15869 u32 domain_index = ~0;
15872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15874 if (unformat (i, "index %u", &domain_index))
15880 if (domain_index == ~0)
15882 clib_warning ("parse error: domain index expected");
15886 /* Construct the API message */
15887 M (MAP_RULE_DUMP, mp);
15889 mp->domain_index = htonl (domain_index);
15894 /* Use a control ping for synchronization */
15895 MPING (CONTROL_PING, mp_ping);
15902 static void vl_api_map_add_domain_reply_t_handler
15903 (vl_api_map_add_domain_reply_t * mp)
15905 vat_main_t *vam = &vat_main;
15906 i32 retval = ntohl (mp->retval);
15908 if (vam->async_mode)
15910 vam->async_errors += (retval < 0);
15914 vam->retval = retval;
15915 vam->result_ready = 1;
15919 static void vl_api_map_add_domain_reply_t_handler_json
15920 (vl_api_map_add_domain_reply_t * mp)
15922 vat_main_t *vam = &vat_main;
15923 vat_json_node_t node;
15925 vat_json_init_object (&node);
15926 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15927 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15929 vat_json_print (vam->ofp, &node);
15930 vat_json_free (&node);
15932 vam->retval = ntohl (mp->retval);
15933 vam->result_ready = 1;
15937 api_get_first_msg_id (vat_main_t * vam)
15939 vl_api_get_first_msg_id_t *mp;
15940 unformat_input_t *i = vam->input;
15945 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15947 if (unformat (i, "client %s", &name))
15955 errmsg ("missing client name");
15958 vec_add1 (name, 0);
15960 if (vec_len (name) > 63)
15962 errmsg ("client name too long");
15966 M (GET_FIRST_MSG_ID, mp);
15967 clib_memcpy (mp->name, name, vec_len (name));
15974 api_cop_interface_enable_disable (vat_main_t * vam)
15976 unformat_input_t *line_input = vam->input;
15977 vl_api_cop_interface_enable_disable_t *mp;
15978 u32 sw_if_index = ~0;
15979 u8 enable_disable = 1;
15982 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15984 if (unformat (line_input, "disable"))
15985 enable_disable = 0;
15986 if (unformat (line_input, "enable"))
15987 enable_disable = 1;
15988 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15989 vam, &sw_if_index))
15991 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15997 if (sw_if_index == ~0)
15999 errmsg ("missing interface name or sw_if_index");
16003 /* Construct the API message */
16004 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16005 mp->sw_if_index = ntohl (sw_if_index);
16006 mp->enable_disable = enable_disable;
16010 /* Wait for the reply */
16016 api_cop_whitelist_enable_disable (vat_main_t * vam)
16018 unformat_input_t *line_input = vam->input;
16019 vl_api_cop_whitelist_enable_disable_t *mp;
16020 u32 sw_if_index = ~0;
16021 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16025 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16027 if (unformat (line_input, "ip4"))
16029 else if (unformat (line_input, "ip6"))
16031 else if (unformat (line_input, "default"))
16033 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16034 vam, &sw_if_index))
16036 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16038 else if (unformat (line_input, "fib-id %d", &fib_id))
16044 if (sw_if_index == ~0)
16046 errmsg ("missing interface name or sw_if_index");
16050 /* Construct the API message */
16051 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16052 mp->sw_if_index = ntohl (sw_if_index);
16053 mp->fib_id = ntohl (fib_id);
16056 mp->default_cop = default_cop;
16060 /* Wait for the reply */
16066 api_get_node_graph (vat_main_t * vam)
16068 vl_api_get_node_graph_t *mp;
16071 M (GET_NODE_GRAPH, mp);
16075 /* Wait for the reply */
16081 /** Used for parsing LISP eids */
16082 typedef CLIB_PACKED(struct{
16083 u8 addr[16]; /**< eid address */
16084 u32 len; /**< prefix length if IP */
16085 u8 type; /**< type of eid */
16090 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16092 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16094 memset (a, 0, sizeof (a[0]));
16096 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16098 a->type = 0; /* ipv4 type */
16100 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16102 a->type = 1; /* ipv6 type */
16104 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16106 a->type = 2; /* mac type */
16108 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16110 a->type = 3; /* NSH type */
16111 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16112 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16119 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16128 lisp_eid_size_vat (u8 type)
16145 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16147 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16151 api_one_add_del_locator_set (vat_main_t * vam)
16153 unformat_input_t *input = vam->input;
16154 vl_api_one_add_del_locator_set_t *mp;
16156 u8 *locator_set_name = NULL;
16157 u8 locator_set_name_set = 0;
16158 vl_api_local_locator_t locator, *locators = 0;
16159 u32 sw_if_index, priority, weight;
16163 /* Parse args required to build the message */
16164 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16166 if (unformat (input, "del"))
16170 else if (unformat (input, "locator-set %s", &locator_set_name))
16172 locator_set_name_set = 1;
16174 else if (unformat (input, "sw_if_index %u p %u w %u",
16175 &sw_if_index, &priority, &weight))
16177 locator.sw_if_index = htonl (sw_if_index);
16178 locator.priority = priority;
16179 locator.weight = weight;
16180 vec_add1 (locators, locator);
16184 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16185 &sw_if_index, &priority, &weight))
16187 locator.sw_if_index = htonl (sw_if_index);
16188 locator.priority = priority;
16189 locator.weight = weight;
16190 vec_add1 (locators, locator);
16196 if (locator_set_name_set == 0)
16198 errmsg ("missing locator-set name");
16199 vec_free (locators);
16203 if (vec_len (locator_set_name) > 64)
16205 errmsg ("locator-set name too long");
16206 vec_free (locator_set_name);
16207 vec_free (locators);
16210 vec_add1 (locator_set_name, 0);
16212 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16214 /* Construct the API message */
16215 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16217 mp->is_add = is_add;
16218 clib_memcpy (mp->locator_set_name, locator_set_name,
16219 vec_len (locator_set_name));
16220 vec_free (locator_set_name);
16222 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16224 clib_memcpy (mp->locators, locators, data_len);
16225 vec_free (locators);
16230 /* Wait for a reply... */
16235 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16238 api_one_add_del_locator (vat_main_t * vam)
16240 unformat_input_t *input = vam->input;
16241 vl_api_one_add_del_locator_t *mp;
16242 u32 tmp_if_index = ~0;
16243 u32 sw_if_index = ~0;
16244 u8 sw_if_index_set = 0;
16245 u8 sw_if_index_if_name_set = 0;
16247 u8 priority_set = 0;
16251 u8 *locator_set_name = NULL;
16252 u8 locator_set_name_set = 0;
16255 /* Parse args required to build the message */
16256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16258 if (unformat (input, "del"))
16262 else if (unformat (input, "locator-set %s", &locator_set_name))
16264 locator_set_name_set = 1;
16266 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16269 sw_if_index_if_name_set = 1;
16270 sw_if_index = tmp_if_index;
16272 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16274 sw_if_index_set = 1;
16275 sw_if_index = tmp_if_index;
16277 else if (unformat (input, "p %d", &priority))
16281 else if (unformat (input, "w %d", &weight))
16289 if (locator_set_name_set == 0)
16291 errmsg ("missing locator-set name");
16295 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16297 errmsg ("missing sw_if_index");
16298 vec_free (locator_set_name);
16302 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16304 errmsg ("cannot use both params interface name and sw_if_index");
16305 vec_free (locator_set_name);
16309 if (priority_set == 0)
16311 errmsg ("missing locator-set priority");
16312 vec_free (locator_set_name);
16316 if (weight_set == 0)
16318 errmsg ("missing locator-set weight");
16319 vec_free (locator_set_name);
16323 if (vec_len (locator_set_name) > 64)
16325 errmsg ("locator-set name too long");
16326 vec_free (locator_set_name);
16329 vec_add1 (locator_set_name, 0);
16331 /* Construct the API message */
16332 M (ONE_ADD_DEL_LOCATOR, mp);
16334 mp->is_add = is_add;
16335 mp->sw_if_index = ntohl (sw_if_index);
16336 mp->priority = priority;
16337 mp->weight = weight;
16338 clib_memcpy (mp->locator_set_name, locator_set_name,
16339 vec_len (locator_set_name));
16340 vec_free (locator_set_name);
16345 /* Wait for a reply... */
16350 #define api_lisp_add_del_locator api_one_add_del_locator
16353 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16355 u32 *key_id = va_arg (*args, u32 *);
16358 if (unformat (input, "%s", &s))
16360 if (!strcmp ((char *) s, "sha1"))
16361 key_id[0] = HMAC_SHA_1_96;
16362 else if (!strcmp ((char *) s, "sha256"))
16363 key_id[0] = HMAC_SHA_256_128;
16366 clib_warning ("invalid key_id: '%s'", s);
16367 key_id[0] = HMAC_NO_KEY;
16378 api_one_add_del_local_eid (vat_main_t * vam)
16380 unformat_input_t *input = vam->input;
16381 vl_api_one_add_del_local_eid_t *mp;
16384 lisp_eid_vat_t _eid, *eid = &_eid;
16385 u8 *locator_set_name = 0;
16386 u8 locator_set_name_set = 0;
16392 /* Parse args required to build the message */
16393 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16395 if (unformat (input, "del"))
16399 else if (unformat (input, "vni %d", &vni))
16403 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16407 else if (unformat (input, "locator-set %s", &locator_set_name))
16409 locator_set_name_set = 1;
16411 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16413 else if (unformat (input, "secret-key %_%v%_", &key))
16419 if (locator_set_name_set == 0)
16421 errmsg ("missing locator-set name");
16427 errmsg ("EID address not set!");
16428 vec_free (locator_set_name);
16432 if (key && (0 == key_id))
16434 errmsg ("invalid key_id!");
16438 if (vec_len (key) > 64)
16440 errmsg ("key too long");
16445 if (vec_len (locator_set_name) > 64)
16447 errmsg ("locator-set name too long");
16448 vec_free (locator_set_name);
16451 vec_add1 (locator_set_name, 0);
16453 /* Construct the API message */
16454 M (ONE_ADD_DEL_LOCAL_EID, mp);
16456 mp->is_add = is_add;
16457 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16458 mp->eid_type = eid->type;
16459 mp->prefix_len = eid->len;
16460 mp->vni = clib_host_to_net_u32 (vni);
16461 mp->key_id = clib_host_to_net_u16 (key_id);
16462 clib_memcpy (mp->locator_set_name, locator_set_name,
16463 vec_len (locator_set_name));
16464 clib_memcpy (mp->key, key, vec_len (key));
16466 vec_free (locator_set_name);
16472 /* Wait for a reply... */
16477 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16480 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16482 u32 dp_table = 0, vni = 0;;
16483 unformat_input_t *input = vam->input;
16484 vl_api_gpe_add_del_fwd_entry_t *mp;
16486 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16487 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16488 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16489 u32 action = ~0, w;
16490 ip4_address_t rmt_rloc4, lcl_rloc4;
16491 ip6_address_t rmt_rloc6, lcl_rloc6;
16492 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16495 memset (&rloc, 0, sizeof (rloc));
16497 /* Parse args required to build the message */
16498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16500 if (unformat (input, "del"))
16502 else if (unformat (input, "add"))
16504 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16508 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16512 else if (unformat (input, "vrf %d", &dp_table))
16514 else if (unformat (input, "bd %d", &dp_table))
16516 else if (unformat (input, "vni %d", &vni))
16518 else if (unformat (input, "w %d", &w))
16522 errmsg ("No RLOC configured for setting priority/weight!");
16525 curr_rloc->weight = w;
16527 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16528 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16532 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16534 vec_add1 (lcl_locs, rloc);
16536 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16537 vec_add1 (rmt_locs, rloc);
16538 /* weight saved in rmt loc */
16539 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16541 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16542 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16545 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16547 vec_add1 (lcl_locs, rloc);
16549 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
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, "action %d", &action))
16560 clib_warning ("parse error '%U'", format_unformat_error, input);
16567 errmsg ("remote eid addresses not set");
16571 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16573 errmsg ("eid types don't match");
16577 if (0 == rmt_locs && (u32) ~ 0 == action)
16579 errmsg ("action not set for negative mapping");
16583 /* Construct the API message */
16584 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16585 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16587 mp->is_add = is_add;
16588 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16589 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16590 mp->eid_type = rmt_eid->type;
16591 mp->dp_table = clib_host_to_net_u32 (dp_table);
16592 mp->vni = clib_host_to_net_u32 (vni);
16593 mp->rmt_len = rmt_eid->len;
16594 mp->lcl_len = lcl_eid->len;
16595 mp->action = action;
16597 if (0 != rmt_locs && 0 != lcl_locs)
16599 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16600 clib_memcpy (mp->locs, lcl_locs,
16601 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16603 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16604 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16605 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16607 vec_free (lcl_locs);
16608 vec_free (rmt_locs);
16613 /* Wait for a reply... */
16619 api_one_add_del_map_server (vat_main_t * vam)
16621 unformat_input_t *input = vam->input;
16622 vl_api_one_add_del_map_server_t *mp;
16626 ip4_address_t ipv4;
16627 ip6_address_t ipv6;
16630 /* Parse args required to build the message */
16631 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16633 if (unformat (input, "del"))
16637 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16641 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16649 if (ipv4_set && ipv6_set)
16651 errmsg ("both eid v4 and v6 addresses set");
16655 if (!ipv4_set && !ipv6_set)
16657 errmsg ("eid addresses not set");
16661 /* Construct the API message */
16662 M (ONE_ADD_DEL_MAP_SERVER, mp);
16664 mp->is_add = is_add;
16668 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16673 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16679 /* Wait for a reply... */
16684 #define api_lisp_add_del_map_server api_one_add_del_map_server
16687 api_one_add_del_map_resolver (vat_main_t * vam)
16689 unformat_input_t *input = vam->input;
16690 vl_api_one_add_del_map_resolver_t *mp;
16694 ip4_address_t ipv4;
16695 ip6_address_t ipv6;
16698 /* Parse args required to build the message */
16699 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16701 if (unformat (input, "del"))
16705 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16709 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16717 if (ipv4_set && ipv6_set)
16719 errmsg ("both eid v4 and v6 addresses set");
16723 if (!ipv4_set && !ipv6_set)
16725 errmsg ("eid addresses not set");
16729 /* Construct the API message */
16730 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16732 mp->is_add = is_add;
16736 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16741 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16747 /* Wait for a reply... */
16752 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16755 api_lisp_gpe_enable_disable (vat_main_t * vam)
16757 unformat_input_t *input = vam->input;
16758 vl_api_gpe_enable_disable_t *mp;
16763 /* Parse args required to build the message */
16764 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16766 if (unformat (input, "enable"))
16771 else if (unformat (input, "disable"))
16782 errmsg ("Value not set");
16786 /* Construct the API message */
16787 M (GPE_ENABLE_DISABLE, mp);
16794 /* Wait for a reply... */
16800 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16802 unformat_input_t *input = vam->input;
16803 vl_api_one_rloc_probe_enable_disable_t *mp;
16808 /* Parse args required to build the message */
16809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16811 if (unformat (input, "enable"))
16816 else if (unformat (input, "disable"))
16824 errmsg ("Value not set");
16828 /* Construct the API message */
16829 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16831 mp->is_enabled = is_en;
16836 /* Wait for a reply... */
16841 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16844 api_one_map_register_enable_disable (vat_main_t * vam)
16846 unformat_input_t *input = vam->input;
16847 vl_api_one_map_register_enable_disable_t *mp;
16852 /* Parse args required to build the message */
16853 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16855 if (unformat (input, "enable"))
16860 else if (unformat (input, "disable"))
16868 errmsg ("Value not set");
16872 /* Construct the API message */
16873 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16875 mp->is_enabled = is_en;
16880 /* Wait for a reply... */
16885 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16888 api_one_enable_disable (vat_main_t * vam)
16890 unformat_input_t *input = vam->input;
16891 vl_api_one_enable_disable_t *mp;
16896 /* Parse args required to build the message */
16897 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16899 if (unformat (input, "enable"))
16904 else if (unformat (input, "disable"))
16914 errmsg ("Value not set");
16918 /* Construct the API message */
16919 M (ONE_ENABLE_DISABLE, mp);
16926 /* Wait for a reply... */
16931 #define api_lisp_enable_disable api_one_enable_disable
16934 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16936 unformat_input_t *input = vam->input;
16937 vl_api_one_enable_disable_xtr_mode_t *mp;
16942 /* Parse args required to build the message */
16943 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16945 if (unformat (input, "enable"))
16950 else if (unformat (input, "disable"))
16960 errmsg ("Value not set");
16964 /* Construct the API message */
16965 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16972 /* Wait for a reply... */
16978 api_one_show_xtr_mode (vat_main_t * vam)
16980 vl_api_one_show_xtr_mode_t *mp;
16983 /* Construct the API message */
16984 M (ONE_SHOW_XTR_MODE, mp);
16989 /* Wait for a reply... */
16995 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16997 unformat_input_t *input = vam->input;
16998 vl_api_one_enable_disable_pitr_mode_t *mp;
17003 /* Parse args required to build the message */
17004 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17006 if (unformat (input, "enable"))
17011 else if (unformat (input, "disable"))
17021 errmsg ("Value not set");
17025 /* Construct the API message */
17026 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17033 /* Wait for a reply... */
17039 api_one_show_pitr_mode (vat_main_t * vam)
17041 vl_api_one_show_pitr_mode_t *mp;
17044 /* Construct the API message */
17045 M (ONE_SHOW_PITR_MODE, mp);
17050 /* Wait for a reply... */
17056 api_one_enable_disable_petr_mode (vat_main_t * vam)
17058 unformat_input_t *input = vam->input;
17059 vl_api_one_enable_disable_petr_mode_t *mp;
17064 /* Parse args required to build the message */
17065 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17067 if (unformat (input, "enable"))
17072 else if (unformat (input, "disable"))
17082 errmsg ("Value not set");
17086 /* Construct the API message */
17087 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17094 /* Wait for a reply... */
17100 api_one_show_petr_mode (vat_main_t * vam)
17102 vl_api_one_show_petr_mode_t *mp;
17105 /* Construct the API message */
17106 M (ONE_SHOW_PETR_MODE, mp);
17111 /* Wait for a reply... */
17117 api_show_one_map_register_state (vat_main_t * vam)
17119 vl_api_show_one_map_register_state_t *mp;
17122 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17127 /* wait for reply */
17132 #define api_show_lisp_map_register_state api_show_one_map_register_state
17135 api_show_one_rloc_probe_state (vat_main_t * vam)
17137 vl_api_show_one_rloc_probe_state_t *mp;
17140 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17145 /* wait for reply */
17150 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17153 api_one_add_del_ndp_entry (vat_main_t * vam)
17155 vl_api_one_add_del_ndp_entry_t *mp;
17156 unformat_input_t *input = vam->input;
17161 u8 mac[6] = { 0, };
17162 u8 ip6[16] = { 0, };
17166 /* Parse args required to build the message */
17167 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17169 if (unformat (input, "del"))
17171 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17173 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17175 else if (unformat (input, "bd %d", &bd))
17179 errmsg ("parse error '%U'", format_unformat_error, input);
17184 if (!bd_set || !ip_set || (!mac_set && is_add))
17186 errmsg ("Missing BD, IP or MAC!");
17190 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17191 mp->is_add = is_add;
17192 clib_memcpy (mp->mac, mac, 6);
17193 mp->bd = clib_host_to_net_u32 (bd);
17194 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17199 /* wait for reply */
17205 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17207 vl_api_one_add_del_l2_arp_entry_t *mp;
17208 unformat_input_t *input = vam->input;
17213 u8 mac[6] = { 0, };
17214 u32 ip4 = 0, bd = ~0;
17217 /* Parse args required to build the message */
17218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17220 if (unformat (input, "del"))
17222 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17224 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17226 else if (unformat (input, "bd %d", &bd))
17230 errmsg ("parse error '%U'", format_unformat_error, input);
17235 if (!bd_set || !ip_set || (!mac_set && is_add))
17237 errmsg ("Missing BD, IP or MAC!");
17241 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17242 mp->is_add = is_add;
17243 clib_memcpy (mp->mac, mac, 6);
17244 mp->bd = clib_host_to_net_u32 (bd);
17250 /* wait for reply */
17256 api_one_ndp_bd_get (vat_main_t * vam)
17258 vl_api_one_ndp_bd_get_t *mp;
17261 M (ONE_NDP_BD_GET, mp);
17266 /* wait for reply */
17272 api_one_ndp_entries_get (vat_main_t * vam)
17274 vl_api_one_ndp_entries_get_t *mp;
17275 unformat_input_t *input = vam->input;
17280 /* Parse args required to build the message */
17281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17283 if (unformat (input, "bd %d", &bd))
17287 errmsg ("parse error '%U'", format_unformat_error, input);
17294 errmsg ("Expected bridge domain!");
17298 M (ONE_NDP_ENTRIES_GET, mp);
17299 mp->bd = clib_host_to_net_u32 (bd);
17304 /* wait for reply */
17310 api_one_l2_arp_bd_get (vat_main_t * vam)
17312 vl_api_one_l2_arp_bd_get_t *mp;
17315 M (ONE_L2_ARP_BD_GET, mp);
17320 /* wait for reply */
17326 api_one_l2_arp_entries_get (vat_main_t * vam)
17328 vl_api_one_l2_arp_entries_get_t *mp;
17329 unformat_input_t *input = vam->input;
17334 /* Parse args required to build the message */
17335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17337 if (unformat (input, "bd %d", &bd))
17341 errmsg ("parse error '%U'", format_unformat_error, input);
17348 errmsg ("Expected bridge domain!");
17352 M (ONE_L2_ARP_ENTRIES_GET, mp);
17353 mp->bd = clib_host_to_net_u32 (bd);
17358 /* wait for reply */
17364 api_one_stats_enable_disable (vat_main_t * vam)
17366 vl_api_one_stats_enable_disable_t *mp;
17367 unformat_input_t *input = vam->input;
17372 /* Parse args required to build the message */
17373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17375 if (unformat (input, "enable"))
17380 else if (unformat (input, "disable"))
17390 errmsg ("Value not set");
17394 M (ONE_STATS_ENABLE_DISABLE, mp);
17400 /* wait for reply */
17406 api_show_one_stats_enable_disable (vat_main_t * vam)
17408 vl_api_show_one_stats_enable_disable_t *mp;
17411 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17416 /* wait for reply */
17422 api_show_one_map_request_mode (vat_main_t * vam)
17424 vl_api_show_one_map_request_mode_t *mp;
17427 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17432 /* wait for reply */
17437 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17440 api_one_map_request_mode (vat_main_t * vam)
17442 unformat_input_t *input = vam->input;
17443 vl_api_one_map_request_mode_t *mp;
17447 /* Parse args required to build the message */
17448 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17450 if (unformat (input, "dst-only"))
17452 else if (unformat (input, "src-dst"))
17456 errmsg ("parse error '%U'", format_unformat_error, input);
17461 M (ONE_MAP_REQUEST_MODE, mp);
17468 /* wait for reply */
17473 #define api_lisp_map_request_mode api_one_map_request_mode
17476 * Enable/disable ONE proxy ITR.
17478 * @param vam vpp API test context
17479 * @return return code
17482 api_one_pitr_set_locator_set (vat_main_t * vam)
17484 u8 ls_name_set = 0;
17485 unformat_input_t *input = vam->input;
17486 vl_api_one_pitr_set_locator_set_t *mp;
17491 /* Parse args required to build the message */
17492 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17494 if (unformat (input, "del"))
17496 else if (unformat (input, "locator-set %s", &ls_name))
17500 errmsg ("parse error '%U'", format_unformat_error, input);
17507 errmsg ("locator-set name not set!");
17511 M (ONE_PITR_SET_LOCATOR_SET, mp);
17513 mp->is_add = is_add;
17514 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17515 vec_free (ls_name);
17520 /* wait for reply */
17525 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17528 api_one_nsh_set_locator_set (vat_main_t * vam)
17530 u8 ls_name_set = 0;
17531 unformat_input_t *input = vam->input;
17532 vl_api_one_nsh_set_locator_set_t *mp;
17537 /* Parse args required to build the message */
17538 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17540 if (unformat (input, "del"))
17542 else if (unformat (input, "ls %s", &ls_name))
17546 errmsg ("parse error '%U'", format_unformat_error, input);
17551 if (!ls_name_set && is_add)
17553 errmsg ("locator-set name not set!");
17557 M (ONE_NSH_SET_LOCATOR_SET, mp);
17559 mp->is_add = is_add;
17560 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17561 vec_free (ls_name);
17566 /* wait for reply */
17572 api_show_one_pitr (vat_main_t * vam)
17574 vl_api_show_one_pitr_t *mp;
17577 if (!vam->json_output)
17579 print (vam->ofp, "%=20s", "lisp status:");
17582 M (SHOW_ONE_PITR, mp);
17586 /* Wait for a reply... */
17591 #define api_show_lisp_pitr api_show_one_pitr
17594 api_one_use_petr (vat_main_t * vam)
17596 unformat_input_t *input = vam->input;
17597 vl_api_one_use_petr_t *mp;
17602 memset (&ip, 0, sizeof (ip));
17604 /* Parse args required to build the message */
17605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17607 if (unformat (input, "disable"))
17610 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17613 ip_addr_version (&ip) = IP4;
17616 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17619 ip_addr_version (&ip) = IP6;
17623 errmsg ("parse error '%U'", format_unformat_error, input);
17628 M (ONE_USE_PETR, mp);
17630 mp->is_add = is_add;
17633 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17635 clib_memcpy (mp->address, &ip, 4);
17637 clib_memcpy (mp->address, &ip, 16);
17643 /* wait for reply */
17648 #define api_lisp_use_petr api_one_use_petr
17651 api_show_one_nsh_mapping (vat_main_t * vam)
17653 vl_api_show_one_use_petr_t *mp;
17656 if (!vam->json_output)
17658 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17661 M (SHOW_ONE_NSH_MAPPING, mp);
17665 /* Wait for a reply... */
17671 api_show_one_use_petr (vat_main_t * vam)
17673 vl_api_show_one_use_petr_t *mp;
17676 if (!vam->json_output)
17678 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17681 M (SHOW_ONE_USE_PETR, mp);
17685 /* Wait for a reply... */
17690 #define api_show_lisp_use_petr api_show_one_use_petr
17693 * Add/delete mapping between vni and vrf
17696 api_one_eid_table_add_del_map (vat_main_t * vam)
17698 unformat_input_t *input = vam->input;
17699 vl_api_one_eid_table_add_del_map_t *mp;
17700 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17701 u32 vni, vrf, bd_index;
17704 /* Parse args required to build the message */
17705 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17707 if (unformat (input, "del"))
17709 else if (unformat (input, "vrf %d", &vrf))
17711 else if (unformat (input, "bd_index %d", &bd_index))
17713 else if (unformat (input, "vni %d", &vni))
17719 if (!vni_set || (!vrf_set && !bd_index_set))
17721 errmsg ("missing arguments!");
17725 if (vrf_set && bd_index_set)
17727 errmsg ("error: both vrf and bd entered!");
17731 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17733 mp->is_add = is_add;
17734 mp->vni = htonl (vni);
17735 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17736 mp->is_l2 = bd_index_set;
17741 /* wait for reply */
17746 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17749 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17751 u32 *action = va_arg (*args, u32 *);
17754 if (unformat (input, "%s", &s))
17756 if (!strcmp ((char *) s, "no-action"))
17758 else if (!strcmp ((char *) s, "natively-forward"))
17760 else if (!strcmp ((char *) s, "send-map-request"))
17762 else if (!strcmp ((char *) s, "drop"))
17766 clib_warning ("invalid action: '%s'", s);
17778 * Add/del remote mapping to/from ONE control plane
17780 * @param vam vpp API test context
17781 * @return return code
17784 api_one_add_del_remote_mapping (vat_main_t * vam)
17786 unformat_input_t *input = vam->input;
17787 vl_api_one_add_del_remote_mapping_t *mp;
17789 lisp_eid_vat_t _eid, *eid = &_eid;
17790 lisp_eid_vat_t _seid, *seid = &_seid;
17791 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17792 u32 action = ~0, p, w, data_len;
17793 ip4_address_t rloc4;
17794 ip6_address_t rloc6;
17795 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17798 memset (&rloc, 0, sizeof (rloc));
17800 /* Parse args required to build the message */
17801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17803 if (unformat (input, "del-all"))
17807 else if (unformat (input, "del"))
17811 else if (unformat (input, "add"))
17815 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17819 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17823 else if (unformat (input, "vni %d", &vni))
17827 else if (unformat (input, "p %d w %d", &p, &w))
17831 errmsg ("No RLOC configured for setting priority/weight!");
17834 curr_rloc->priority = p;
17835 curr_rloc->weight = w;
17837 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17840 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17841 vec_add1 (rlocs, rloc);
17842 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17844 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17847 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17848 vec_add1 (rlocs, rloc);
17849 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17851 else if (unformat (input, "action %U",
17852 unformat_negative_mapping_action, &action))
17858 clib_warning ("parse error '%U'", format_unformat_error, input);
17865 errmsg ("missing params!");
17869 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17871 errmsg ("no action set for negative map-reply!");
17875 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17877 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17878 mp->is_add = is_add;
17879 mp->vni = htonl (vni);
17880 mp->action = (u8) action;
17881 mp->is_src_dst = seid_set;
17882 mp->eid_len = eid->len;
17883 mp->seid_len = seid->len;
17884 mp->del_all = del_all;
17885 mp->eid_type = eid->type;
17886 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17887 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17889 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17890 clib_memcpy (mp->rlocs, rlocs, data_len);
17896 /* Wait for a reply... */
17901 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17904 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17905 * forwarding entries in data-plane accordingly.
17907 * @param vam vpp API test context
17908 * @return return code
17911 api_one_add_del_adjacency (vat_main_t * vam)
17913 unformat_input_t *input = vam->input;
17914 vl_api_one_add_del_adjacency_t *mp;
17916 ip4_address_t leid4, reid4;
17917 ip6_address_t leid6, reid6;
17918 u8 reid_mac[6] = { 0 };
17919 u8 leid_mac[6] = { 0 };
17920 u8 reid_type, leid_type;
17921 u32 leid_len = 0, reid_len = 0, len;
17925 leid_type = reid_type = (u8) ~ 0;
17927 /* Parse args required to build the message */
17928 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17930 if (unformat (input, "del"))
17934 else if (unformat (input, "add"))
17938 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17941 reid_type = 0; /* ipv4 */
17944 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17947 reid_type = 1; /* ipv6 */
17950 else if (unformat (input, "reid %U", unformat_ethernet_address,
17953 reid_type = 2; /* mac */
17955 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17958 leid_type = 0; /* ipv4 */
17961 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17964 leid_type = 1; /* ipv6 */
17967 else if (unformat (input, "leid %U", unformat_ethernet_address,
17970 leid_type = 2; /* mac */
17972 else if (unformat (input, "vni %d", &vni))
17978 errmsg ("parse error '%U'", format_unformat_error, input);
17983 if ((u8) ~ 0 == reid_type)
17985 errmsg ("missing params!");
17989 if (leid_type != reid_type)
17991 errmsg ("remote and local EIDs are of different types!");
17995 M (ONE_ADD_DEL_ADJACENCY, mp);
17996 mp->is_add = is_add;
17997 mp->vni = htonl (vni);
17998 mp->leid_len = leid_len;
17999 mp->reid_len = reid_len;
18000 mp->eid_type = reid_type;
18002 switch (mp->eid_type)
18005 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18006 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18009 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18010 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18013 clib_memcpy (mp->leid, leid_mac, 6);
18014 clib_memcpy (mp->reid, reid_mac, 6);
18017 errmsg ("unknown EID type %d!", mp->eid_type);
18024 /* Wait for a reply... */
18029 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18032 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18034 u32 *mode = va_arg (*args, u32 *);
18036 if (unformat (input, "lisp"))
18038 else if (unformat (input, "vxlan"))
18047 api_gpe_get_encap_mode (vat_main_t * vam)
18049 vl_api_gpe_get_encap_mode_t *mp;
18052 /* Construct the API message */
18053 M (GPE_GET_ENCAP_MODE, mp);
18058 /* Wait for a reply... */
18064 api_gpe_set_encap_mode (vat_main_t * vam)
18066 unformat_input_t *input = vam->input;
18067 vl_api_gpe_set_encap_mode_t *mp;
18071 /* Parse args required to build the message */
18072 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18074 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18080 /* Construct the API message */
18081 M (GPE_SET_ENCAP_MODE, mp);
18088 /* Wait for a reply... */
18094 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18096 unformat_input_t *input = vam->input;
18097 vl_api_gpe_add_del_iface_t *mp;
18098 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18099 u32 dp_table = 0, vni = 0;
18102 /* Parse args required to build the message */
18103 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18105 if (unformat (input, "up"))
18110 else if (unformat (input, "down"))
18115 else if (unformat (input, "table_id %d", &dp_table))
18119 else if (unformat (input, "bd_id %d", &dp_table))
18124 else if (unformat (input, "vni %d", &vni))
18132 if (action_set == 0)
18134 errmsg ("Action not set");
18137 if (dp_table_set == 0 || vni_set == 0)
18139 errmsg ("vni and dp_table must be set");
18143 /* Construct the API message */
18144 M (GPE_ADD_DEL_IFACE, mp);
18146 mp->is_add = is_add;
18147 mp->dp_table = clib_host_to_net_u32 (dp_table);
18149 mp->vni = clib_host_to_net_u32 (vni);
18154 /* Wait for a reply... */
18160 api_one_map_register_fallback_threshold (vat_main_t * vam)
18162 unformat_input_t *input = vam->input;
18163 vl_api_one_map_register_fallback_threshold_t *mp;
18168 /* Parse args required to build the message */
18169 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18171 if (unformat (input, "%u", &value))
18175 clib_warning ("parse error '%U'", format_unformat_error, input);
18182 errmsg ("fallback threshold value is missing!");
18186 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18187 mp->value = clib_host_to_net_u32 (value);
18192 /* Wait for a reply... */
18198 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18200 vl_api_show_one_map_register_fallback_threshold_t *mp;
18203 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18208 /* Wait for a reply... */
18214 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18216 u32 *proto = va_arg (*args, u32 *);
18218 if (unformat (input, "udp"))
18220 else if (unformat (input, "api"))
18229 api_one_set_transport_protocol (vat_main_t * vam)
18231 unformat_input_t *input = vam->input;
18232 vl_api_one_set_transport_protocol_t *mp;
18237 /* Parse args required to build the message */
18238 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18240 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18244 clib_warning ("parse error '%U'", format_unformat_error, input);
18251 errmsg ("Transport protocol missing!");
18255 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18256 mp->protocol = (u8) protocol;
18261 /* Wait for a reply... */
18267 api_one_get_transport_protocol (vat_main_t * vam)
18269 vl_api_one_get_transport_protocol_t *mp;
18272 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18277 /* Wait for a reply... */
18283 api_one_map_register_set_ttl (vat_main_t * vam)
18285 unformat_input_t *input = vam->input;
18286 vl_api_one_map_register_set_ttl_t *mp;
18291 /* Parse args required to build the message */
18292 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18294 if (unformat (input, "%u", &ttl))
18298 clib_warning ("parse error '%U'", format_unformat_error, input);
18305 errmsg ("TTL value missing!");
18309 M (ONE_MAP_REGISTER_SET_TTL, mp);
18310 mp->ttl = clib_host_to_net_u32 (ttl);
18315 /* Wait for a reply... */
18321 api_show_one_map_register_ttl (vat_main_t * vam)
18323 vl_api_show_one_map_register_ttl_t *mp;
18326 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18331 /* Wait for a reply... */
18337 * Add/del map request itr rlocs from ONE control plane and updates
18339 * @param vam vpp API test context
18340 * @return return code
18343 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18345 unformat_input_t *input = vam->input;
18346 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18347 u8 *locator_set_name = 0;
18348 u8 locator_set_name_set = 0;
18352 /* Parse args required to build the message */
18353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18355 if (unformat (input, "del"))
18359 else if (unformat (input, "%_%v%_", &locator_set_name))
18361 locator_set_name_set = 1;
18365 clib_warning ("parse error '%U'", format_unformat_error, input);
18370 if (is_add && !locator_set_name_set)
18372 errmsg ("itr-rloc is not set!");
18376 if (is_add && vec_len (locator_set_name) > 64)
18378 errmsg ("itr-rloc locator-set name too long");
18379 vec_free (locator_set_name);
18383 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18384 mp->is_add = is_add;
18387 clib_memcpy (mp->locator_set_name, locator_set_name,
18388 vec_len (locator_set_name));
18392 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18394 vec_free (locator_set_name);
18399 /* Wait for a reply... */
18404 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18407 api_one_locator_dump (vat_main_t * vam)
18409 unformat_input_t *input = vam->input;
18410 vl_api_one_locator_dump_t *mp;
18411 vl_api_control_ping_t *mp_ping;
18412 u8 is_index_set = 0, is_name_set = 0;
18417 /* Parse args required to build the message */
18418 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18420 if (unformat (input, "ls_name %_%v%_", &ls_name))
18424 else if (unformat (input, "ls_index %d", &ls_index))
18430 errmsg ("parse error '%U'", format_unformat_error, input);
18435 if (!is_index_set && !is_name_set)
18437 errmsg ("error: expected one of index or name!");
18441 if (is_index_set && is_name_set)
18443 errmsg ("error: only one param expected!");
18447 if (vec_len (ls_name) > 62)
18449 errmsg ("error: locator set name too long!");
18453 if (!vam->json_output)
18455 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18458 M (ONE_LOCATOR_DUMP, mp);
18459 mp->is_index_set = is_index_set;
18462 mp->ls_index = clib_host_to_net_u32 (ls_index);
18465 vec_add1 (ls_name, 0);
18466 strncpy ((char *) mp->ls_name, (char *) ls_name,
18467 sizeof (mp->ls_name) - 1);
18473 /* Use a control ping for synchronization */
18474 MPING (CONTROL_PING, mp_ping);
18477 /* Wait for a reply... */
18482 #define api_lisp_locator_dump api_one_locator_dump
18485 api_one_locator_set_dump (vat_main_t * vam)
18487 vl_api_one_locator_set_dump_t *mp;
18488 vl_api_control_ping_t *mp_ping;
18489 unformat_input_t *input = vam->input;
18493 /* Parse args required to build the message */
18494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18496 if (unformat (input, "local"))
18500 else if (unformat (input, "remote"))
18506 errmsg ("parse error '%U'", format_unformat_error, input);
18511 if (!vam->json_output)
18513 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18516 M (ONE_LOCATOR_SET_DUMP, mp);
18518 mp->filter = filter;
18523 /* Use a control ping for synchronization */
18524 MPING (CONTROL_PING, mp_ping);
18527 /* Wait for a reply... */
18532 #define api_lisp_locator_set_dump api_one_locator_set_dump
18535 api_one_eid_table_map_dump (vat_main_t * vam)
18539 unformat_input_t *input = vam->input;
18540 vl_api_one_eid_table_map_dump_t *mp;
18541 vl_api_control_ping_t *mp_ping;
18544 /* Parse args required to build the message */
18545 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18547 if (unformat (input, "l2"))
18552 else if (unformat (input, "l3"))
18559 errmsg ("parse error '%U'", format_unformat_error, input);
18566 errmsg ("expected one of 'l2' or 'l3' parameter!");
18570 if (!vam->json_output)
18572 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18575 M (ONE_EID_TABLE_MAP_DUMP, mp);
18581 /* Use a control ping for synchronization */
18582 MPING (CONTROL_PING, mp_ping);
18585 /* Wait for a reply... */
18590 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18593 api_one_eid_table_vni_dump (vat_main_t * vam)
18595 vl_api_one_eid_table_vni_dump_t *mp;
18596 vl_api_control_ping_t *mp_ping;
18599 if (!vam->json_output)
18601 print (vam->ofp, "VNI");
18604 M (ONE_EID_TABLE_VNI_DUMP, mp);
18609 /* Use a control ping for synchronization */
18610 MPING (CONTROL_PING, mp_ping);
18613 /* Wait for a reply... */
18618 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18621 api_one_eid_table_dump (vat_main_t * vam)
18623 unformat_input_t *i = vam->input;
18624 vl_api_one_eid_table_dump_t *mp;
18625 vl_api_control_ping_t *mp_ping;
18626 struct in_addr ip4;
18627 struct in6_addr ip6;
18629 u8 eid_type = ~0, eid_set = 0;
18630 u32 prefix_length = ~0, t, vni = 0;
18633 lisp_nsh_api_t nsh;
18635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18637 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18643 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18649 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18654 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18659 else if (unformat (i, "vni %d", &t))
18663 else if (unformat (i, "local"))
18667 else if (unformat (i, "remote"))
18673 errmsg ("parse error '%U'", format_unformat_error, i);
18678 if (!vam->json_output)
18680 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18681 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18684 M (ONE_EID_TABLE_DUMP, mp);
18686 mp->filter = filter;
18690 mp->vni = htonl (vni);
18691 mp->eid_type = eid_type;
18695 mp->prefix_length = prefix_length;
18696 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18699 mp->prefix_length = prefix_length;
18700 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18703 clib_memcpy (mp->eid, mac, sizeof (mac));
18706 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18709 errmsg ("unknown EID type %d!", eid_type);
18717 /* Use a control ping for synchronization */
18718 MPING (CONTROL_PING, mp_ping);
18721 /* Wait for a reply... */
18726 #define api_lisp_eid_table_dump api_one_eid_table_dump
18729 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18731 unformat_input_t *i = vam->input;
18732 vl_api_gpe_fwd_entries_get_t *mp;
18737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18739 if (unformat (i, "vni %d", &vni))
18745 errmsg ("parse error '%U'", format_unformat_error, i);
18752 errmsg ("vni not set!");
18756 if (!vam->json_output)
18758 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18762 M (GPE_FWD_ENTRIES_GET, mp);
18763 mp->vni = clib_host_to_net_u32 (vni);
18768 /* Wait for a reply... */
18773 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18774 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18775 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18776 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18777 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18778 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18779 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18780 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18783 api_one_adjacencies_get (vat_main_t * vam)
18785 unformat_input_t *i = vam->input;
18786 vl_api_one_adjacencies_get_t *mp;
18791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18793 if (unformat (i, "vni %d", &vni))
18799 errmsg ("parse error '%U'", format_unformat_error, i);
18806 errmsg ("vni not set!");
18810 if (!vam->json_output)
18812 print (vam->ofp, "%s %40s", "leid", "reid");
18815 M (ONE_ADJACENCIES_GET, mp);
18816 mp->vni = clib_host_to_net_u32 (vni);
18821 /* Wait for a reply... */
18826 #define api_lisp_adjacencies_get api_one_adjacencies_get
18829 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18831 unformat_input_t *i = vam->input;
18832 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18834 u8 ip_family_set = 0, is_ip4 = 1;
18836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18838 if (unformat (i, "ip4"))
18843 else if (unformat (i, "ip6"))
18850 errmsg ("parse error '%U'", format_unformat_error, i);
18855 if (!ip_family_set)
18857 errmsg ("ip family not set!");
18861 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18862 mp->is_ip4 = is_ip4;
18867 /* Wait for a reply... */
18873 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18875 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18878 if (!vam->json_output)
18880 print (vam->ofp, "VNIs");
18883 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18888 /* Wait for a reply... */
18894 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18896 unformat_input_t *i = vam->input;
18897 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18899 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18900 struct in_addr ip4;
18901 struct in6_addr ip6;
18902 u32 table_id = 0, nh_sw_if_index = ~0;
18904 memset (&ip4, 0, sizeof (ip4));
18905 memset (&ip6, 0, sizeof (ip6));
18907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18909 if (unformat (i, "del"))
18911 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18912 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18917 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18918 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18923 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18927 nh_sw_if_index = ~0;
18929 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18933 nh_sw_if_index = ~0;
18935 else if (unformat (i, "table %d", &table_id))
18939 errmsg ("parse error '%U'", format_unformat_error, i);
18946 errmsg ("nh addr not set!");
18950 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18951 mp->is_add = is_add;
18952 mp->table_id = clib_host_to_net_u32 (table_id);
18953 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18954 mp->is_ip4 = is_ip4;
18956 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18958 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18963 /* Wait for a reply... */
18969 api_one_map_server_dump (vat_main_t * vam)
18971 vl_api_one_map_server_dump_t *mp;
18972 vl_api_control_ping_t *mp_ping;
18975 if (!vam->json_output)
18977 print (vam->ofp, "%=20s", "Map server");
18980 M (ONE_MAP_SERVER_DUMP, mp);
18984 /* Use a control ping for synchronization */
18985 MPING (CONTROL_PING, mp_ping);
18988 /* Wait for a reply... */
18993 #define api_lisp_map_server_dump api_one_map_server_dump
18996 api_one_map_resolver_dump (vat_main_t * vam)
18998 vl_api_one_map_resolver_dump_t *mp;
18999 vl_api_control_ping_t *mp_ping;
19002 if (!vam->json_output)
19004 print (vam->ofp, "%=20s", "Map resolver");
19007 M (ONE_MAP_RESOLVER_DUMP, mp);
19011 /* Use a control ping for synchronization */
19012 MPING (CONTROL_PING, mp_ping);
19015 /* Wait for a reply... */
19020 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19023 api_one_stats_flush (vat_main_t * vam)
19025 vl_api_one_stats_flush_t *mp;
19028 M (ONE_STATS_FLUSH, mp);
19035 api_one_stats_dump (vat_main_t * vam)
19037 vl_api_one_stats_dump_t *mp;
19038 vl_api_control_ping_t *mp_ping;
19041 M (ONE_STATS_DUMP, mp);
19045 /* Use a control ping for synchronization */
19046 MPING (CONTROL_PING, mp_ping);
19049 /* Wait for a reply... */
19055 api_show_one_status (vat_main_t * vam)
19057 vl_api_show_one_status_t *mp;
19060 if (!vam->json_output)
19062 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19065 M (SHOW_ONE_STATUS, mp);
19068 /* Wait for a reply... */
19073 #define api_show_lisp_status api_show_one_status
19076 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19078 vl_api_gpe_fwd_entry_path_dump_t *mp;
19079 vl_api_control_ping_t *mp_ping;
19080 unformat_input_t *i = vam->input;
19081 u32 fwd_entry_index = ~0;
19084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19086 if (unformat (i, "index %d", &fwd_entry_index))
19092 if (~0 == fwd_entry_index)
19094 errmsg ("no index specified!");
19098 if (!vam->json_output)
19100 print (vam->ofp, "first line");
19103 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19107 /* Use a control ping for synchronization */
19108 MPING (CONTROL_PING, mp_ping);
19111 /* Wait for a reply... */
19117 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19119 vl_api_one_get_map_request_itr_rlocs_t *mp;
19122 if (!vam->json_output)
19124 print (vam->ofp, "%=20s", "itr-rlocs:");
19127 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19130 /* Wait for a reply... */
19135 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19138 api_af_packet_create (vat_main_t * vam)
19140 unformat_input_t *i = vam->input;
19141 vl_api_af_packet_create_t *mp;
19142 u8 *host_if_name = 0;
19144 u8 random_hw_addr = 1;
19147 memset (hw_addr, 0, sizeof (hw_addr));
19149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19151 if (unformat (i, "name %s", &host_if_name))
19152 vec_add1 (host_if_name, 0);
19153 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19154 random_hw_addr = 0;
19159 if (!vec_len (host_if_name))
19161 errmsg ("host-interface name must be specified");
19165 if (vec_len (host_if_name) > 64)
19167 errmsg ("host-interface name too long");
19171 M (AF_PACKET_CREATE, mp);
19173 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19174 clib_memcpy (mp->hw_addr, hw_addr, 6);
19175 mp->use_random_hw_addr = random_hw_addr;
19176 vec_free (host_if_name);
19184 fprintf (vam->ofp ? vam->ofp : stderr,
19185 " new sw_if_index = %d\n", vam->sw_if_index);
19192 api_af_packet_delete (vat_main_t * vam)
19194 unformat_input_t *i = vam->input;
19195 vl_api_af_packet_delete_t *mp;
19196 u8 *host_if_name = 0;
19199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19201 if (unformat (i, "name %s", &host_if_name))
19202 vec_add1 (host_if_name, 0);
19207 if (!vec_len (host_if_name))
19209 errmsg ("host-interface name must be specified");
19213 if (vec_len (host_if_name) > 64)
19215 errmsg ("host-interface name too long");
19219 M (AF_PACKET_DELETE, mp);
19221 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19222 vec_free (host_if_name);
19230 api_policer_add_del (vat_main_t * vam)
19232 unformat_input_t *i = vam->input;
19233 vl_api_policer_add_del_t *mp;
19243 u8 color_aware = 0;
19244 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19247 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19248 conform_action.dscp = 0;
19249 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19250 exceed_action.dscp = 0;
19251 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19252 violate_action.dscp = 0;
19254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19256 if (unformat (i, "del"))
19258 else if (unformat (i, "name %s", &name))
19259 vec_add1 (name, 0);
19260 else if (unformat (i, "cir %u", &cir))
19262 else if (unformat (i, "eir %u", &eir))
19264 else if (unformat (i, "cb %u", &cb))
19266 else if (unformat (i, "eb %u", &eb))
19268 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19271 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19274 else if (unformat (i, "type %U", unformat_policer_type, &type))
19276 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19279 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19282 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19285 else if (unformat (i, "color-aware"))
19291 if (!vec_len (name))
19293 errmsg ("policer name must be specified");
19297 if (vec_len (name) > 64)
19299 errmsg ("policer name too long");
19303 M (POLICER_ADD_DEL, mp);
19305 clib_memcpy (mp->name, name, vec_len (name));
19307 mp->is_add = is_add;
19308 mp->cir = ntohl (cir);
19309 mp->eir = ntohl (eir);
19310 mp->cb = clib_net_to_host_u64 (cb);
19311 mp->eb = clib_net_to_host_u64 (eb);
19312 mp->rate_type = rate_type;
19313 mp->round_type = round_type;
19315 mp->conform_action_type = conform_action.action_type;
19316 mp->conform_dscp = conform_action.dscp;
19317 mp->exceed_action_type = exceed_action.action_type;
19318 mp->exceed_dscp = exceed_action.dscp;
19319 mp->violate_action_type = violate_action.action_type;
19320 mp->violate_dscp = violate_action.dscp;
19321 mp->color_aware = color_aware;
19329 api_policer_dump (vat_main_t * vam)
19331 unformat_input_t *i = vam->input;
19332 vl_api_policer_dump_t *mp;
19333 vl_api_control_ping_t *mp_ping;
19334 u8 *match_name = 0;
19335 u8 match_name_valid = 0;
19338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19340 if (unformat (i, "name %s", &match_name))
19342 vec_add1 (match_name, 0);
19343 match_name_valid = 1;
19349 M (POLICER_DUMP, mp);
19350 mp->match_name_valid = match_name_valid;
19351 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19352 vec_free (match_name);
19356 /* Use a control ping for synchronization */
19357 MPING (CONTROL_PING, mp_ping);
19360 /* Wait for a reply... */
19366 api_policer_classify_set_interface (vat_main_t * vam)
19368 unformat_input_t *i = vam->input;
19369 vl_api_policer_classify_set_interface_t *mp;
19371 int sw_if_index_set;
19372 u32 ip4_table_index = ~0;
19373 u32 ip6_table_index = ~0;
19374 u32 l2_table_index = ~0;
19378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19380 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19381 sw_if_index_set = 1;
19382 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19383 sw_if_index_set = 1;
19384 else if (unformat (i, "del"))
19386 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19388 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19390 else if (unformat (i, "l2-table %d", &l2_table_index))
19394 clib_warning ("parse error '%U'", format_unformat_error, i);
19399 if (sw_if_index_set == 0)
19401 errmsg ("missing interface name or sw_if_index");
19405 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19407 mp->sw_if_index = ntohl (sw_if_index);
19408 mp->ip4_table_index = ntohl (ip4_table_index);
19409 mp->ip6_table_index = ntohl (ip6_table_index);
19410 mp->l2_table_index = ntohl (l2_table_index);
19411 mp->is_add = is_add;
19419 api_policer_classify_dump (vat_main_t * vam)
19421 unformat_input_t *i = vam->input;
19422 vl_api_policer_classify_dump_t *mp;
19423 vl_api_control_ping_t *mp_ping;
19424 u8 type = POLICER_CLASSIFY_N_TABLES;
19427 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19431 errmsg ("classify table type must be specified");
19435 if (!vam->json_output)
19437 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19440 M (POLICER_CLASSIFY_DUMP, mp);
19445 /* Use a control ping for synchronization */
19446 MPING (CONTROL_PING, mp_ping);
19449 /* Wait for a reply... */
19455 api_netmap_create (vat_main_t * vam)
19457 unformat_input_t *i = vam->input;
19458 vl_api_netmap_create_t *mp;
19461 u8 random_hw_addr = 1;
19466 memset (hw_addr, 0, sizeof (hw_addr));
19468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19470 if (unformat (i, "name %s", &if_name))
19471 vec_add1 (if_name, 0);
19472 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19473 random_hw_addr = 0;
19474 else if (unformat (i, "pipe"))
19476 else if (unformat (i, "master"))
19478 else if (unformat (i, "slave"))
19484 if (!vec_len (if_name))
19486 errmsg ("interface name must be specified");
19490 if (vec_len (if_name) > 64)
19492 errmsg ("interface name too long");
19496 M (NETMAP_CREATE, mp);
19498 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19499 clib_memcpy (mp->hw_addr, hw_addr, 6);
19500 mp->use_random_hw_addr = random_hw_addr;
19501 mp->is_pipe = is_pipe;
19502 mp->is_master = is_master;
19503 vec_free (if_name);
19511 api_netmap_delete (vat_main_t * vam)
19513 unformat_input_t *i = vam->input;
19514 vl_api_netmap_delete_t *mp;
19518 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19520 if (unformat (i, "name %s", &if_name))
19521 vec_add1 (if_name, 0);
19526 if (!vec_len (if_name))
19528 errmsg ("interface name must be specified");
19532 if (vec_len (if_name) > 64)
19534 errmsg ("interface name too long");
19538 M (NETMAP_DELETE, mp);
19540 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19541 vec_free (if_name);
19549 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19551 if (fp->afi == IP46_TYPE_IP6)
19553 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19554 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19555 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19556 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19557 format_ip6_address, fp->next_hop);
19558 else if (fp->afi == IP46_TYPE_IP4)
19560 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19561 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19562 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19563 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19564 format_ip4_address, fp->next_hop);
19568 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19569 vl_api_fib_path2_t * fp)
19571 struct in_addr ip4;
19572 struct in6_addr ip6;
19574 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19575 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19576 vat_json_object_add_uint (node, "is_local", fp->is_local);
19577 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19578 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19579 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19580 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19581 if (fp->afi == IP46_TYPE_IP4)
19583 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19584 vat_json_object_add_ip4 (node, "next_hop", ip4);
19586 else if (fp->afi == IP46_TYPE_IP6)
19588 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19589 vat_json_object_add_ip6 (node, "next_hop", ip6);
19594 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19596 vat_main_t *vam = &vat_main;
19597 int count = ntohl (mp->mt_count);
19598 vl_api_fib_path2_t *fp;
19601 print (vam->ofp, "[%d]: sw_if_index %d via:",
19602 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19604 for (i = 0; i < count; i++)
19606 vl_api_mpls_fib_path_print (vam, fp);
19610 print (vam->ofp, "");
19613 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19614 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19617 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19619 vat_main_t *vam = &vat_main;
19620 vat_json_node_t *node = NULL;
19621 int count = ntohl (mp->mt_count);
19622 vl_api_fib_path2_t *fp;
19625 if (VAT_JSON_ARRAY != vam->json_tree.type)
19627 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19628 vat_json_init_array (&vam->json_tree);
19630 node = vat_json_array_add (&vam->json_tree);
19632 vat_json_init_object (node);
19633 vat_json_object_add_uint (node, "tunnel_index",
19634 ntohl (mp->mt_tunnel_index));
19635 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19637 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19640 for (i = 0; i < count; i++)
19642 vl_api_mpls_fib_path_json_print (node, fp);
19648 api_mpls_tunnel_dump (vat_main_t * vam)
19650 vl_api_mpls_tunnel_dump_t *mp;
19651 vl_api_control_ping_t *mp_ping;
19655 /* Parse args required to build the message */
19656 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19658 if (!unformat (vam->input, "tunnel_index %d", &index))
19665 print (vam->ofp, " tunnel_index %d", index);
19667 M (MPLS_TUNNEL_DUMP, mp);
19668 mp->tunnel_index = htonl (index);
19671 /* Use a control ping for synchronization */
19672 MPING (CONTROL_PING, mp_ping);
19679 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19680 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19684 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19686 vat_main_t *vam = &vat_main;
19687 int count = ntohl (mp->count);
19688 vl_api_fib_path2_t *fp;
19692 "table-id %d, label %u, ess_bit %u",
19693 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19695 for (i = 0; i < count; i++)
19697 vl_api_mpls_fib_path_print (vam, fp);
19702 static void vl_api_mpls_fib_details_t_handler_json
19703 (vl_api_mpls_fib_details_t * mp)
19705 vat_main_t *vam = &vat_main;
19706 int count = ntohl (mp->count);
19707 vat_json_node_t *node = NULL;
19708 vl_api_fib_path2_t *fp;
19711 if (VAT_JSON_ARRAY != vam->json_tree.type)
19713 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19714 vat_json_init_array (&vam->json_tree);
19716 node = vat_json_array_add (&vam->json_tree);
19718 vat_json_init_object (node);
19719 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19720 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19721 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19722 vat_json_object_add_uint (node, "path_count", count);
19724 for (i = 0; i < count; i++)
19726 vl_api_mpls_fib_path_json_print (node, fp);
19732 api_mpls_fib_dump (vat_main_t * vam)
19734 vl_api_mpls_fib_dump_t *mp;
19735 vl_api_control_ping_t *mp_ping;
19738 M (MPLS_FIB_DUMP, mp);
19741 /* Use a control ping for synchronization */
19742 MPING (CONTROL_PING, mp_ping);
19749 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19750 #define vl_api_ip_fib_details_t_print vl_noop_handler
19753 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19755 vat_main_t *vam = &vat_main;
19756 int count = ntohl (mp->count);
19757 vl_api_fib_path_t *fp;
19761 "table-id %d, prefix %U/%d",
19762 ntohl (mp->table_id), format_ip4_address, mp->address,
19763 mp->address_length);
19765 for (i = 0; i < count; i++)
19767 if (fp->afi == IP46_TYPE_IP6)
19769 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19770 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19771 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19772 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19773 format_ip6_address, fp->next_hop);
19774 else if (fp->afi == IP46_TYPE_IP4)
19776 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19777 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19778 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19779 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19780 format_ip4_address, fp->next_hop);
19785 static void vl_api_ip_fib_details_t_handler_json
19786 (vl_api_ip_fib_details_t * mp)
19788 vat_main_t *vam = &vat_main;
19789 int count = ntohl (mp->count);
19790 vat_json_node_t *node = NULL;
19791 struct in_addr ip4;
19792 struct in6_addr ip6;
19793 vl_api_fib_path_t *fp;
19796 if (VAT_JSON_ARRAY != vam->json_tree.type)
19798 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19799 vat_json_init_array (&vam->json_tree);
19801 node = vat_json_array_add (&vam->json_tree);
19803 vat_json_init_object (node);
19804 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19805 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19806 vat_json_object_add_ip4 (node, "prefix", ip4);
19807 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19808 vat_json_object_add_uint (node, "path_count", count);
19810 for (i = 0; i < count; i++)
19812 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19813 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19814 vat_json_object_add_uint (node, "is_local", fp->is_local);
19815 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19816 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19817 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19818 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19819 if (fp->afi == IP46_TYPE_IP4)
19821 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19822 vat_json_object_add_ip4 (node, "next_hop", ip4);
19824 else if (fp->afi == IP46_TYPE_IP6)
19826 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19827 vat_json_object_add_ip6 (node, "next_hop", ip6);
19833 api_ip_fib_dump (vat_main_t * vam)
19835 vl_api_ip_fib_dump_t *mp;
19836 vl_api_control_ping_t *mp_ping;
19839 M (IP_FIB_DUMP, mp);
19842 /* Use a control ping for synchronization */
19843 MPING (CONTROL_PING, mp_ping);
19851 api_ip_mfib_dump (vat_main_t * vam)
19853 vl_api_ip_mfib_dump_t *mp;
19854 vl_api_control_ping_t *mp_ping;
19857 M (IP_MFIB_DUMP, mp);
19860 /* Use a control ping for synchronization */
19861 MPING (CONTROL_PING, mp_ping);
19868 static void vl_api_ip_neighbor_details_t_handler
19869 (vl_api_ip_neighbor_details_t * mp)
19871 vat_main_t *vam = &vat_main;
19873 print (vam->ofp, "%c %U %U",
19874 (mp->is_static) ? 'S' : 'D',
19875 format_ethernet_address, &mp->mac_address,
19876 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19880 static void vl_api_ip_neighbor_details_t_handler_json
19881 (vl_api_ip_neighbor_details_t * mp)
19884 vat_main_t *vam = &vat_main;
19885 vat_json_node_t *node;
19886 struct in_addr ip4;
19887 struct in6_addr ip6;
19889 if (VAT_JSON_ARRAY != vam->json_tree.type)
19891 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19892 vat_json_init_array (&vam->json_tree);
19894 node = vat_json_array_add (&vam->json_tree);
19896 vat_json_init_object (node);
19897 vat_json_object_add_string_copy (node, "flag",
19898 (mp->is_static) ? (u8 *) "static" : (u8 *)
19901 vat_json_object_add_string_copy (node, "link_layer",
19902 format (0, "%U", format_ethernet_address,
19903 &mp->mac_address));
19907 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19908 vat_json_object_add_ip6 (node, "ip_address", ip6);
19912 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19913 vat_json_object_add_ip4 (node, "ip_address", ip4);
19918 api_ip_neighbor_dump (vat_main_t * vam)
19920 unformat_input_t *i = vam->input;
19921 vl_api_ip_neighbor_dump_t *mp;
19922 vl_api_control_ping_t *mp_ping;
19924 u32 sw_if_index = ~0;
19927 /* Parse args required to build the message */
19928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19930 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19932 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19934 else if (unformat (i, "ip6"))
19940 if (sw_if_index == ~0)
19942 errmsg ("missing interface name or sw_if_index");
19946 M (IP_NEIGHBOR_DUMP, mp);
19947 mp->is_ipv6 = (u8) is_ipv6;
19948 mp->sw_if_index = ntohl (sw_if_index);
19951 /* Use a control ping for synchronization */
19952 MPING (CONTROL_PING, mp_ping);
19959 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19960 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19963 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19965 vat_main_t *vam = &vat_main;
19966 int count = ntohl (mp->count);
19967 vl_api_fib_path_t *fp;
19971 "table-id %d, prefix %U/%d",
19972 ntohl (mp->table_id), format_ip6_address, mp->address,
19973 mp->address_length);
19975 for (i = 0; i < count; i++)
19977 if (fp->afi == IP46_TYPE_IP6)
19979 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19980 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19981 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19982 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19983 format_ip6_address, fp->next_hop);
19984 else if (fp->afi == IP46_TYPE_IP4)
19986 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19987 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19988 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19989 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19990 format_ip4_address, fp->next_hop);
19995 static void vl_api_ip6_fib_details_t_handler_json
19996 (vl_api_ip6_fib_details_t * mp)
19998 vat_main_t *vam = &vat_main;
19999 int count = ntohl (mp->count);
20000 vat_json_node_t *node = NULL;
20001 struct in_addr ip4;
20002 struct in6_addr ip6;
20003 vl_api_fib_path_t *fp;
20006 if (VAT_JSON_ARRAY != vam->json_tree.type)
20008 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20009 vat_json_init_array (&vam->json_tree);
20011 node = vat_json_array_add (&vam->json_tree);
20013 vat_json_init_object (node);
20014 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20015 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20016 vat_json_object_add_ip6 (node, "prefix", ip6);
20017 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20018 vat_json_object_add_uint (node, "path_count", count);
20020 for (i = 0; i < count; i++)
20022 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20023 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20024 vat_json_object_add_uint (node, "is_local", fp->is_local);
20025 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20026 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20027 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20028 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20029 if (fp->afi == IP46_TYPE_IP4)
20031 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20032 vat_json_object_add_ip4 (node, "next_hop", ip4);
20034 else if (fp->afi == IP46_TYPE_IP6)
20036 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20037 vat_json_object_add_ip6 (node, "next_hop", ip6);
20043 api_ip6_fib_dump (vat_main_t * vam)
20045 vl_api_ip6_fib_dump_t *mp;
20046 vl_api_control_ping_t *mp_ping;
20049 M (IP6_FIB_DUMP, mp);
20052 /* Use a control ping for synchronization */
20053 MPING (CONTROL_PING, mp_ping);
20061 api_ip6_mfib_dump (vat_main_t * vam)
20063 vl_api_ip6_mfib_dump_t *mp;
20064 vl_api_control_ping_t *mp_ping;
20067 M (IP6_MFIB_DUMP, mp);
20070 /* Use a control ping for synchronization */
20071 MPING (CONTROL_PING, mp_ping);
20079 api_classify_table_ids (vat_main_t * vam)
20081 vl_api_classify_table_ids_t *mp;
20084 /* Construct the API message */
20085 M (CLASSIFY_TABLE_IDS, mp);
20094 api_classify_table_by_interface (vat_main_t * vam)
20096 unformat_input_t *input = vam->input;
20097 vl_api_classify_table_by_interface_t *mp;
20099 u32 sw_if_index = ~0;
20101 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20103 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20105 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20110 if (sw_if_index == ~0)
20112 errmsg ("missing interface name or sw_if_index");
20116 /* Construct the API message */
20117 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20119 mp->sw_if_index = ntohl (sw_if_index);
20127 api_classify_table_info (vat_main_t * vam)
20129 unformat_input_t *input = vam->input;
20130 vl_api_classify_table_info_t *mp;
20134 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20136 if (unformat (input, "table_id %d", &table_id))
20141 if (table_id == ~0)
20143 errmsg ("missing table id");
20147 /* Construct the API message */
20148 M (CLASSIFY_TABLE_INFO, mp);
20150 mp->table_id = ntohl (table_id);
20158 api_classify_session_dump (vat_main_t * vam)
20160 unformat_input_t *input = vam->input;
20161 vl_api_classify_session_dump_t *mp;
20162 vl_api_control_ping_t *mp_ping;
20166 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20168 if (unformat (input, "table_id %d", &table_id))
20173 if (table_id == ~0)
20175 errmsg ("missing table id");
20179 /* Construct the API message */
20180 M (CLASSIFY_SESSION_DUMP, mp);
20182 mp->table_id = ntohl (table_id);
20185 /* Use a control ping for synchronization */
20186 MPING (CONTROL_PING, mp_ping);
20194 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20196 vat_main_t *vam = &vat_main;
20198 print (vam->ofp, "collector_address %U, collector_port %d, "
20199 "src_address %U, vrf_id %d, path_mtu %u, "
20200 "template_interval %u, udp_checksum %d",
20201 format_ip4_address, mp->collector_address,
20202 ntohs (mp->collector_port),
20203 format_ip4_address, mp->src_address,
20204 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20205 ntohl (mp->template_interval), mp->udp_checksum);
20208 vam->result_ready = 1;
20212 vl_api_ipfix_exporter_details_t_handler_json
20213 (vl_api_ipfix_exporter_details_t * mp)
20215 vat_main_t *vam = &vat_main;
20216 vat_json_node_t node;
20217 struct in_addr collector_address;
20218 struct in_addr src_address;
20220 vat_json_init_object (&node);
20221 clib_memcpy (&collector_address, &mp->collector_address,
20222 sizeof (collector_address));
20223 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20224 vat_json_object_add_uint (&node, "collector_port",
20225 ntohs (mp->collector_port));
20226 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20227 vat_json_object_add_ip4 (&node, "src_address", src_address);
20228 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20229 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20230 vat_json_object_add_uint (&node, "template_interval",
20231 ntohl (mp->template_interval));
20232 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20234 vat_json_print (vam->ofp, &node);
20235 vat_json_free (&node);
20237 vam->result_ready = 1;
20241 api_ipfix_exporter_dump (vat_main_t * vam)
20243 vl_api_ipfix_exporter_dump_t *mp;
20246 /* Construct the API message */
20247 M (IPFIX_EXPORTER_DUMP, mp);
20256 api_ipfix_classify_stream_dump (vat_main_t * vam)
20258 vl_api_ipfix_classify_stream_dump_t *mp;
20261 /* Construct the API message */
20262 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20273 vl_api_ipfix_classify_stream_details_t_handler
20274 (vl_api_ipfix_classify_stream_details_t * mp)
20276 vat_main_t *vam = &vat_main;
20277 print (vam->ofp, "domain_id %d, src_port %d",
20278 ntohl (mp->domain_id), ntohs (mp->src_port));
20280 vam->result_ready = 1;
20284 vl_api_ipfix_classify_stream_details_t_handler_json
20285 (vl_api_ipfix_classify_stream_details_t * mp)
20287 vat_main_t *vam = &vat_main;
20288 vat_json_node_t node;
20290 vat_json_init_object (&node);
20291 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20292 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20294 vat_json_print (vam->ofp, &node);
20295 vat_json_free (&node);
20297 vam->result_ready = 1;
20301 api_ipfix_classify_table_dump (vat_main_t * vam)
20303 vl_api_ipfix_classify_table_dump_t *mp;
20304 vl_api_control_ping_t *mp_ping;
20307 if (!vam->json_output)
20309 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20310 "transport_protocol");
20313 /* Construct the API message */
20314 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20319 /* Use a control ping for synchronization */
20320 MPING (CONTROL_PING, mp_ping);
20328 vl_api_ipfix_classify_table_details_t_handler
20329 (vl_api_ipfix_classify_table_details_t * mp)
20331 vat_main_t *vam = &vat_main;
20332 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20333 mp->transport_protocol);
20337 vl_api_ipfix_classify_table_details_t_handler_json
20338 (vl_api_ipfix_classify_table_details_t * mp)
20340 vat_json_node_t *node = NULL;
20341 vat_main_t *vam = &vat_main;
20343 if (VAT_JSON_ARRAY != vam->json_tree.type)
20345 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20346 vat_json_init_array (&vam->json_tree);
20349 node = vat_json_array_add (&vam->json_tree);
20350 vat_json_init_object (node);
20352 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20353 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20354 vat_json_object_add_uint (node, "transport_protocol",
20355 mp->transport_protocol);
20359 api_sw_interface_span_enable_disable (vat_main_t * vam)
20361 unformat_input_t *i = vam->input;
20362 vl_api_sw_interface_span_enable_disable_t *mp;
20363 u32 src_sw_if_index = ~0;
20364 u32 dst_sw_if_index = ~0;
20369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20372 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20374 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20378 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20380 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20382 else if (unformat (i, "disable"))
20384 else if (unformat (i, "rx"))
20386 else if (unformat (i, "tx"))
20388 else if (unformat (i, "both"))
20390 else if (unformat (i, "l2"))
20396 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20398 mp->sw_if_index_from = htonl (src_sw_if_index);
20399 mp->sw_if_index_to = htonl (dst_sw_if_index);
20409 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20412 vat_main_t *vam = &vat_main;
20413 u8 *sw_if_from_name = 0;
20414 u8 *sw_if_to_name = 0;
20415 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20416 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20417 char *states[] = { "none", "rx", "tx", "both" };
20421 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20423 if ((u32) p->value[0] == sw_if_index_from)
20425 sw_if_from_name = (u8 *)(p->key);
20429 if ((u32) p->value[0] == sw_if_index_to)
20431 sw_if_to_name = (u8 *)(p->key);
20432 if (sw_if_from_name)
20437 print (vam->ofp, "%20s => %20s (%s)",
20438 sw_if_from_name, sw_if_to_name, states[mp->state]);
20442 vl_api_sw_interface_span_details_t_handler_json
20443 (vl_api_sw_interface_span_details_t * mp)
20445 vat_main_t *vam = &vat_main;
20446 vat_json_node_t *node = NULL;
20447 u8 *sw_if_from_name = 0;
20448 u8 *sw_if_to_name = 0;
20449 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20450 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20454 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20456 if ((u32) p->value[0] == sw_if_index_from)
20458 sw_if_from_name = (u8 *)(p->key);
20462 if ((u32) p->value[0] == sw_if_index_to)
20464 sw_if_to_name = (u8 *)(p->key);
20465 if (sw_if_from_name)
20471 if (VAT_JSON_ARRAY != vam->json_tree.type)
20473 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20474 vat_json_init_array (&vam->json_tree);
20476 node = vat_json_array_add (&vam->json_tree);
20478 vat_json_init_object (node);
20479 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20480 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20481 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20482 if (0 != sw_if_to_name)
20484 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20486 vat_json_object_add_uint (node, "state", mp->state);
20490 api_sw_interface_span_dump (vat_main_t * vam)
20492 unformat_input_t *input = vam->input;
20493 vl_api_sw_interface_span_dump_t *mp;
20494 vl_api_control_ping_t *mp_ping;
20498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20500 if (unformat (input, "l2"))
20506 M (SW_INTERFACE_SPAN_DUMP, mp);
20510 /* Use a control ping for synchronization */
20511 MPING (CONTROL_PING, mp_ping);
20519 api_pg_create_interface (vat_main_t * vam)
20521 unformat_input_t *input = vam->input;
20522 vl_api_pg_create_interface_t *mp;
20526 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20528 if (unformat (input, "if_id %d", &if_id))
20535 errmsg ("missing pg interface index");
20539 /* Construct the API message */
20540 M (PG_CREATE_INTERFACE, mp);
20542 mp->interface_id = ntohl (if_id);
20550 api_pg_capture (vat_main_t * vam)
20552 unformat_input_t *input = vam->input;
20553 vl_api_pg_capture_t *mp;
20558 u8 pcap_file_set = 0;
20561 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20563 if (unformat (input, "if_id %d", &if_id))
20565 else if (unformat (input, "pcap %s", &pcap_file))
20567 else if (unformat (input, "count %d", &count))
20569 else if (unformat (input, "disable"))
20576 errmsg ("missing pg interface index");
20579 if (pcap_file_set > 0)
20581 if (vec_len (pcap_file) > 255)
20583 errmsg ("pcap file name is too long");
20588 u32 name_len = vec_len (pcap_file);
20589 /* Construct the API message */
20590 M (PG_CAPTURE, mp);
20592 mp->interface_id = ntohl (if_id);
20593 mp->is_enabled = enable;
20594 mp->count = ntohl (count);
20595 mp->pcap_name_length = ntohl (name_len);
20596 if (pcap_file_set != 0)
20598 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20600 vec_free (pcap_file);
20608 api_pg_enable_disable (vat_main_t * vam)
20610 unformat_input_t *input = vam->input;
20611 vl_api_pg_enable_disable_t *mp;
20614 u8 stream_name_set = 0;
20615 u8 *stream_name = 0;
20617 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20619 if (unformat (input, "stream %s", &stream_name))
20620 stream_name_set = 1;
20621 else if (unformat (input, "disable"))
20627 if (stream_name_set > 0)
20629 if (vec_len (stream_name) > 255)
20631 errmsg ("stream name too long");
20636 u32 name_len = vec_len (stream_name);
20637 /* Construct the API message */
20638 M (PG_ENABLE_DISABLE, mp);
20640 mp->is_enabled = enable;
20641 if (stream_name_set != 0)
20643 mp->stream_name_length = ntohl (name_len);
20644 clib_memcpy (mp->stream_name, stream_name, name_len);
20646 vec_free (stream_name);
20654 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20656 unformat_input_t *input = vam->input;
20657 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20659 u16 *low_ports = 0;
20660 u16 *high_ports = 0;
20663 ip4_address_t ip4_addr;
20664 ip6_address_t ip6_addr;
20673 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20675 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20681 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20686 else if (unformat (input, "vrf %d", &vrf_id))
20688 else if (unformat (input, "del"))
20690 else if (unformat (input, "port %d", &tmp))
20692 if (tmp == 0 || tmp > 65535)
20694 errmsg ("port %d out of range", tmp);
20698 this_hi = this_low + 1;
20699 vec_add1 (low_ports, this_low);
20700 vec_add1 (high_ports, this_hi);
20702 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20704 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20706 errmsg ("incorrect range parameters");
20710 /* Note: in debug CLI +1 is added to high before
20711 passing to real fn that does "the work"
20712 (ip_source_and_port_range_check_add_del).
20713 This fn is a wrapper around the binary API fn a
20714 control plane will call, which expects this increment
20715 to have occurred. Hence letting the binary API control
20716 plane fn do the increment for consistency between VAT
20717 and other control planes.
20720 vec_add1 (low_ports, this_low);
20721 vec_add1 (high_ports, this_hi);
20727 if (prefix_set == 0)
20729 errmsg ("<address>/<mask> not specified");
20735 errmsg ("VRF ID required, not specified");
20742 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20746 if (vec_len (low_ports) == 0)
20748 errmsg ("At least one port or port range required");
20752 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20754 mp->is_add = is_add;
20759 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20764 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20767 mp->mask_length = length;
20768 mp->number_of_ranges = vec_len (low_ports);
20770 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20771 vec_free (low_ports);
20773 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20774 vec_free (high_ports);
20776 mp->vrf_id = ntohl (vrf_id);
20784 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20786 unformat_input_t *input = vam->input;
20787 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20788 u32 sw_if_index = ~0;
20790 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20791 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20795 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20797 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20799 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20801 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20803 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20805 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20807 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20809 else if (unformat (input, "del"))
20815 if (sw_if_index == ~0)
20817 errmsg ("Interface required but not specified");
20823 errmsg ("VRF ID required but not specified");
20827 if (tcp_out_vrf_id == 0
20828 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20831 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20835 /* Construct the API message */
20836 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20838 mp->sw_if_index = ntohl (sw_if_index);
20839 mp->is_add = is_add;
20840 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20841 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20842 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20843 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20848 /* Wait for a reply... */
20854 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20856 unformat_input_t *i = vam->input;
20857 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20858 u32 local_sa_id = 0;
20859 u32 remote_sa_id = 0;
20860 ip4_address_t src_address;
20861 ip4_address_t dst_address;
20865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20867 if (unformat (i, "local_sa %d", &local_sa_id))
20869 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20871 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20873 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20875 else if (unformat (i, "del"))
20879 clib_warning ("parse error '%U'", format_unformat_error, i);
20884 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20886 mp->local_sa_id = ntohl (local_sa_id);
20887 mp->remote_sa_id = ntohl (remote_sa_id);
20888 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20889 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20890 mp->is_add = is_add;
20898 api_punt (vat_main_t * vam)
20900 unformat_input_t *i = vam->input;
20908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20910 if (unformat (i, "ip %d", &ipv))
20912 else if (unformat (i, "protocol %d", &protocol))
20914 else if (unformat (i, "port %d", &port))
20916 else if (unformat (i, "del"))
20920 clib_warning ("parse error '%U'", format_unformat_error, i);
20927 mp->is_add = (u8) is_add;
20928 mp->ipv = (u8) ipv;
20929 mp->l4_protocol = (u8) protocol;
20930 mp->l4_port = htons ((u16) port);
20937 static void vl_api_ipsec_gre_tunnel_details_t_handler
20938 (vl_api_ipsec_gre_tunnel_details_t * mp)
20940 vat_main_t *vam = &vat_main;
20942 print (vam->ofp, "%11d%15U%15U%14d%14d",
20943 ntohl (mp->sw_if_index),
20944 format_ip4_address, &mp->src_address,
20945 format_ip4_address, &mp->dst_address,
20946 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20949 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20950 (vl_api_ipsec_gre_tunnel_details_t * mp)
20952 vat_main_t *vam = &vat_main;
20953 vat_json_node_t *node = NULL;
20954 struct in_addr ip4;
20956 if (VAT_JSON_ARRAY != vam->json_tree.type)
20958 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20959 vat_json_init_array (&vam->json_tree);
20961 node = vat_json_array_add (&vam->json_tree);
20963 vat_json_init_object (node);
20964 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20965 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20966 vat_json_object_add_ip4 (node, "src_address", ip4);
20967 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20968 vat_json_object_add_ip4 (node, "dst_address", ip4);
20969 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20970 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20974 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20976 unformat_input_t *i = vam->input;
20977 vl_api_ipsec_gre_tunnel_dump_t *mp;
20978 vl_api_control_ping_t *mp_ping;
20980 u8 sw_if_index_set = 0;
20983 /* Parse args required to build the message */
20984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20986 if (unformat (i, "sw_if_index %d", &sw_if_index))
20987 sw_if_index_set = 1;
20992 if (sw_if_index_set == 0)
20997 if (!vam->json_output)
20999 print (vam->ofp, "%11s%15s%15s%14s%14s",
21000 "sw_if_index", "src_address", "dst_address",
21001 "local_sa_id", "remote_sa_id");
21004 /* Get list of gre-tunnel interfaces */
21005 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21007 mp->sw_if_index = htonl (sw_if_index);
21011 /* Use a control ping for synchronization */
21012 MPING (CONTROL_PING, mp_ping);
21020 api_delete_subif (vat_main_t * vam)
21022 unformat_input_t *i = vam->input;
21023 vl_api_delete_subif_t *mp;
21024 u32 sw_if_index = ~0;
21027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21029 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21031 if (unformat (i, "sw_if_index %d", &sw_if_index))
21037 if (sw_if_index == ~0)
21039 errmsg ("missing sw_if_index");
21043 /* Construct the API message */
21044 M (DELETE_SUBIF, mp);
21045 mp->sw_if_index = ntohl (sw_if_index);
21052 #define foreach_pbb_vtr_op \
21053 _("disable", L2_VTR_DISABLED) \
21054 _("pop", L2_VTR_POP_2) \
21055 _("push", L2_VTR_PUSH_2)
21058 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21060 unformat_input_t *i = vam->input;
21061 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21062 u32 sw_if_index = ~0, vtr_op = ~0;
21063 u16 outer_tag = ~0;
21064 u8 dmac[6], smac[6];
21065 u8 dmac_set = 0, smac_set = 0;
21071 /* Shut up coverity */
21072 memset (dmac, 0, sizeof (dmac));
21073 memset (smac, 0, sizeof (smac));
21075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21077 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21081 else if (unformat (i, "vtr_op %d", &vtr_op))
21083 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21086 else if (unformat (i, "translate_pbb_stag"))
21088 if (unformat (i, "%d", &tmp))
21090 vtr_op = L2_VTR_TRANSLATE_2_1;
21096 ("translate_pbb_stag operation requires outer tag definition");
21100 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21102 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21104 else if (unformat (i, "sid %d", &sid))
21106 else if (unformat (i, "vlanid %d", &tmp))
21110 clib_warning ("parse error '%U'", format_unformat_error, i);
21115 if ((sw_if_index == ~0) || (vtr_op == ~0))
21117 errmsg ("missing sw_if_index or vtr operation");
21120 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21121 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21124 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21128 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21129 mp->sw_if_index = ntohl (sw_if_index);
21130 mp->vtr_op = ntohl (vtr_op);
21131 mp->outer_tag = ntohs (outer_tag);
21132 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21133 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21134 mp->b_vlanid = ntohs (vlanid);
21135 mp->i_sid = ntohl (sid);
21143 api_flow_classify_set_interface (vat_main_t * vam)
21145 unformat_input_t *i = vam->input;
21146 vl_api_flow_classify_set_interface_t *mp;
21148 int sw_if_index_set;
21149 u32 ip4_table_index = ~0;
21150 u32 ip6_table_index = ~0;
21154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21156 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21157 sw_if_index_set = 1;
21158 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21159 sw_if_index_set = 1;
21160 else if (unformat (i, "del"))
21162 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21164 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21168 clib_warning ("parse error '%U'", format_unformat_error, i);
21173 if (sw_if_index_set == 0)
21175 errmsg ("missing interface name or sw_if_index");
21179 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21181 mp->sw_if_index = ntohl (sw_if_index);
21182 mp->ip4_table_index = ntohl (ip4_table_index);
21183 mp->ip6_table_index = ntohl (ip6_table_index);
21184 mp->is_add = is_add;
21192 api_flow_classify_dump (vat_main_t * vam)
21194 unformat_input_t *i = vam->input;
21195 vl_api_flow_classify_dump_t *mp;
21196 vl_api_control_ping_t *mp_ping;
21197 u8 type = FLOW_CLASSIFY_N_TABLES;
21200 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21204 errmsg ("classify table type must be specified");
21208 if (!vam->json_output)
21210 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21213 M (FLOW_CLASSIFY_DUMP, mp);
21218 /* Use a control ping for synchronization */
21219 MPING (CONTROL_PING, mp_ping);
21222 /* Wait for a reply... */
21228 api_feature_enable_disable (vat_main_t * vam)
21230 unformat_input_t *i = vam->input;
21231 vl_api_feature_enable_disable_t *mp;
21233 u8 *feature_name = 0;
21234 u32 sw_if_index = ~0;
21238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21240 if (unformat (i, "arc_name %s", &arc_name))
21242 else if (unformat (i, "feature_name %s", &feature_name))
21245 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21247 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21249 else if (unformat (i, "disable"))
21257 errmsg ("missing arc name");
21260 if (vec_len (arc_name) > 63)
21262 errmsg ("arc name too long");
21265 if (feature_name == 0)
21267 errmsg ("missing feature name");
21270 if (vec_len (feature_name) > 63)
21272 errmsg ("feature name too long");
21275 if (sw_if_index == ~0)
21277 errmsg ("missing interface name or sw_if_index");
21281 /* Construct the API message */
21282 M (FEATURE_ENABLE_DISABLE, mp);
21283 mp->sw_if_index = ntohl (sw_if_index);
21284 mp->enable = enable;
21285 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21286 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21287 vec_free (arc_name);
21288 vec_free (feature_name);
21296 api_sw_interface_tag_add_del (vat_main_t * vam)
21298 unformat_input_t *i = vam->input;
21299 vl_api_sw_interface_tag_add_del_t *mp;
21300 u32 sw_if_index = ~0;
21305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21307 if (unformat (i, "tag %s", &tag))
21309 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21311 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21313 else if (unformat (i, "del"))
21319 if (sw_if_index == ~0)
21321 errmsg ("missing interface name or sw_if_index");
21325 if (enable && (tag == 0))
21327 errmsg ("no tag specified");
21331 /* Construct the API message */
21332 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21333 mp->sw_if_index = ntohl (sw_if_index);
21334 mp->is_add = enable;
21336 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21344 static void vl_api_l2_xconnect_details_t_handler
21345 (vl_api_l2_xconnect_details_t * mp)
21347 vat_main_t *vam = &vat_main;
21349 print (vam->ofp, "%15d%15d",
21350 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21353 static void vl_api_l2_xconnect_details_t_handler_json
21354 (vl_api_l2_xconnect_details_t * mp)
21356 vat_main_t *vam = &vat_main;
21357 vat_json_node_t *node = NULL;
21359 if (VAT_JSON_ARRAY != vam->json_tree.type)
21361 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21362 vat_json_init_array (&vam->json_tree);
21364 node = vat_json_array_add (&vam->json_tree);
21366 vat_json_init_object (node);
21367 vat_json_object_add_uint (node, "rx_sw_if_index",
21368 ntohl (mp->rx_sw_if_index));
21369 vat_json_object_add_uint (node, "tx_sw_if_index",
21370 ntohl (mp->tx_sw_if_index));
21374 api_l2_xconnect_dump (vat_main_t * vam)
21376 vl_api_l2_xconnect_dump_t *mp;
21377 vl_api_control_ping_t *mp_ping;
21380 if (!vam->json_output)
21382 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21385 M (L2_XCONNECT_DUMP, mp);
21389 /* Use a control ping for synchronization */
21390 MPING (CONTROL_PING, mp_ping);
21398 api_sw_interface_set_mtu (vat_main_t * vam)
21400 unformat_input_t *i = vam->input;
21401 vl_api_sw_interface_set_mtu_t *mp;
21402 u32 sw_if_index = ~0;
21406 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21408 if (unformat (i, "mtu %d", &mtu))
21410 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21412 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21418 if (sw_if_index == ~0)
21420 errmsg ("missing interface name or sw_if_index");
21426 errmsg ("no mtu specified");
21430 /* Construct the API message */
21431 M (SW_INTERFACE_SET_MTU, mp);
21432 mp->sw_if_index = ntohl (sw_if_index);
21433 mp->mtu = ntohs ((u16) mtu);
21441 api_p2p_ethernet_add (vat_main_t * vam)
21443 unformat_input_t *i = vam->input;
21444 vl_api_p2p_ethernet_add_t *mp;
21445 u32 parent_if_index = ~0;
21451 memset (remote_mac, 0, sizeof (remote_mac));
21452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21454 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21456 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21460 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21462 else if (unformat (i, "sub_id %d", &sub_id))
21466 clib_warning ("parse error '%U'", format_unformat_error, i);
21471 if (parent_if_index == ~0)
21473 errmsg ("missing interface name or sw_if_index");
21478 errmsg ("missing remote mac address");
21483 errmsg ("missing sub-interface id");
21487 M (P2P_ETHERNET_ADD, mp);
21488 mp->parent_if_index = ntohl (parent_if_index);
21489 mp->subif_id = ntohl (sub_id);
21490 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21498 api_p2p_ethernet_del (vat_main_t * vam)
21500 unformat_input_t *i = vam->input;
21501 vl_api_p2p_ethernet_del_t *mp;
21502 u32 parent_if_index = ~0;
21507 memset (remote_mac, 0, sizeof (remote_mac));
21508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21510 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21512 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21516 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21520 clib_warning ("parse error '%U'", format_unformat_error, i);
21525 if (parent_if_index == ~0)
21527 errmsg ("missing interface name or sw_if_index");
21532 errmsg ("missing remote mac address");
21536 M (P2P_ETHERNET_DEL, mp);
21537 mp->parent_if_index = ntohl (parent_if_index);
21538 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21546 api_lldp_config (vat_main_t * vam)
21548 unformat_input_t *i = vam->input;
21549 vl_api_lldp_config_t *mp;
21551 int tx_interval = 0;
21552 u8 *sys_name = NULL;
21555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21557 if (unformat (i, "system-name %s", &sys_name))
21559 else if (unformat (i, "tx-hold %d", &tx_hold))
21561 else if (unformat (i, "tx-interval %d", &tx_interval))
21565 clib_warning ("parse error '%U'", format_unformat_error, i);
21570 vec_add1 (sys_name, 0);
21572 M (LLDP_CONFIG, mp);
21573 mp->tx_hold = htonl (tx_hold);
21574 mp->tx_interval = htonl (tx_interval);
21575 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21576 vec_free (sys_name);
21584 api_sw_interface_set_lldp (vat_main_t * vam)
21586 unformat_input_t *i = vam->input;
21587 vl_api_sw_interface_set_lldp_t *mp;
21588 u32 sw_if_index = ~0;
21590 u8 *port_desc = NULL, *mgmt_oid = NULL;
21591 ip4_address_t ip4_addr;
21592 ip6_address_t ip6_addr;
21595 memset (&ip4_addr, 0, sizeof (ip4_addr));
21596 memset (&ip6_addr, 0, sizeof (ip6_addr));
21598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21600 if (unformat (i, "disable"))
21603 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21605 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21607 else if (unformat (i, "port-desc %s", &port_desc))
21609 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21611 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21613 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21619 if (sw_if_index == ~0)
21621 errmsg ("missing interface name or sw_if_index");
21625 /* Construct the API message */
21626 vec_add1 (port_desc, 0);
21627 vec_add1 (mgmt_oid, 0);
21628 M (SW_INTERFACE_SET_LLDP, mp);
21629 mp->sw_if_index = ntohl (sw_if_index);
21630 mp->enable = enable;
21631 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21632 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21633 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21634 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21635 vec_free (port_desc);
21636 vec_free (mgmt_oid);
21644 api_tcp_configure_src_addresses (vat_main_t * vam)
21646 vl_api_tcp_configure_src_addresses_t *mp;
21647 unformat_input_t *i = vam->input;
21648 ip4_address_t v4first, v4last;
21649 ip6_address_t v6first, v6last;
21654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21656 if (unformat (i, "%U - %U",
21657 unformat_ip4_address, &v4first,
21658 unformat_ip4_address, &v4last))
21662 errmsg ("one range per message (range already set)");
21667 else if (unformat (i, "%U - %U",
21668 unformat_ip6_address, &v6first,
21669 unformat_ip6_address, &v6last))
21673 errmsg ("one range per message (range already set)");
21678 else if (unformat (i, "vrf %d", &vrf_id))
21684 if (range_set == 0)
21686 errmsg ("address range not set");
21690 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21691 mp->vrf_id = ntohl (vrf_id);
21693 if (range_set == 2)
21696 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21697 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21702 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21703 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21710 static void vl_api_app_namespace_add_del_reply_t_handler
21711 (vl_api_app_namespace_add_del_reply_t * mp)
21713 vat_main_t *vam = &vat_main;
21714 i32 retval = ntohl (mp->retval);
21715 if (vam->async_mode)
21717 vam->async_errors += (retval < 0);
21721 vam->retval = retval;
21723 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21724 vam->result_ready = 1;
21728 static void vl_api_app_namespace_add_del_reply_t_handler_json
21729 (vl_api_app_namespace_add_del_reply_t * mp)
21731 vat_main_t *vam = &vat_main;
21732 vat_json_node_t node;
21734 vat_json_init_object (&node);
21735 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21736 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21738 vat_json_print (vam->ofp, &node);
21739 vat_json_free (&node);
21741 vam->retval = ntohl (mp->retval);
21742 vam->result_ready = 1;
21746 api_app_namespace_add_del (vat_main_t * vam)
21748 vl_api_app_namespace_add_del_t *mp;
21749 unformat_input_t *i = vam->input;
21750 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21751 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21757 if (unformat (i, "id %_%v%_", &ns_id))
21759 else if (unformat (i, "secret %lu", &secret))
21761 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21762 sw_if_index_set = 1;
21763 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21765 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21770 if (!ns_id || !secret_set || !sw_if_index_set)
21772 errmsg ("namespace id, secret and sw_if_index must be set");
21775 if (vec_len (ns_id) > 64)
21777 errmsg ("namespace id too long");
21780 M (APP_NAMESPACE_ADD_DEL, mp);
21782 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21783 mp->namespace_id_len = vec_len (ns_id);
21784 mp->secret = clib_host_to_net_u64 (secret);
21785 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21786 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21787 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21795 api_memfd_segment_create (vat_main_t * vam)
21797 #if VPP_API_TEST_BUILTIN == 0
21798 unformat_input_t *i = vam->input;
21799 vl_api_memfd_segment_create_t *mp;
21800 u64 size = 64 << 20;
21803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21805 if (unformat (i, "size %U", unformat_memory_size, &size))
21811 M (MEMFD_SEGMENT_CREATE, mp);
21812 mp->requested_size = size;
21818 errmsg ("memfd_segment_create (builtin) not supported");
21824 api_sock_init_shm (vat_main_t * vam)
21826 #if VPP_API_TEST_BUILTIN == 0
21827 unformat_input_t *i = vam->input;
21828 vl_api_shm_elem_config_t *config = 0;
21829 u64 size = 64 << 20;
21832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21834 if (unformat (i, "size %U", unformat_memory_size, &size))
21840 /* Try customized config to see if it works */
21841 vec_validate (config, 3);
21842 config[0].type = VL_API_VLIB_RING;
21843 config[0].count = 256;
21844 config[0].size = 256;
21845 config[1].type = VL_API_CLIENT_RING;
21846 config[1].count = 256;
21847 config[1].size = 1024;
21848 config[2].type = VL_API_CLIENT_RING;
21849 config[2].count = 8;
21850 config[2].size = 4096;
21851 config[3].type = VL_API_QUEUE;
21852 config[3].count = 256;
21853 config[3].size = sizeof (uword);
21854 rv = vl_socket_client_init_shm (config);
21856 vam->client_index_invalid = 1;
21864 api_dns_enable_disable (vat_main_t * vam)
21866 unformat_input_t *line_input = vam->input;
21867 vl_api_dns_enable_disable_t *mp;
21868 u8 enable_disable = 1;
21871 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21873 if (unformat (line_input, "disable"))
21874 enable_disable = 0;
21875 if (unformat (line_input, "enable"))
21876 enable_disable = 1;
21881 /* Construct the API message */
21882 M (DNS_ENABLE_DISABLE, mp);
21883 mp->enable = enable_disable;
21887 /* Wait for the reply */
21893 api_dns_resolve_name (vat_main_t * vam)
21895 unformat_input_t *line_input = vam->input;
21896 vl_api_dns_resolve_name_t *mp;
21900 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21902 if (unformat (line_input, "%s", &name))
21908 if (vec_len (name) > 127)
21910 errmsg ("name too long");
21914 /* Construct the API message */
21915 M (DNS_RESOLVE_NAME, mp);
21916 memcpy (mp->name, name, vec_len (name));
21921 /* Wait for the reply */
21927 api_dns_resolve_ip (vat_main_t * vam)
21929 unformat_input_t *line_input = vam->input;
21930 vl_api_dns_resolve_ip_t *mp;
21932 ip4_address_t addr4;
21933 ip6_address_t addr6;
21936 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21938 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21940 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21948 errmsg ("missing address");
21952 /* Construct the API message */
21953 M (DNS_RESOLVE_IP, mp);
21954 mp->is_ip6 = is_ip6;
21956 memcpy (mp->address, &addr6, sizeof (addr6));
21958 memcpy (mp->address, &addr4, sizeof (addr4));
21962 /* Wait for the reply */
21968 api_dns_name_server_add_del (vat_main_t * vam)
21970 unformat_input_t *i = vam->input;
21971 vl_api_dns_name_server_add_del_t *mp;
21973 ip6_address_t ip6_server;
21974 ip4_address_t ip4_server;
21979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21981 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21983 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21985 else if (unformat (i, "del"))
21989 clib_warning ("parse error '%U'", format_unformat_error, i);
21994 if (ip4_set && ip6_set)
21996 errmsg ("Only one server address allowed per message");
21999 if ((ip4_set + ip6_set) == 0)
22001 errmsg ("Server address required");
22005 /* Construct the API message */
22006 M (DNS_NAME_SERVER_ADD_DEL, mp);
22010 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22015 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22019 mp->is_add = is_add;
22024 /* Wait for a reply, return good/bad news */
22030 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22032 vat_main_t *vam = &vat_main;
22037 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22038 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22039 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22040 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22041 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22042 clib_net_to_host_u32 (mp->action_index), mp->tag);
22047 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22048 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22049 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22050 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22051 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22052 clib_net_to_host_u32 (mp->action_index), mp->tag);
22057 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22060 vat_main_t *vam = &vat_main;
22061 vat_json_node_t *node = NULL;
22062 struct in6_addr ip6;
22063 struct in_addr ip4;
22065 if (VAT_JSON_ARRAY != vam->json_tree.type)
22067 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22068 vat_json_init_array (&vam->json_tree);
22070 node = vat_json_array_add (&vam->json_tree);
22071 vat_json_init_object (node);
22073 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22074 vat_json_object_add_uint (node, "appns_index",
22075 clib_net_to_host_u32 (mp->appns_index));
22076 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22077 vat_json_object_add_uint (node, "scope", mp->scope);
22078 vat_json_object_add_uint (node, "action_index",
22079 clib_net_to_host_u32 (mp->action_index));
22080 vat_json_object_add_uint (node, "lcl_port",
22081 clib_net_to_host_u16 (mp->lcl_port));
22082 vat_json_object_add_uint (node, "rmt_port",
22083 clib_net_to_host_u16 (mp->rmt_port));
22084 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22085 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22086 vat_json_object_add_string_copy (node, "tag", mp->tag);
22089 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22090 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22091 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22092 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22096 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22097 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22098 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22099 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22104 api_session_rule_add_del (vat_main_t * vam)
22106 vl_api_session_rule_add_del_t *mp;
22107 unformat_input_t *i = vam->input;
22108 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22109 u32 appns_index = 0, scope = 0;
22110 ip4_address_t lcl_ip4, rmt_ip4;
22111 ip6_address_t lcl_ip6, rmt_ip6;
22112 u8 is_ip4 = 1, conn_set = 0;
22113 u8 is_add = 1, *tag = 0;
22116 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22118 if (unformat (i, "del"))
22120 else if (unformat (i, "add"))
22122 else if (unformat (i, "proto tcp"))
22124 else if (unformat (i, "proto udp"))
22126 else if (unformat (i, "appns %d", &appns_index))
22128 else if (unformat (i, "scope %d", &scope))
22130 else if (unformat (i, "tag %_%v%_", &tag))
22134 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22135 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22143 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22144 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22150 else if (unformat (i, "action %d", &action))
22155 if (proto == ~0 || !conn_set || action == ~0)
22157 errmsg ("transport proto, connection and action must be set");
22163 errmsg ("scope should be 0-3");
22167 M (SESSION_RULE_ADD_DEL, mp);
22169 mp->is_ip4 = is_ip4;
22170 mp->transport_proto = proto;
22171 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22172 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22173 mp->lcl_plen = lcl_plen;
22174 mp->rmt_plen = rmt_plen;
22175 mp->action_index = clib_host_to_net_u32 (action);
22176 mp->appns_index = clib_host_to_net_u32 (appns_index);
22178 mp->is_add = is_add;
22181 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22182 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22186 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22187 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22191 clib_memcpy (mp->tag, tag, vec_len (tag));
22201 api_session_rules_dump (vat_main_t * vam)
22203 vl_api_session_rules_dump_t *mp;
22204 vl_api_control_ping_t *mp_ping;
22207 if (!vam->json_output)
22209 print (vam->ofp, "%=20s", "Session Rules");
22212 M (SESSION_RULES_DUMP, mp);
22216 /* Use a control ping for synchronization */
22217 MPING (CONTROL_PING, mp_ping);
22220 /* Wait for a reply... */
22226 api_ip_container_proxy_add_del (vat_main_t * vam)
22228 vl_api_ip_container_proxy_add_del_t *mp;
22229 unformat_input_t *i = vam->input;
22230 u32 plen = ~0, sw_if_index = ~0;
22237 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22239 if (unformat (i, "del"))
22241 else if (unformat (i, "add"))
22243 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22248 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22253 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22258 if (sw_if_index == ~0 || plen == ~0)
22260 errmsg ("address and sw_if_index must be set");
22264 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22266 mp->is_ip4 = is_ip4;
22267 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22269 mp->is_add = is_add;
22271 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22273 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22281 q_or_quit (vat_main_t * vam)
22283 #if VPP_API_TEST_BUILTIN == 0
22284 longjmp (vam->jump_buf, 1);
22286 return 0; /* not so much */
22290 q (vat_main_t * vam)
22292 return q_or_quit (vam);
22296 quit (vat_main_t * vam)
22298 return q_or_quit (vam);
22302 comment (vat_main_t * vam)
22308 cmd_cmp (void *a1, void *a2)
22313 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22317 help (vat_main_t * vam)
22322 unformat_input_t *i = vam->input;
22325 if (unformat (i, "%s", &name))
22329 vec_add1 (name, 0);
22331 hs = hash_get_mem (vam->help_by_name, name);
22333 print (vam->ofp, "usage: %s %s", name, hs[0]);
22335 print (vam->ofp, "No such msg / command '%s'", name);
22340 print (vam->ofp, "Help is available for the following:");
22343 hash_foreach_pair (p, vam->function_by_name,
22345 vec_add1 (cmds, (u8 *)(p->key));
22349 vec_sort_with_function (cmds, cmd_cmp);
22351 for (j = 0; j < vec_len (cmds); j++)
22352 print (vam->ofp, "%s", cmds[j]);
22359 set (vat_main_t * vam)
22361 u8 *name = 0, *value = 0;
22362 unformat_input_t *i = vam->input;
22364 if (unformat (i, "%s", &name))
22366 /* The input buffer is a vector, not a string. */
22367 value = vec_dup (i->buffer);
22368 vec_delete (value, i->index, 0);
22369 /* Almost certainly has a trailing newline */
22370 if (value[vec_len (value) - 1] == '\n')
22371 value[vec_len (value) - 1] = 0;
22372 /* Make sure it's a proper string, one way or the other */
22373 vec_add1 (value, 0);
22374 (void) clib_macro_set_value (&vam->macro_main,
22375 (char *) name, (char *) value);
22378 errmsg ("usage: set <name> <value>");
22386 unset (vat_main_t * vam)
22390 if (unformat (vam->input, "%s", &name))
22391 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22392 errmsg ("unset: %s wasn't set", name);
22405 macro_sort_cmp (void *a1, void *a2)
22407 macro_sort_t *s1 = a1;
22408 macro_sort_t *s2 = a2;
22410 return strcmp ((char *) (s1->name), (char *) (s2->name));
22414 dump_macro_table (vat_main_t * vam)
22416 macro_sort_t *sort_me = 0, *sm;
22421 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22423 vec_add2 (sort_me, sm, 1);
22424 sm->name = (u8 *)(p->key);
22425 sm->value = (u8 *) (p->value[0]);
22429 vec_sort_with_function (sort_me, macro_sort_cmp);
22431 if (vec_len (sort_me))
22432 print (vam->ofp, "%-15s%s", "Name", "Value");
22434 print (vam->ofp, "The macro table is empty...");
22436 for (i = 0; i < vec_len (sort_me); i++)
22437 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22442 dump_node_table (vat_main_t * vam)
22445 vlib_node_t *node, *next_node;
22447 if (vec_len (vam->graph_nodes) == 0)
22449 print (vam->ofp, "Node table empty, issue get_node_graph...");
22453 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22455 node = vam->graph_nodes[i];
22456 print (vam->ofp, "[%d] %s", i, node->name);
22457 for (j = 0; j < vec_len (node->next_nodes); j++)
22459 if (node->next_nodes[j] != ~0)
22461 next_node = vam->graph_nodes[node->next_nodes[j]];
22462 print (vam->ofp, " [%d] %s", j, next_node->name);
22470 value_sort_cmp (void *a1, void *a2)
22472 name_sort_t *n1 = a1;
22473 name_sort_t *n2 = a2;
22475 if (n1->value < n2->value)
22477 if (n1->value > n2->value)
22484 dump_msg_api_table (vat_main_t * vam)
22486 api_main_t *am = &api_main;
22487 name_sort_t *nses = 0, *ns;
22492 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22494 vec_add2 (nses, ns, 1);
22495 ns->name = (u8 *)(hp->key);
22496 ns->value = (u32) hp->value[0];
22500 vec_sort_with_function (nses, value_sort_cmp);
22502 for (i = 0; i < vec_len (nses); i++)
22503 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22509 get_msg_id (vat_main_t * vam)
22514 if (unformat (vam->input, "%s", &name_and_crc))
22516 message_index = vl_msg_api_get_msg_index (name_and_crc);
22517 if (message_index == ~0)
22519 print (vam->ofp, " '%s' not found", name_and_crc);
22522 print (vam->ofp, " '%s' has message index %d",
22523 name_and_crc, message_index);
22526 errmsg ("name_and_crc required...");
22531 search_node_table (vat_main_t * vam)
22533 unformat_input_t *line_input = vam->input;
22536 vlib_node_t *node, *next_node;
22539 if (vam->graph_node_index_by_name == 0)
22541 print (vam->ofp, "Node table empty, issue get_node_graph...");
22545 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22547 if (unformat (line_input, "%s", &node_to_find))
22549 vec_add1 (node_to_find, 0);
22550 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22553 print (vam->ofp, "%s not found...", node_to_find);
22556 node = vam->graph_nodes[p[0]];
22557 print (vam->ofp, "[%d] %s", p[0], node->name);
22558 for (j = 0; j < vec_len (node->next_nodes); j++)
22560 if (node->next_nodes[j] != ~0)
22562 next_node = vam->graph_nodes[node->next_nodes[j]];
22563 print (vam->ofp, " [%d] %s", j, next_node->name);
22570 clib_warning ("parse error '%U'", format_unformat_error,
22576 vec_free (node_to_find);
22585 script (vat_main_t * vam)
22587 #if (VPP_API_TEST_BUILTIN==0)
22589 char *save_current_file;
22590 unformat_input_t save_input;
22591 jmp_buf save_jump_buf;
22592 u32 save_line_number;
22594 FILE *new_fp, *save_ifp;
22596 if (unformat (vam->input, "%s", &s))
22598 new_fp = fopen ((char *) s, "r");
22601 errmsg ("Couldn't open script file %s", s);
22608 errmsg ("Missing script name");
22612 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22613 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22614 save_ifp = vam->ifp;
22615 save_line_number = vam->input_line_number;
22616 save_current_file = (char *) vam->current_file;
22618 vam->input_line_number = 0;
22620 vam->current_file = s;
22623 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22624 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22625 vam->ifp = save_ifp;
22626 vam->input_line_number = save_line_number;
22627 vam->current_file = (u8 *) save_current_file;
22632 clib_warning ("use the exec command...");
22638 echo (vat_main_t * vam)
22640 print (vam->ofp, "%v", vam->input->buffer);
22644 /* List of API message constructors, CLI names map to api_xxx */
22645 #define foreach_vpe_api_msg \
22646 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22647 _(sw_interface_dump,"") \
22648 _(sw_interface_set_flags, \
22649 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22650 _(sw_interface_add_del_address, \
22651 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22652 _(sw_interface_set_rx_mode, \
22653 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22654 _(sw_interface_set_table, \
22655 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22656 _(sw_interface_set_mpls_enable, \
22657 "<intfc> | sw_if_index [disable | dis]") \
22658 _(sw_interface_set_vpath, \
22659 "<intfc> | sw_if_index <id> enable | disable") \
22660 _(sw_interface_set_vxlan_bypass, \
22661 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22662 _(sw_interface_set_geneve_bypass, \
22663 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22664 _(sw_interface_set_l2_xconnect, \
22665 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22666 "enable | disable") \
22667 _(sw_interface_set_l2_bridge, \
22668 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22669 "[shg <split-horizon-group>] [bvi]\n" \
22670 "enable | disable") \
22671 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22672 _(bridge_domain_add_del, \
22673 "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") \
22674 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22676 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22677 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22678 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22680 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22682 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22684 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22686 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22688 "<vpp-if-name> | sw_if_index <id>") \
22689 _(sw_interface_tap_dump, "") \
22691 "name <name> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22693 "<vpp-if-name> | sw_if_index <id>") \
22694 _(sw_interface_tap_v2_dump, "") \
22695 _(ip_table_add_del, \
22696 "table-id <n> [ipv6]\n") \
22697 _(ip_add_del_route, \
22698 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22699 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22700 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22701 "[multipath] [count <n>]") \
22702 _(ip_mroute_add_del, \
22703 "<src> <grp>/<mask> [table-id <n>]\n" \
22704 "[<intfc> | sw_if_index <id>] [local] [del]") \
22705 _(mpls_table_add_del, \
22706 "table-id <n>\n") \
22707 _(mpls_route_add_del, \
22708 "<label> <eos> via <addr> [table-id <n>]\n" \
22709 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22710 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22711 "[multipath] [count <n>]") \
22712 _(mpls_ip_bind_unbind, \
22713 "<label> <addr/len>") \
22714 _(mpls_tunnel_add_del, \
22715 " via <addr> [table-id <n>]\n" \
22716 "sw_if_index <id>] [l2] [del]") \
22717 _(bier_table_add_del, \
22718 "<label> <sub-domain> <set> <bsl> [del]") \
22719 _(bier_route_add_del, \
22720 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22721 "[<intfc> | sw_if_index <id>]" \
22722 "[weight <n>] [del] [multipath]") \
22723 _(proxy_arp_add_del, \
22724 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22725 _(proxy_arp_intfc_enable_disable, \
22726 "<intfc> | sw_if_index <id> enable | disable") \
22727 _(sw_interface_set_unnumbered, \
22728 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22729 _(ip_neighbor_add_del, \
22730 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22731 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22732 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22733 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22734 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22735 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22736 "[outer_vlan_id_any][inner_vlan_id_any]") \
22737 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22738 _(reset_fib, "vrf <n> [ipv6]") \
22739 _(dhcp_proxy_config, \
22740 "svr <v46-address> src <v46-address>\n" \
22741 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22742 _(dhcp_proxy_set_vss, \
22743 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22744 _(dhcp_proxy_dump, "ip6") \
22745 _(dhcp_client_config, \
22746 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22747 _(set_ip_flow_hash, \
22748 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22749 _(sw_interface_ip6_enable_disable, \
22750 "<intfc> | sw_if_index <id> enable | disable") \
22751 _(sw_interface_ip6_set_link_local_address, \
22752 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22753 _(ip6nd_proxy_add_del, \
22754 "<intfc> | sw_if_index <id> <ip6-address>") \
22755 _(ip6nd_proxy_dump, "") \
22756 _(sw_interface_ip6nd_ra_prefix, \
22757 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22758 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22759 "[nolink] [isno]") \
22760 _(sw_interface_ip6nd_ra_config, \
22761 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22762 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22763 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22764 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22765 _(l2_patch_add_del, \
22766 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22767 "enable | disable") \
22768 _(sr_localsid_add_del, \
22769 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22770 "fib-table <num> (end.psp) sw_if_index <num>") \
22771 _(classify_add_del_table, \
22772 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22773 " [del] [del-chain] mask <mask-value>\n" \
22774 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22775 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22776 _(classify_add_del_session, \
22777 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22778 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22779 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22780 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22781 _(classify_set_interface_ip_table, \
22782 "<intfc> | sw_if_index <nn> table <nn>") \
22783 _(classify_set_interface_l2_tables, \
22784 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22785 " [other-table <nn>]") \
22786 _(get_node_index, "node <node-name") \
22787 _(add_node_next, "node <node-name> next <next-node-name>") \
22788 _(l2tpv3_create_tunnel, \
22789 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22790 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22791 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22792 _(l2tpv3_set_tunnel_cookies, \
22793 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22794 "[new_remote_cookie <nn>]\n") \
22795 _(l2tpv3_interface_enable_disable, \
22796 "<intfc> | sw_if_index <nn> enable | disable") \
22797 _(l2tpv3_set_lookup_key, \
22798 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22799 _(sw_if_l2tpv3_tunnel_dump, "") \
22800 _(vxlan_add_del_tunnel, \
22801 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22802 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22803 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22804 _(geneve_add_del_tunnel, \
22805 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22806 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22807 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22808 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22809 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22810 _(gre_add_del_tunnel, \
22811 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22812 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22813 _(l2_fib_clear_table, "") \
22814 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22815 _(l2_interface_vlan_tag_rewrite, \
22816 "<intfc> | sw_if_index <nn> \n" \
22817 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22818 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22819 _(create_vhost_user_if, \
22820 "socket <filename> [server] [renumber <dev_instance>] " \
22821 "[mac <mac_address>]") \
22822 _(modify_vhost_user_if, \
22823 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22824 "[server] [renumber <dev_instance>]") \
22825 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22826 _(sw_interface_vhost_user_dump, "") \
22827 _(show_version, "") \
22828 _(vxlan_gpe_add_del_tunnel, \
22829 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22830 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22831 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22832 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22833 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22834 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22835 _(interface_name_renumber, \
22836 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22837 _(input_acl_set_interface, \
22838 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22839 " [l2-table <nn>] [del]") \
22840 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22841 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22842 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22843 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22844 _(ip_dump, "ipv4 | ipv6") \
22845 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22846 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22848 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22849 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22850 " integ_alg <alg> integ_key <hex>") \
22851 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22852 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22853 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22854 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22855 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22856 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22857 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22858 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22859 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22860 _(ipsec_sa_dump, "[sa_id <n>]") \
22861 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22862 " <alg> <hex>\n") \
22863 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22864 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22865 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22866 "(auth_data 0x<data> | auth_data <data>)") \
22867 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22868 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22869 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22870 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22871 "(local|remote)") \
22872 _(ikev2_set_local_key, "file <absolute_file_path>") \
22873 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22874 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22875 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22876 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22877 _(ikev2_initiate_sa_init, "<profile_name>") \
22878 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22879 _(ikev2_initiate_del_child_sa, "<ispi>") \
22880 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22881 _(delete_loopback,"sw_if_index <nn>") \
22882 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22883 _(map_add_domain, \
22884 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22885 "ip6-src <ip6addr> " \
22886 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22887 _(map_del_domain, "index <n>") \
22888 _(map_add_del_rule, \
22889 "index <n> psid <n> dst <ip6addr> [del]") \
22890 _(map_domain_dump, "") \
22891 _(map_rule_dump, "index <map-domain>") \
22892 _(want_interface_events, "enable|disable") \
22893 _(want_stats,"enable|disable") \
22894 _(get_first_msg_id, "client <name>") \
22895 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22896 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22897 "fib-id <nn> [ip4][ip6][default]") \
22898 _(get_node_graph, " ") \
22899 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22900 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22901 _(ioam_disable, "") \
22902 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22903 " sw_if_index <sw_if_index> p <priority> " \
22904 "w <weight>] [del]") \
22905 _(one_add_del_locator, "locator-set <locator_name> " \
22906 "iface <intf> | sw_if_index <sw_if_index> " \
22907 "p <priority> w <weight> [del]") \
22908 _(one_add_del_local_eid,"vni <vni> eid " \
22909 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22910 "locator-set <locator_name> [del]" \
22911 "[key-id sha1|sha256 secret-key <secret-key>]")\
22912 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22913 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22914 _(one_enable_disable, "enable|disable") \
22915 _(one_map_register_enable_disable, "enable|disable") \
22916 _(one_map_register_fallback_threshold, "<value>") \
22917 _(one_rloc_probe_enable_disable, "enable|disable") \
22918 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22920 "rloc <locator> p <prio> " \
22921 "w <weight> [rloc <loc> ... ] " \
22922 "action <action> [del-all]") \
22923 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22925 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22926 _(one_use_petr, "ip-address> | disable") \
22927 _(one_map_request_mode, "src-dst|dst-only") \
22928 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22929 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22930 _(one_locator_set_dump, "[local | remote]") \
22931 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22932 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22933 "[local] | [remote]") \
22934 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22935 _(one_ndp_bd_get, "") \
22936 _(one_ndp_entries_get, "bd <bridge-domain>") \
22937 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22938 _(one_l2_arp_bd_get, "") \
22939 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22940 _(one_stats_enable_disable, "enable|disalbe") \
22941 _(show_one_stats_enable_disable, "") \
22942 _(one_eid_table_vni_dump, "") \
22943 _(one_eid_table_map_dump, "l2|l3") \
22944 _(one_map_resolver_dump, "") \
22945 _(one_map_server_dump, "") \
22946 _(one_adjacencies_get, "vni <vni>") \
22947 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22948 _(show_one_rloc_probe_state, "") \
22949 _(show_one_map_register_state, "") \
22950 _(show_one_status, "") \
22951 _(one_stats_dump, "") \
22952 _(one_stats_flush, "") \
22953 _(one_get_map_request_itr_rlocs, "") \
22954 _(one_map_register_set_ttl, "<ttl>") \
22955 _(one_set_transport_protocol, "udp|api") \
22956 _(one_get_transport_protocol, "") \
22957 _(one_enable_disable_xtr_mode, "enable|disable") \
22958 _(one_show_xtr_mode, "") \
22959 _(one_enable_disable_pitr_mode, "enable|disable") \
22960 _(one_show_pitr_mode, "") \
22961 _(one_enable_disable_petr_mode, "enable|disable") \
22962 _(one_show_petr_mode, "") \
22963 _(show_one_nsh_mapping, "") \
22964 _(show_one_pitr, "") \
22965 _(show_one_use_petr, "") \
22966 _(show_one_map_request_mode, "") \
22967 _(show_one_map_register_ttl, "") \
22968 _(show_one_map_register_fallback_threshold, "") \
22969 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22970 " sw_if_index <sw_if_index> p <priority> " \
22971 "w <weight>] [del]") \
22972 _(lisp_add_del_locator, "locator-set <locator_name> " \
22973 "iface <intf> | sw_if_index <sw_if_index> " \
22974 "p <priority> w <weight> [del]") \
22975 _(lisp_add_del_local_eid,"vni <vni> eid " \
22976 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22977 "locator-set <locator_name> [del]" \
22978 "[key-id sha1|sha256 secret-key <secret-key>]") \
22979 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22980 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22981 _(lisp_enable_disable, "enable|disable") \
22982 _(lisp_map_register_enable_disable, "enable|disable") \
22983 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22984 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22986 "rloc <locator> p <prio> " \
22987 "w <weight> [rloc <loc> ... ] " \
22988 "action <action> [del-all]") \
22989 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22991 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22992 _(lisp_use_petr, "<ip-address> | disable") \
22993 _(lisp_map_request_mode, "src-dst|dst-only") \
22994 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22995 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22996 _(lisp_locator_set_dump, "[local | remote]") \
22997 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22998 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22999 "[local] | [remote]") \
23000 _(lisp_eid_table_vni_dump, "") \
23001 _(lisp_eid_table_map_dump, "l2|l3") \
23002 _(lisp_map_resolver_dump, "") \
23003 _(lisp_map_server_dump, "") \
23004 _(lisp_adjacencies_get, "vni <vni>") \
23005 _(gpe_fwd_entry_vnis_get, "") \
23006 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23007 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23008 "[table <table-id>]") \
23009 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23010 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23011 _(gpe_set_encap_mode, "lisp|vxlan") \
23012 _(gpe_get_encap_mode, "") \
23013 _(lisp_gpe_add_del_iface, "up|down") \
23014 _(lisp_gpe_enable_disable, "enable|disable") \
23015 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23016 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23017 _(show_lisp_rloc_probe_state, "") \
23018 _(show_lisp_map_register_state, "") \
23019 _(show_lisp_status, "") \
23020 _(lisp_get_map_request_itr_rlocs, "") \
23021 _(show_lisp_pitr, "") \
23022 _(show_lisp_use_petr, "") \
23023 _(show_lisp_map_request_mode, "") \
23024 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23025 _(af_packet_delete, "name <host interface name>") \
23026 _(policer_add_del, "name <policer name> <params> [del]") \
23027 _(policer_dump, "[name <policer name>]") \
23028 _(policer_classify_set_interface, \
23029 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23030 " [l2-table <nn>] [del]") \
23031 _(policer_classify_dump, "type [ip4|ip6|l2]") \
23032 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
23033 "[master|slave]") \
23034 _(netmap_delete, "name <interface name>") \
23035 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
23036 _(mpls_fib_dump, "") \
23037 _(classify_table_ids, "") \
23038 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
23039 _(classify_table_info, "table_id <nn>") \
23040 _(classify_session_dump, "table_id <nn>") \
23041 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
23042 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
23043 "[template_interval <nn>] [udp_checksum]") \
23044 _(ipfix_exporter_dump, "") \
23045 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
23046 _(ipfix_classify_stream_dump, "") \
23047 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
23048 _(ipfix_classify_table_dump, "") \
23049 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
23050 _(sw_interface_span_dump, "[l2]") \
23051 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
23052 _(pg_create_interface, "if_id <nn>") \
23053 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
23054 _(pg_enable_disable, "[stream <id>] disable") \
23055 _(ip_source_and_port_range_check_add_del, \
23056 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
23057 _(ip_source_and_port_range_check_interface_add_del, \
23058 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23059 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23060 _(ipsec_gre_add_del_tunnel, \
23061 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23062 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23063 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23064 _(l2_interface_pbb_tag_rewrite, \
23065 "<intfc> | sw_if_index <nn> \n" \
23066 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23067 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23068 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23069 _(flow_classify_set_interface, \
23070 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23071 _(flow_classify_dump, "type [ip4|ip6]") \
23072 _(ip_fib_dump, "") \
23073 _(ip_mfib_dump, "") \
23074 _(ip6_fib_dump, "") \
23075 _(ip6_mfib_dump, "") \
23076 _(feature_enable_disable, "arc_name <arc_name> " \
23077 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23078 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23080 _(l2_xconnect_dump, "") \
23081 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23082 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23083 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23084 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23085 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23086 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23087 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23088 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23089 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23090 _(memfd_segment_create,"size <nnn>") \
23091 _(sock_init_shm, "size <nnn>") \
23092 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23093 _(dns_enable_disable, "[enable][disable]") \
23094 _(dns_name_server_add_del, "<ip-address> [del]") \
23095 _(dns_resolve_name, "<hostname>") \
23096 _(dns_resolve_ip, "<ip4|ip6>") \
23097 _(dns_name_server_add_del, "<ip-address> [del]") \
23098 _(dns_resolve_name, "<hostname>") \
23099 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23100 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23101 _(session_rules_dump, "") \
23102 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23104 /* List of command functions, CLI names map directly to functions */
23105 #define foreach_cli_function \
23106 _(comment, "usage: comment <ignore-rest-of-line>") \
23107 _(dump_interface_table, "usage: dump_interface_table") \
23108 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23109 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23110 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23111 _(dump_stats_table, "usage: dump_stats_table") \
23112 _(dump_macro_table, "usage: dump_macro_table ") \
23113 _(dump_node_table, "usage: dump_node_table") \
23114 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23115 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23116 _(echo, "usage: echo <message>") \
23117 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23118 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23119 _(help, "usage: help") \
23120 _(q, "usage: quit") \
23121 _(quit, "usage: quit") \
23122 _(search_node_table, "usage: search_node_table <name>...") \
23123 _(set, "usage: set <variable-name> <value>") \
23124 _(script, "usage: script <file-name>") \
23125 _(unset, "usage: unset <variable-name>")
23127 static void vl_api_##n##_t_handler_uni \
23128 (vl_api_##n##_t * mp) \
23130 vat_main_t * vam = &vat_main; \
23131 if (vam->json_output) { \
23132 vl_api_##n##_t_handler_json(mp); \
23134 vl_api_##n##_t_handler(mp); \
23137 foreach_vpe_api_reply_msg;
23138 #if VPP_API_TEST_BUILTIN == 0
23139 foreach_standalone_reply_msg;
23144 vat_api_hookup (vat_main_t * vam)
23147 vl_msg_api_set_handlers(VL_API_##N, #n, \
23148 vl_api_##n##_t_handler_uni, \
23150 vl_api_##n##_t_endian, \
23151 vl_api_##n##_t_print, \
23152 sizeof(vl_api_##n##_t), 1);
23153 foreach_vpe_api_reply_msg;
23154 #if VPP_API_TEST_BUILTIN == 0
23155 foreach_standalone_reply_msg;
23159 #if (VPP_API_TEST_BUILTIN==0)
23160 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23162 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23164 vam->function_by_name = hash_create_string (0, sizeof (uword));
23166 vam->help_by_name = hash_create_string (0, sizeof (uword));
23169 /* API messages we can send */
23170 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23171 foreach_vpe_api_msg;
23175 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23176 foreach_vpe_api_msg;
23179 /* CLI functions */
23180 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23181 foreach_cli_function;
23185 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23186 foreach_cli_function;
23190 #if VPP_API_TEST_BUILTIN
23191 static clib_error_t *
23192 vat_api_hookup_shim (vlib_main_t * vm)
23194 vat_api_hookup (&vat_main);
23198 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23202 * fd.io coding-style-patch-verification: ON
23205 * eval: (c-set-style "gnu")